typeast.cs

来自「charp compiler」· CS 代码 · 共 629 行 · 第 1/2 页

        
        m_filerange = tElem.Location;
        m_cDimension = dimension;
        
        Debug.Assert(!tElem.CLRType.IsByRef, "Can't make an array of references");
        m_sigBase = null;
        m_ArrayTypeRec = 
        Debug.Assert(m_ArrayTypeRec != null);
    }
    */
#endregion

#region Properties
    NonRefTypeSig m_sigBase;
/*
    public TypeSig ElemTypeNode
    {
        get { return m_sigBase; }
    }
*/
    public TypeEntry ElemType
    {
        get {
            if (m_ArrayTypeRec == null)
                return m_sigBase.BlueType;
            return m_ArrayTypeRec.ElemType;
        }
    }

    int m_cDimension;
    public int Dimension
    {
        get { return m_cDimension;}
    }

    protected ArrayTypeEntry m_ArrayTypeRec;
    public ArrayTypeEntry ArrayTypeRec
    {
        get { return m_ArrayTypeRec; }
    }

#endregion

    // Get the resolved type
    // Same as ArrayTypeRec, but not type safe
    public override TypeEntry BlueType
    {
        get { return m_ArrayTypeRec; }
    }
        
    // ArrayType is always an array 
    public override bool IsArray
    {
        get { return true; }
    }
    
    // trivially true..
    public override ArrayTypeSig AsArraySig
    {
        get { return this; }
    }
    
#region Checks

#if false            
    public override string ToString()
    {
        // First get the non-array type

        TypeSig t = m_sigBase;
        while(t.IsArray)
        t = t.AsArraySig.ElemType;

        string stBase = t.ToString();
            
        t = this;
        while(t.IsArray)
        {
            stBase = stBase + "[";
            for(int i = 0; i < t.AsArraySig.Dimension - 1; i++)
            stBase += ",";
            stBase += "]";
                    
            t = t.AsArraySig.ElemType;
        }
        
        return stBase;
    }
#endif        
        
    public override void DebugCheck(ISemanticResolver s)
    {
        ElemType.DebugCheck(s);
        Debug.Assert(m_ArrayTypeRec != null);
            
        // Parallel data structures:
        // (ArrayTypeSig : TypeSig) as (ArrayTypeEntry : TypeEntry)
        // So verify the integrity there
        if (m_sigBase != null)
        {
            Debug.Assert(m_sigBase.BlueType == m_ArrayTypeRec.ElemType);
        }
                
    } // DebugCheck

    // Dump as XML
    public override void Dump(XmlWriter o)
    {
        o.WriteStartElement("ArrayTypeSig");
        o.WriteAttributeString("Dimension", m_cDimension.ToString());
        o.WriteAttributeString("fulltype", ToString());
                    
        if (m_sigBase != null)
            m_sigBase.Dump(o);
                        
        o.WriteEndElement();
    }
#endregion
    // Semantic resolution
    public override void ResolveType(ISemanticResolver s)
    {
        if (m_ArrayTypeRec != null)
            return;
            
        m_sigBase.ResolveType(s);
        m_ArrayTypeRec = new ArrayTypeEntry(this, s);
    }
}

#region Reference Type
//-----------------------------------------------------------------------------    
// Reference
//-----------------------------------------------------------------------------    
public class RefTypeSig : TypeSig
{
#region Construction
    // Create around an existing type
    public RefTypeSig(NonRefTypeSig sig)        
    {
        Debug.Assert(sig != null);
        m_tElem = sig;
    }
#endregion

#region Properties & Data
    // We hold a reference to a non-reference type.
    // Can't have reference to references. (These ain't pointers!)
    NonRefTypeSig m_tElem;

    // Track our internal symbol
    RefTypeEntry m_tRefEntry;

    // Get the blue & clr symbols
    public override TypeEntry BlueType
    {
        get { return m_tRefEntry; }
    }
        
    public override Type CLRType
    {
        get { return m_tRefEntry.CLRType; }
    }    
    
    // References are pretty transparent. So For array checks, we just pass right
    // through to our element type.
    public override bool IsArray
    {
        get { 
            return m_tElem.IsArray; 
        }
    }
    
    public override ArrayTypeSig AsArraySig
    {
        get {
            return m_tElem.AsArraySig;
        }
    }
#endregion

    // Semantic resolution
    public override void ResolveType(ISemanticResolver s)
    {        
        if (m_tRefEntry != null)
            return;
            
        m_tElem.ResolveType(s);
        
        m_tRefEntry = new RefTypeEntry(m_tElem.BlueType, s);
    }
    
#region Checks
    public override void DebugCheck(ISemanticResolver s)
    {
        base.DebugCheck(s);
        Debug.Assert(CLRType.IsByRef, "Ref type must wrap a ref");
        Debug.Assert(!m_tElem.BlueType.CLRType.IsByRef, "Can't have ref to ref");
    }
#endregion    
    
} // end RefTypeSig

#endregion Reference Type




#region Array Initializer

//-----------------------------------------------------------------------------    
// Array Initilizer - list of either expressions or nested ArrayInitliazers
// ArrayInitializers are not expressions, they're just part of the NewObjExp.
//-----------------------------------------------------------------------------    
public class ArrayInitializer : Node
{
    // Create an array initializer from the list
    public ArrayInitializer(System.Collections.ArrayList al)
    {
        m_list = new Node[al.Count];
        for(int i = 0; i < m_list.Length; i++)
            m_list[i] = (Node) al[i];
    }
    
    public ArrayInitializer(Node[] list)
    {
        m_list= list;
    }
    
    Node [] m_list;
    
    protected Node [] List
    {
        get { return m_list; }
    }
    
    public int Length
    {
        get { return m_list.Length; }
    }
    
    public Exp GetExpAt(int idx)
    {
        return (Exp) m_list[idx];
    }
    
#region checks
    public override void DebugCheck(ISemanticResolver s)    
    {
        foreach(Node n in List)
        {
            n.DebugCheck(s);
        }
    }
    
    // Dump as XML
    public override void Dump(XmlWriter o)
    {
        o.WriteStartElement("ArrayInitializer");
        
        foreach(Node n in List)
        {
            n.Dump(o); 
        }
                            
        o.WriteEndElement();
    }
#endregion

#region Resolution
    // Resolve this array initializer list.
    // Provide with the type that we expect each element in the list to be
    public void Resolve(ISemanticResolver s, TypeEntry tExpected)
    {
        // Each node must either be an expression or a nested array initializer list
        //foreach(Node n in List)
        for(int i = 0; i < m_list.Length; i++)
        {
            Node n = m_list[i]; 
            if (n is Exp)
            {
                Exp e = (Exp) n;
                Exp.ResolveExpAsRight(ref e, s);
                m_list[i] = e;
                
                s.EnsureAssignable(e, tExpected.CLRType);
            } 
            
            else if (n is ArrayInitializer)
            {
                Debug.Assert(tExpected.IsArray); // @todo -legit
                
                ArrayInitializer a = (ArrayInitializer) n;
                TypeEntry tNested = tExpected.AsArrayType.ElemType;
                
                a.Resolve(s, tNested);
            }
            
            else 
            {
                // Error
                Debug.Assert(false); // @todo - legit
            }
        
        }
    }


#endregion
}

#endregion ArrayInitializer


} // namespace AST