예제 #1
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 // Resolve expression as a RHS value. The exp node can totally change on us
 // (operator overloading, constant folding, etc), so we must pass as a ref
 public static void ResolveExpAsRight(ref Exp e, ISemanticResolver s)
 {
     // Debugging helper. Useful when we want to break when resolving 
     // a particular symbol.
     
     #if false   
          
     // Set lTarget to a symbol that we want to see resolved.
     FileRange lTarget = new FileRange("SemanticChecker.cs", 143, 39, 143, 43);
     if (lTarget.Equals(e.Location))
     {
         System.Diagnostics.Debugger.Break();
     }
     
     #endif
     e = e.ResolveExpAsRight(s);
     Debug.Assert(e != null);
 }
예제 #2
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
    // Use this when we already have a static method to call
    // and we already have the symbols
    public MethodCallExp(
        Exp eInstance, // null if static       
        MethodExpEntry  symMethod,
        ArgExp [] arParams,
        ISemanticResolver s
    )
    {
        this.m_idName = new Identifier(symMethod.Name);
        m_arParams = arParams;
        m_symbol = symMethod;
        
        // Spoof Left
        if (eInstance == null)
        {
            //m_objExp = new SimpleObjExp(symMethod.SymbolClass.Name);
            m_objExp = new TypeExp(symMethod.SymbolClass);
        }
        else
            m_objExp = eInstance;
            
        Exp.ResolveExpAsRight(ref m_objExp, s);

        // Resolve args, just in case
        foreach(ArgExp eArg in arParams)
        {
            Exp e = eArg;
            Exp.ResolveExpAsRight(ref e, s);
            Debug.Assert(e == eArg);
        }   
        
        //ResolveAsExpEntry(m_symbol, s);
        CalcCLRType(s);
    }
예제 #3
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public AssignStmtExp(Exp expLeft, Exp expRight)
 {
     Debug.Assert(expLeft != null);
     Debug.Assert(expRight != null);
 
     m_oeLeft = expLeft;
     m_expRight = expRight;
 
     //m_filerange = FileRange.Merge(expLeft.Location, expRight.Location);
 }
예제 #4
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 //.........................................................................
 // Semantic resolution. Resolve the exp as either a LHS or RHS value.
 //.........................................................................
 
 // Resolve the expression as a LHS value
 public static void ResolveExpAsLeft(ref Exp e, ISemanticResolver s)
 {
     e = e.ResolveExpAsLeft(s);
     Debug.Assert(e != null);
 }
예제 #5
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public BinaryExp(Exp left, Exp right, BinaryOp op)
 {
     Debug.Assert(left != null);
     Debug.Assert(right != null);
     
     //m_filerange = FileRange.Merge(left.Location, right.Location);
     
     m_left = left;
     m_right = right;
     m_op = op;
 }
예제 #6
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public UnaryExp(Exp left, UnaryOp op)
 {
     Debug.Assert(left != null);
         
     m_filerange = left.Location;
 
     m_left = left;        
     m_op = op;
 }
예제 #7
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public NewArrayObjExp(
     ArrayTypeSig tArrayType,    // full array type (includes rank)
     Exp [] arExpSize,           // rank to allocate, eval at runtime
     ArrayInitializer aInit      // optional initilizer list        
 )
 {
     Debug.Assert(tArrayType != null);
     Debug.Assert(arExpSize != null);
     
     m_tFullType = tArrayType;
     this.m_arExpList = arExpSize;
     this.m_ArrayInit = aInit;
     
     // @todo - this is wrong
     m_filerange = tArrayType.Location;
 }        
예제 #8
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
    public IsExp(
        Exp expTest,
        TypeSig tTarget
    )
    {
        Debug.Assert(expTest != null);
        Debug.Assert(tTarget != null);

        m_expTest = expTest;
        m_tTarget = tTarget;

        //m_filerange = FileRange.Merge(expTest.Location, tTarget.Location);
    }
예제 #9
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public BaseCastObjExp(
     TypeSig tTargetType,
     Exp expSource
     )
 {
     m_tTargetType = tTargetType;
     m_expSource = expSource;
     
     Debug.Assert(m_tTargetType != null);
     Debug.Assert(m_expSource != null);
     
     // @todo - have parser resolve this
     //m_filerange = FileRange.Merge(expSource.Location, m_tTargetType.Location);
 }
예제 #10
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public NewObjExp(
     TypeSig tType,
     Exp [] arParams
 )
 {
     Debug.Assert(tType != null);
     Debug.Assert(arParams != null);
     
     m_tType = tType;
     m_arParams = arParams;
     
     // @todo- this is wrong
     m_filerange = tType.Location;                
 }
예제 #11
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public CastObjExp(
     TypeSig tTargetType,
     Exp expSource
     ) 
     : base(tTargetType, expSource)
 {
 }
예제 #12
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public AsExp(
     TypeSig tTargetType,
     Exp expSource
     ) 
     : base(tTargetType, expSource)
 {
 }
예제 #13
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
    // Semantic resolution
    protected override Exp ResolveExpAsRight(ISemanticResolver s)
    {   
        // Only resolve once.     
        if (m_symbol != null)
            return this;
            
        // First, resolve our parameters (because of overloading)
        // We need to know the URT types for our parameters
        // in order to resolve between overloaded operators
        
        Type [] alParamTypes = new Type[m_arParams.Length];
        
        
        for(int i = 0; i < m_arParams.Length; i++)        
        {
            Exp e = m_arParams[i];
            ResolveExpAsRight(ref e, s);
            Debug.Assert(e == m_arParams[i]);
            
            Type tParam = e.CLRType;
            
            //if ((tParam !=null) && tParam.IsByRef)
            //    tParam = tParam.GetElementType();
            
            alParamTypes[i] = tParam;
            //Debug.Assert(alParamTypes[i] != null);
            
        }   
        
        TypeEntry tCur = s.GetCurrentClass();    
        TypeEntry tLeft = null; // Type to lookup in   
        
        // Is this a 'base' access?
        // Convert to the real type and set a non-virtual flag
        if (m_objExp is SimpleObjExp)
        {
            SimpleObjExp e = m_objExp as SimpleObjExp;
            if (e.Name.Text == "base")
            {
                // Set the scope that we lookup in.
                tLeft = tCur.Super;
                
                // Still need to resolve the expression.
                m_objExp = new SimpleObjExp("this");               
                                               
                m_fIsNotPolymorphic = true;
            }
        }
        
#if true
        // See if we have a delegate here
        Exp eDelegate = null;
        if (m_objExp == null)
        {
            Exp e = new SimpleObjExp(m_idName);
            Exp.ResolveExpAsRight(ref e, s);
            if (!(e is SimpleObjExp))                
                eDelegate = e;
        } else {
            // If it's an interface, then we know we can't have a delegate field on it, 
            // so short-circuit now. 
            Exp.ResolveExpAsRight(ref m_objExp, s);
            if (!m_objExp.CLRType.IsInterface)
            {                
                Exp e = new DotObjExp(m_objExp, m_idName);
                Exp.ResolveExpAsRight(ref e, s);
                if (!(e is DotObjExp))                
                    eDelegate = e;        
            }
        }

        if (eDelegate != null)
        {
            if (!DelegateDecl.IsDelegate(eDelegate.CLRType))
            {
                //Debug.Assert(false, "@todo - " + m_strName + " is not a delegate or function"); // @todo - legit
                // Just fall through for now, method resolution will decide if this is a valid function
            } else 
            {            
                Exp e = new MethodCallExp(
                    eDelegate, 
                    new Identifier("Invoke"), 
                    this.m_arParams
                );
                
                Exp.ResolveExpAsRight(ref e, s);
                return e;        
            }
        }        
#endif    
        // No delegate, carry on with a normal function call
                        
        // If there's no objexp, then the function is a method
        // of the current class. 
        // make it either a 'this' or a static call
        if (m_objExp == null)
        {   
            // Lookup
            bool fIsVarArgDummy;
            MethodExpEntry sym = tCur.LookupMethod(s, m_idName, alParamTypes, out fIsVarArgDummy);
            
            if (sym.IsStatic)
            {                
                m_objExp = new TypeExp(tCur);
            } else {
                m_objExp = new SimpleObjExp("this");
            }
        }
        
        // Need to Lookup m_strName in m_objExp's scope (inherited scope)
        Exp.ResolveExpAsRight(ref m_objExp, s);
                    
                
        // Get type of of left side object
        // This call can either be a field on a variable
        // or a static method on a class
        
        bool fIsStaticMember = false;
        
        // If we don't yet know what TypeEntry this methodcall is on, then figure
        // it out based off the expression
        if (tLeft == null)
        {
            if (m_objExp is TypeExp)
            {
                fIsStaticMember = true;
                tLeft = ((TypeExp) m_objExp).Symbol;
            } else {
                fIsStaticMember = false;
                tLeft = s.ResolveCLRTypeToBlueType(m_objExp.CLRType);
            }
        }
        
        // Here's the big lookup. This will jump through all sorts of hoops to match
        // parameters, search base classes, do implied conversions, varargs, 
        // deal with abstract, etc.
        bool fIsVarArg;
        m_symbol = tLeft.LookupMethod(s, m_idName, alParamTypes, out fIsVarArg);
        Debug.Assert(m_symbol != null);
        
        if (m_fIsNotPolymorphic)
        {
            // of the form 'base.X(....)'
            if (m_symbol.IsStatic)
                ThrowError(SymbolError.BaseAccessCantBeStatic(this.Location, m_symbol)); // @todo - PrintError?
        } else {
            // normal method call
            /*
            if (fIsStaticMember && !m_symbol.IsStatic)
                ThrowError(SymbolError.ExpectInstanceMember(this.Location)); // @todo - PrintError?
            else if (!fIsStaticMember && m_symbol.IsStatic)                
                ThrowError(SymbolError.ExpectStaticMember(this.Location)); // @todo - PrintError?
            */
            Debug.Assert(fIsStaticMember == m_symbol.IsStatic, "@todo - user error. Mismatch between static & instance members on line.");
        }
        
        
        // If we have a vararg, then transform it 
        if (fIsVarArg)
        {
        // Create the array
            int cDecl = m_symbol.ParamCount;
            int cCall = this.ParamExps.Length;
            
            ArrayTypeSig tSig = new ArrayTypeSig(m_symbol.ParamCLRType(cDecl - 1), s);
            
            Node [] list = new Node[cCall - cDecl + 1];
            for(int i = 0; i < list.Length; i++)
            {
                list[i] = this.ParamExps[i + cDecl - 1];
            }
            
            Exp eArray = new NewArrayObjExp(
                tSig,
                new ArrayInitializer(
                    list
                )
            );
            
            Exp.ResolveExpAsRight(ref eArray, s);
            
        // Change the parameters to use the array    
            ArgExp [] arParams = new ArgExp[cDecl];
            for(int i = 0; i < cDecl - 1; i++)
                arParams[i] = m_arParams[i];
            arParams[cDecl - 1] = new ArgExp(EArgFlow.cIn, eArray);
            
            m_arParams = arParams;                            
        } // end vararg transformation
                
        this.CalcCLRType(s);
   
        return this;
    }
예제 #14
0
파일: AST.cs 프로젝트: chenzuo/blue
    // For search path
    public UsingDirective(Exp eNamespace)
    {
        Debug.Assert(eNamespace != null);

        m_stAlias = null;
        m_eNamespace = eNamespace;
    }
예제 #15
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public ArrayAccessExp(
     Exp expLeft,
     Exp expIndex
     )
 {
     Debug.Assert(expLeft != null);
     Debug.Assert(expIndex != null);
 
     m_oeLeft = expLeft;
     m_expIndex = expIndex;
 
     // @todo- this is wrong
     m_filerange = m_oeLeft.Location;                
 }
예제 #16
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public IfExp(
     Exp expTest,
     Exp expTrue,
     Exp expFalse
 )
 {
     Debug.Assert(expTest != null);
     Debug.Assert(expTrue != null);
     Debug.Assert(expFalse != null);
     
     m_expTest = expTest;
     m_expTrue = expTrue;
     m_expFalse = expFalse;
 }
예제 #17
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public FieldExp(
     FieldExpEntry symbol,
     Exp expInstance // null for statics
 )
 {
     Debug.Assert(symbol != null);
     m_symbol = symbol;
     m_expInstance = expInstance;
 }
예제 #18
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 // @todo - not really working yet. We don't do constant folding.
 //.........................................................................
 // Simplifying an expression that we pass in. Pass out the simplified
 // expression (or the same thing we passed in if we can't simplify)
 //.........................................................................
 public static void TrySimplify(ref Exp e)
 {
     e = e.TrySimplify();
 }
예제 #19
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public DotObjExp(Exp left, Identifier id)
 {
     m_left = left;
     m_strId = id;
     
     m_filerange = id.Location;
 }
예제 #20
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 // Return true iff the given expression is allowed to have a null type
 public static bool CanBeNullType(Exp e)
 {
     return (e is NullExp) || (e is IfExp) || (e is ArgExp) || (e is NamespaceExp);
 }
예제 #21
0
파일: TypeAST.cs 프로젝트: chenzuo/blue
 public SimpleTypeSig(Exp e)
 {
     if (e != null)
         m_filerange = e.Location;
         
     m_oeValue = e;           
 }
예제 #22
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public ArgExp(AST.EArgFlow eFlow, Exp exp)
 {
     Debug.Assert(exp != null);        
     Debug.Assert(!(exp is ArgExp), "ArgExp should never wrap an ArgExp");
     m_exp = exp;
     m_eFlow = eFlow;
 }
예제 #23
0
 public ThrowStatement(
     Exp oeException // can be null for a rethrow
 )
 {        
     m_oeException = oeException;
 }
예제 #24
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 // <e0, e1, e2 .... en>
 // e_0 .. e_n-1 are StatementExp, that generate as Statements (to produce side effects)
 // e_n is a normal expression, generated as an expression, to produce a value
 public CompoundStmtExp(
     StatementExp [] eList,
     Exp eLast
 )
 {
     Debug.Assert(eList != null);
     Debug.Assert(eLast != null);
     
     m_eList = eList;
     m_eLast = eLast;
 }        
예제 #25
0
 public SwitchStatement(
     Exp expTest,
     SwitchSection [] sections
 )
 {
     m_expTest = expTest;
     m_sections = sections;
     
     m_proxy = null;
 }
예제 #26
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public OpEqualStmtExp(Exp expLeft, Exp expRight, BinaryExp.BinaryOp op)
 {   
     Debug.Assert(false, "OpEqualStmtExp is obsolete"); //
     m_op = op;
     m_eLeft = expLeft;
     m_expRight = expRight;        
 }
예제 #27
0
파일: AST.cs 프로젝트: chenzuo/blue
    // For alias
    public UsingDirective(string stAlias, Exp eNamespace)
    {
        Debug.Assert(stAlias != null);
        Debug.Assert(eNamespace != null);

        m_stAlias = stAlias;
        m_eNamespace = eNamespace;
    }
예제 #28
0
파일: ExpAST.cs 프로젝트: chenzuo/blue
 public PrePostIncDecStmtExp(
     Exp e,
     bool fPre, bool fInc)
 {
     m_exp = e;
     m_fPre = fPre;
     m_fInc = fInc;
 }
예제 #29
0
파일: ObjExpAST.cs 프로젝트: chenzuo/blue
 public MethodCallExp(
     Exp e, // may be null,
     Identifier id,
     ArgExp [] arParams
 )
 {   
 // m_objExp may be null _until_ we resolve this. And then it's either
 // going to the implied 'this' ptr, a global func or a static func.
     m_objExp = e;
     m_idName = id;
     m_arParams = (arParams == null) ? new ArgExp[0] : arParams;
     
     
     // @todo - set in parser
     m_filerange = id.Location;        
 }