public DeclareLocalStmtExp(TypeEntry t)
{
LocalVarExpEntry l = new LocalVarExpEntry();
l.m_strName = ".temp_local_" + m_count;
m_count++;
l.m_type = t;
m_exp = new LocalExp(l);
}
// 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()));
}
Debug.Assert(eResolved != null);
return eResolved;
}
