C# Emitter.FindField方法代码示例

        public override void Compile(Emitter.Emitter emitter)
        {
            try
              {
            Resolve(emitter);

            if (!emitter.TypeIsParent(IdentifierType, Expression.GetExpressionType(emitter)))
              Error(String.Format(Resources.errAssignTypeMismatch, Expression.GetExpressionType(emitter), IdentifierType));
              }
              catch(CompilerException ex)
              {
            ex.AffixToLexem(Lexem);
            throw;
              }

              switch (Kind)
              {

            case IdentifierKind.StaticField:  Expression.Compile(emitter);
                                          emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break;

            case IdentifierKind.Field:        if (ExpressionPrefix != null)
                                            ExpressionPrefix.Compile(emitter);
                                          else
                                            emitter.EmitLoadThis();
                                          Expression.Compile(emitter);
                                          emitter.EmitSaveField(emitter.FindField(OwnerType, Name)); break;

            case IdentifierKind.Variable:     Expression.Compile(emitter);
                                          emitter.EmitSaveVariable(emitter.CurrentMethod.Scope.Find(Name)); break;

            case IdentifierKind.Parameter:    Expression.Compile(emitter);
                                          emitter.EmitSaveParameter(emitter.CurrentMethod.Parameters[Name].Id); break;
              }
        }

        public override void Compile(Emitter.Emitter emitter)
        {
            try
              {
            Resolve(emitter);
              }
              catch (CompilerException ex)
              {
            ex.AffixToLexem(Lexem);
            throw;
              }

              switch (Kind)
              {

            case IdentifierKind.StaticField:    emitter.EmitLoadField(emitter.FindField(OwnerType, Name)); break;

            case IdentifierKind.Field:          if(ExpressionPrefix != null)
                                              ExpressionPrefix.Compile(emitter);
                                            else
                                              emitter.EmitLoadThis();
                                            emitter.EmitLoadField(emitter.FindField(OwnerType, Name)); break;

            case IdentifierKind.StaticMethod:   emitter.EmitCall(emitter.FindMethod(OwnerType, Name)); break;

            case IdentifierKind.Method:         if (ExpressionPrefix != null)
                                              ExpressionPrefix.Compile(emitter);
                                            else
                                              emitter.EmitLoadThis();
                                            emitter.EmitCall(emitter.FindMethod(OwnerType, Name)); break;

            case IdentifierKind.Variable:       emitter.EmitLoadVariable(emitter.CurrentMethod.Scope.Find(Name)); break;

            case IdentifierKind.Parameter:      emitter.EmitLoadParameter(emitter.CurrentMethod.Parameters[Name].Id); break;

            case IdentifierKind.SizeProperty:   ExpressionPrefix.Compile(emitter);
                                            emitter.EmitLoadArraySize(); break;
              }
        }

        /// <summary>
        /// Emit code for saving local variables into fields
        /// </summary>
        private void SaveClosuredVariables(Emitter.Emitter emitter, Utils.ScopeVariable variable)
        {
            foreach (var curr in Closures)
              {
            emitter.EmitLoadVariable(variable);

            // load variable
            var currVar = emitter.CurrentMethod.Scope.Find(curr.Key);
            emitter.EmitLoadVariable(currVar);

            // save into field
            var currField = emitter.FindField(PlannerID, "_" + curr.Key);
            emitter.EmitSaveField(currField);
              }
        }

        /// <summary>
        /// Emit code for loading local variables from fields
        /// </summary>
        /// <param name="list">List of closures</param>
        private void LoadClosuredVariables(Dictionary<string, string> list, Emitter.Emitter emitter)
        {
            foreach (var curr in list)
              {
            emitter.EmitLoadThis();

            // load field
            var currField = emitter.FindField(PlannerID, "_" + curr.Key);
            emitter.EmitLoadField(currField);

            // save into variable
            var currVar = emitter.CurrentMethod.Scope.Introduce(curr.Value, emitter.ResolveType(curr.Value), curr.Key);
            emitter.EmitSaveVariable(currVar);
              }
        }

        /// <summary>
        /// Resolve the identifier meaning
        /// </summary>
        public void Resolve(Emitter.Emitter emitter)
        {
            // already resolved?
              if (Kind != IdentifierKind.Unresolved) return;

              // atmark?
              if (AtmarkPrefix)
              {
            if (emitter.CurrentType == null)
              Error(Resources.errFieldOutsideType);

            OwnerType = emitter.CurrentType.Name;

            var field = emitter.FindField(emitter.CurrentType.Name, Name);
            if (field != null)
              Kind = field.Static ? IdentifierKind.StaticField : IdentifierKind.Field;
            else
              Error(String.Format(Resources.errFieldNotFound, Name, emitter.CurrentType.Name));

            // additional check: dynamic field from static method
            if (emitter.CurrentMethod.Static && !field.Static)
              Error(String.Format(Resources.errDynamicFromStatic, field.Name));
              }

              // other prefix?
              else if (TypePrefix != null || ExpressionPrefix != null)
              {
            OwnerType = (TypePrefix != null ? TypePrefix.Data : ExpressionPrefix.GetExpressionType(emitter));

            if (OwnerType == "null")
              Error(Resources.errNullAccessor);

            if(OwnerType.EndsWith("[]") && Name == "size")
            {
              Kind = IdentifierKind.SizeProperty;
              return;
            }

            // check class existence
            emitter.FindType(OwnerType);

            // field ?
            try
            {
              emitter.FindField(OwnerType, Name);
              Kind = (TypePrefix != null ? IdentifierKind.StaticField : IdentifierKind.Field);
              return;
            }
            catch { }

            // method ?!
            MethodNode method = null;
            try
            {
              method = emitter.FindMethod(OwnerType, Name);
            }
            catch
            {
              Error(String.Format(Resources.errTypeIdentifierUnresolved, OwnerType, Name));
            }

            if (ExpressionPrefix == null && !method.Static)
              Error(String.Format(Resources.errNonStaticMethod, Name));

            Kind = (TypePrefix != null ? IdentifierKind.StaticMethod : IdentifierKind.Method);
              }

              else
              {
            MethodNode method = null;

            // local variable
            if (emitter.CurrentMethod.Scope.Exists(Name))
            {
              Kind = IdentifierKind.Variable;
              return;
            }

            // parameter
            if(emitter.CurrentMethod.Parameters.Contains(Name))
            {
              Kind = IdentifierKind.Parameter;
              return;
            }

            // search for a method
            try
            {
              method = emitter.FindMethod(emitter.CurrentType != null ? emitter.CurrentType.Name : "", true, Name);
            }
            catch
            {
              Error(String.Format(Resources.errIdentifierUnresolved, Name));
            }

            OwnerType = method.Owner.Name;
            if(method.Static)
//.........这里部分代码省略.........

        public override string GetExpressionType(Emitter.Emitter emitter)
        {
            if (ExpressionType != "")
            return ExpressionType;

              try
              {
            Resolve(emitter);
              }
              catch (CompilerException ex)
              {
            ex.AffixToLexem(Lexem);
            throw;
              }

              switch(Kind)
              {
            case IdentifierKind.StaticField:
            case IdentifierKind.Field: ExpressionType = emitter.FindField(OwnerType, Name).Type.Signature; break;
            case IdentifierKind.StaticMethod:
            case IdentifierKind.Method: ExpressionType = emitter.FindMethod(OwnerType, Name).Type.Signature; break;
            case IdentifierKind.Variable: ExpressionType = emitter.CurrentMethod.Scope.Find(Name).Type; break;
            case IdentifierKind.Parameter: ExpressionType = emitter.CurrentMethod.Parameters[Name].Type.Signature; break;
            case IdentifierKind.SizeProperty: ExpressionType = "int"; break;
              }

              return ExpressionType;
        }

        private void Resolve(Emitter.Emitter emitter)
        {
            // already resolved?
              if (Kind != IdentifierKind.Unresolved) return;

              // atmark?
              if (AtmarkPrefix)
              {
            OwnerType = emitter.CurrentType.Name;

            var field = emitter.FindField(emitter.CurrentType.Name, Name);
            if (field != null)
              Kind = field.Static ? IdentifierKind.StaticField : IdentifierKind.Field;
            else
              Error(String.Format(Resources.errFieldNotFound, Name, emitter.CurrentType.Name));

            // additional check: dynamic field from static method
            if (emitter.CurrentMethod.Static && !field.Static)
              Error(String.Format(Resources.errDynamicFromStatic, field.Name));

            IdentifierType = field.Type.Signature;
              }

              // other prefix?
              else if (TypePrefix != null || ExpressionPrefix != null)
              {
            OwnerType = (TypePrefix != null ? TypePrefix.Data : ExpressionPrefix.GetExpressionType(emitter));

            // check class existence
            var type = emitter.FindType(OwnerType);
            if (type == null)
              Error(String.Format(Resources.errTypeNotFound, OwnerType), TypePrefix);

            // field ?
            var field = emitter.FindField(OwnerType, Name);
            Kind = (TypePrefix != null ? IdentifierKind.StaticField : IdentifierKind.Field);
            IdentifierType = field.Type.Signature;
              }

              else
              {
            // local variable
            if (emitter.CurrentMethod.Scope.Exists(Name))
            {
              Kind = IdentifierKind.Variable;
              IdentifierType = emitter.CurrentMethod.Scope.Find(Name).Type;
            }

            // parameter
            else if (emitter.CurrentMethod.Parameters.Contains(Name))
            {
              Kind = IdentifierKind.Parameter;
              IdentifierType = emitter.CurrentMethod.Parameters[Name].Type.Signature;
            }

            // no luck at all
            else
              Error(String.Format(Resources.errIdentifierUnresolved, Name));
              }
        }

        /// <summary>
        /// Generate code to setup the currently defined emitter
        /// </summary>
        /// <param name="emitter"></param>
        private void CompileInitiation(Emitter.Emitter emitter)
        {
            var emitterType = emitter.FindType(EmitterID);
              var tmpVar = emitter.CurrentMethod.Scope.Introduce(EmitterID, emitterType.Type);

              // tmp = new emitterN()
              emitter.EmitNewObj(emitter.FindMethod(EmitterID, ".ctor"));
              emitter.EmitSaveVariable(tmpVar);

              // step
              if (Step != null)
              {
            // validate step
            var stepType = Step.GetExpressionType(emitter);
            if (!stepType.IsAnyOf("int", "float"))
              Error(Resources.errEmitStepExpected);

            // tmp.Step = step
            emitter.EmitLoadVariable(tmpVar);
            Step.Compile(emitter);
            if (stepType == "int")
              emitter.EmitConvertToFloat();
            emitter.EmitSaveField(emitter.FindField(EmitterID, "step"));
              }

              // distribution
              if (Distribution != null)
              {
            // validate distr
            if (Distribution.GetExpressionType(emitter) != "distr")
              Error(Resources.errEmitDistributionExpected);

            // tmp.Distr = distr
            emitter.EmitLoadVariable(tmpVar);
            Distribution.Compile(emitter);
            emitter.EmitSaveField(emitter.FindField(EmitterID, "distr"));
              }

              // limit
              if (Limit != null)
              {
            // validate distr
            if (Limit.GetExpressionType(emitter) != "int")
              Error(Resources.errEmitLimitExpected);

            // tmp.Distr = distr
            emitter.EmitLoadVariable(tmpVar);
            Limit.Compile(emitter);
            emitter.EmitSaveField(emitter.FindField(EmitterID, "limit"));
              }

              SaveClosuredVariables(emitter, tmpVar);

              // register emitter in the system
              emitter.EmitLoadVariable(tmpVar);
              var registerMethod = emitter.AssemblyImport(typeof(Simulation).GetMethod("RegisterEmitter", new[] { typeof(EventEmitter) }));
              emitter.EmitCall(registerMethod);
        }