C# CodeBlock.Lookup方法代码示例

    public override Expression Generate(object args, CodeBlock cb)
    {
      SymbolId s = (SymbolId)Builtins.First(args);

      assigns[s] = true;

      if (libraryglobals.ContainsKey(s))
      {
        libraryglobals.Remove(s);
      }

      if (libraryglobalsN.ContainsKey(s))
      {
        libraryglobalsN.Remove(s);
      }

      if (libraryglobalsX.ContainsKey(s))
      {
        libraryglobalsX.Remove(s);
      }


      setstack.Push(s);

      NameHint = Builtins.UnGenSymInternal(s);
      var prevvh = VarHint;
      VarHint = s;
      Expression value = GetAst(Builtins.Second(args), cb);
      VarHint = prevvh;
      setstack.Pop();

      NameHint = SymbolId.Invalid;

      Variable v = cb.Lookup(s);
      Statement r = null;

      if (v == null)
      {
        r = Ast.Statement(Ast.SimpleCallHelper(SetSymbolValue, Ast.Constant(s), value));
      }
      else
      {
        //Trace.Assert(cb.Parent != null);
        value = Ast.ConvertHelper(value, v.Type);
        r = Ast.Write(v, value);
      }

      if (SpanHint != SourceSpan.Invalid || SpanHint != SourceSpan.None)
      {
        r.SetLoc(SpanHint);
      }

      return Ast.Void(r);
    }

    protected internal static Expression GetAst(object args, CodeBlock cb, bool istailposition)
    {
      if (args is Annotation)
      {
        args = ((Annotation)args).stripped;
      }
      Cons c = args as Cons;
      if (c != null)
      {

        if (c.car is SymbolId)
        {
          SymbolId f = (SymbolId)c.car;

          Variable var = cb.Lookup(f);

          if (var != null && !assigns.ContainsKey(f))
          {
            var = null;
          }

          object m;

#if OPTIMIZATIONS

#if !BLAH
          CodeBlockExpression cbe;

          //// needs to do the same for overloads...
          if (SimpleGenerator.libraryglobals.TryGetValue(f, out cbe))
          {
            Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);

            if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount == ppp.Length)
            {
              //inline here? we could for simple bodies, but we need to copy the entire structure
              if (!(cbe.Block.HasEnvironment || cbe.Block.IsClosure))
              {
                if (cbe.Block.Body is ReturnStatement)
                {
                  ReturnStatement rs = (ReturnStatement)cbe.Block.Body;

                  if (!ScriptDomainManager.Options.DebugMode && 
                    !ScriptDomainManager.Options.LightweightDebugging && 
                    !cb.IsGlobal && IsSimpleExpression(rs.Expression))
                  {
                    return InlineCall(cb, Ast.CodeBlockExpression(RewriteBody(cbe.Block), false, cbe.IsStronglyTyped), ppp);
                  }
                }
              }
              if (cbe.Block != cb.Parent && cbe.Block != cb) // do TCE later
              {
                return CallNormal(cbe, ppp);
              }
            }
          }

          // varargs
          if (SimpleGenerator.libraryglobalsX.TryGetValue(f, out cbe))
          {
            Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);

            if (cbe.Block.ParameterCount < 9 && cbe.Block.ParameterCount - 1 <= ppp.Length)
            {
              //inline here?
              return CallVarArgs(cbe, ppp);
            }
          }

          // overloads
          CodeBlockDescriptor[] cbd;
          if (SimpleGenerator.libraryglobalsN.TryGetValue(f, out cbd))
          {
            Expression[] ppp = GetAstListNoCast(c.cdr as Cons, cb);

            foreach (CodeBlockDescriptor d in cbd)
            {
              if (d.codeblock.Block.ParameterCount < 9)
              {
                if (ppp.Length == d.arity || (d.varargs && ppp.Length > d.arity))
                {
                  if (d.varargs)
                  {
                    //inline here?
                    return CallVarArgs(d.codeblock, ppp);
                  }
                  else
                  {
                    //inline here?
                    //if (d.codeblock.Block != cb.Parent && d.codeblock.Block != cb) // do TCE later, not yet
                    {
                      return CallNormal(d.codeblock, ppp);
                    }
                  }
                }
              }
            }
          }
#endif

//.........这里部分代码省略.........

    static Expression RewriteExpression(CodeBlock cb, Expression e)
    {
      if (e is MethodCallExpression)
      {
        MethodCallExpression mce = (MethodCallExpression)e;
        List<Expression> args = new List<Expression>();
        foreach (var arg in mce.Arguments)
        {
          args.Add(RewriteExpression(cb, arg));
        }

        return Ast.Call(RewriteExpression(cb, mce.Instance), mce.Method, args.ToArray());
      }
      if (e is BoundExpression)
      {
        BoundExpression be = (BoundExpression)e;
        return Ast.Read(cb.Lookup(be.Variable.Name));
      }

      if (e is BinaryExpression)
      {
        BinaryExpression be = (BinaryExpression)e;
        return new BinaryExpression(be.NodeType, RewriteExpression(cb, be.Left), RewriteExpression(cb, be.Right));
      }

      if (e is UnaryExpression)
      {
        UnaryExpression ue = (UnaryExpression)e;
        if (ue.NodeType == AstNodeType.Convert)
        {
          return Ast.ConvertHelper(RewriteExpression(cb, ue.Operand), ue.Type);
        }
        return null;
      }

      if (e is TypeBinaryExpression)
      {
        TypeBinaryExpression tbe = (TypeBinaryExpression)e;
        return Ast.TypeIs(RewriteExpression(cb, tbe.Expression), tbe.TypeOperand);
      }

      if (e is ConditionalExpression)
      {
        ConditionalExpression ce = (ConditionalExpression)e;
        return Ast.Condition(RewriteExpression(cb, ce.Test), RewriteExpression(cb, ce.IfTrue), RewriteExpression(cb, ce.IfFalse));
      }

      return e;
    }

        static Expression Read(SymbolId name, CodeBlock cb, Type type)
        {
            SymbolId sname = name;

              Variable v = cb.Lookup(sname);

              if (v == null)
              {
            if (assigns.ContainsKey(sname))
            {
              return Ast.Read(sname);
            }
            else
            {
              CodeBlock tl = GetTopLevel(cb);
              v = tl.CreateVariable(sname, Variable.VariableKind.Global, typeof(object), Ast.Read(sname));
              return Ast.Read(v);
            }
              }

              return Ast.ReadDefined(v);
        }