C# ISemanticResolver.LookupSymbolWithContext方法代码示例

 public override void ResolveStatement2(ISemanticResolver s)
 {       
 // Since we're doing this on a second pass, all labels must have been added
     m_symbol = (LabelEntry) s.EnsureSymbolType(
         s.LookupSymbolWithContext(m_label, true), 
         typeof(LabelEntry), 
         m_label.Location);
 }

 // An ObjExp is just a temporary node. But that's the best a Context-Free parse can
 // do. So now that we're building a symbol table, we can do a Context-Sensitive resolution
 // and figure out what type of node this really is.
 public Exp GetResolvedNode(ISemanticResolver s, bool fRight)
 {   
     Exp eResolved = null;
     
     // Lookup the symbol and determine what we are
     //SymEntry sym = s.LookupSymbol(this.m_strId, true);
     string stName = this.m_strId.Text;
     SymEntry sym = s.LookupSymbolWithContext(this.m_strId, false); // allow methods
     
     // Namespace
     if (sym is NamespaceEntry)
     {
         eResolved = new NamespaceExp(sym as NamespaceEntry);
     }
     
     // Local Variable
     else if (sym is LocalVarExpEntry)
     {
         eResolved = new LocalExp(sym as LocalVarExpEntry);
     }
     
     // Parameter
     else if (sym is ParamVarExpEntry)
     {
         eResolved = new ParamExp(sym as ParamVarExpEntry);   
     }
     
     // A type name
     else if (sym is TypeEntry)
     {
         eResolved = new TypeExp(sym as TypeEntry);
     }
     
     // A field (w/ an implied 'this' pointer)
     else if (sym is FieldExpEntry)
     {
         // When a single identifier resolves to a field, it can be either
         // an instance field with an implied 'this' ref, or a static field of this class.
         FieldExpEntry f = sym as FieldExpEntry;
         Exp expInstance = null;
         if (!f.IsStatic)
         {
             expInstance = new SimpleObjExp("this");
             Exp.ResolveExpAsRight(ref expInstance, s);
         }
         eResolved = new FieldExp(f, expInstance);
     }
     
     // An event (w/ an implied 'this' ptr)
     else if (sym is EventExpEntry)
     {
         EventExpEntry e = (EventExpEntry) sym;
         Exp expInstance = null;
         if (!e.Mods.IsStatic)
         {
             expInstance = new SimpleObjExp("this");
             Exp.ResolveExpAsRight(ref expInstance, s);
         }
         eResolved = new EventExp(e, expInstance);            
     }
     
     // A property (w/ an implied 'this' ptr).
     // Properties will eventually be converted into method calls.
     else if (sym is PropertyExpEntry)
     {
         PropertyExpEntry p = (PropertyExpEntry) sym;
         
         Exp expInstance = null;
         if (!p.IsStatic)            
         {
             expInstance = new SimpleObjExp("this");
             Exp.ResolveExpAsRight(ref expInstance, s);
         }
         
         eResolved = new PropertyExp(p, expInstance);
     }
     
     // Not recognized.
     else {
         if (stName == "this") // check a common error case...            
             Debug.Assert(false, "Can't access 'this'. Are we in a static?");
         
         if (sym == null)
         {
             MethodHeaderEntry h = s.GetCurrentClass().LookupMethodHeader(this.m_strId.Text);
             if (h != null)
             {                    
                 return this;
             }
             
             ThrowError(SymbolError.UndefinedSymbol(m_strId));
             //Debug.Assert(false, "Unknown name in SimpleObjExp:" + stName);
         }
         Debug.Assert(false, "Unknown symbol type:" + ((sym == null) ? "null" : sym.ToString()));
     }
     
     
//.........这里部分代码省略.........