[Dotgnu-pnet-commits] CVS: pnet/cscc/c c_ainit.tc,1.1,1.2

[Rhys Weatherley <address@hidden>]

Update of /cvsroot/dotgnu-pnet/pnet/cscc/c
In directory subversions:/tmp/cvs-serv4247/cscc/c

Modified Files:
        c_ainit.tc 
Log Message:


CArrayInitializerSize: further improvements to array size computation - handle
nested structs within structs, etc.


Index: c_ainit.tc
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnet/cscc/c/c_ainit.tc,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -r1.1 -r1.2
*** c_ainit.tc  26 Jun 2003 07:05:47 -0000      1.1
--- c_ainit.tc  27 Jun 2003 01:15:54 -0000      1.2
***************
*** 21,81 ****
  %{
  
! ILUInt32 CArrayInitializerSize(ILType *type, ILNode *init)
  {
-       ILType *elemType = CTypeGetElemType(type);
-       ILNode *list = ((ILNode_CArrayInit *)init)->expr;
-       ILNode_ListIter iter;
-       ILUInt32 len = 0;
-       ILUInt32 numElems;
        ILNode *node;
  
!       /* Scan the list, skipping over elements as we find them */
!       ILNode_ListIter_Init(&iter, list);
!       while((node = ILNode_ListIter_Next(&iter)) != 0)
        {
!               if(yyisa(node, ILNode_CArrayInit))
                {
!                       /* Nested array dimension or struct value */
!                       ++len;
                }
!               else if(CTypeIsStruct(elemType))
                {
!                       /* Struct value which is inline within its parent array 
*/
!                       numElems = CTypeGetNumFields(elemType);
!                       if(!numElems)
!                       {
!                               CCErrorOnLine(yygetfilename(node), 
yygetlinenum(node),
!                                                         _("cannot initialize 
empty `struct' types"));
!                               return 1;
!                       }
!                       while(numElems > 1 && node)
                        {
!                               node = ILNode_ListIter_Next(&iter);
!                               --numElems;
                        }
-                       ++len;
                }
!               else if(CTypeIsUnion(elemType))
                {
!                       CCErrorOnLine(yygetfilename(node), yygetlinenum(node),
!                                                 _("`union' initializers are 
not supported"));
                        return 1;
                }
!               else if(CTypeIsArray(elemType))
!               {
!                       /* Nested array which is inline within its parent 
dimension */
!                       numElems = CTypeGetNumElems(elemType);
!                       while(numElems > 1 && node)
!                       {
!                               node = ILNode_ListIter_Next(&iter);
!                               --numElems;
!                       }
!                       ++len;
!               }
!               else
!               {
!                       /* Ordinary array element */
!                       ++len;
!               }
        }
  
--- 21,155 ----
  %{
  
! /*
!  * Look ahead to the next item in a list iteration.
!  */
! static ILNode *IterLookAhead(ILNode_ListIter *iter)
! {
!       ILNode_ListIter copy = *iter;
!       return ILNode_ListIter_Next(&copy);
! }
! 
! /*
!  * Forward declaration.
!  */
! static int SkipInitializer(ILNode_ListIter *iter, ILType *type);
! 
! /*
!  * Skip the initializer for an array type.  Returns zero if
!  * the initializer does not have sufficient elements.
!  */
! static int SkipArrayInitializer(ILNode_ListIter *iter, ILType *type)
  {
        ILNode *node;
+       ILUInt32 numElems;
+       ILType *elemType;
  
!       /* Look ahead to see if we are at the end or a nested initializer */
!       node = IterLookAhead(iter);
!       if(!node)
        {
!               return 0;
!       }
!       else if(yyisa(node, ILNode_CArrayInit))
!       {
!               /* Assume that the entire array is within the nested 
initializer */
!               ILNode_ListIter_Next(iter);
!               return 1;
!       }
! 
!       /* Get the number of elements and the element type */
!       numElems = CTypeGetNumElems(type);
!       elemType = CTypeGetElemType(type);
! 
!       /* Recognize the elements, inline within the current array */
!       while(numElems > 0)
!       {
!               if(!SkipInitializer(iter, elemType))
                {
!                       return 0;
                }
!               --numElems;
!       }
!       return 1;
! }
! 
! /*
!  * Skip the initializer for a struct type.  Returns zero if
!  * the initializer does not have sufficient elements.
!  */
! static int SkipStructInitializer(ILNode_ListIter *iter, ILType *type)
! {
!       ILClass *classInfo = ILType_ToValueType(ILTypeStripPrefixes(type));
!       ILField *field;
!       ILNode *node;
! 
!       /* If the next element is an array initializer, then assume that
!          it contains the entire structure in a nested scope */
!       node = IterLookAhead(iter);
!       if(node && yyisa(node, ILNode_CArrayInit))
!       {
!               ILNode_ListIter_Next(iter);
!               return 1;
!       }
! 
!       /* Skip the struct elements, which are inline within the parent array */
!       field = 0;
!       while((field = (ILField *)ILClassNextMemberByKind
!                               (classInfo, (ILMember *)field, 
IL_META_MEMBERKIND_FIELD)) != 0)
!       {
!               if(!ILField_IsStatic(field))
                {
!                       if(!SkipInitializer(iter, 
ILFieldGetTypeWithPrefixes(field)))
                        {
!                               return 0;
                        }
                }
!       }
!       return 1;
! }
! 
! /*
!  * Skip the initializer for a particular type.
!  */
! static int SkipInitializer(ILNode_ListIter *iter, ILType *type)
! {
!       if(CTypeIsStruct(type))
!       {
!               return SkipStructInitializer(iter, type);
!       }
!       else if(CTypeIsUnion(type))
!       {
!               /* Cannot use "union" types within array initializers */
!               return 0;
!       }
!       else if(CTypeIsArray(type))
!       {
!               return SkipArrayInitializer(iter, type);
!       }
!       else
!       {
!               return (ILNode_ListIter_Next(iter) != 0);
!       }
! }
! 
! ILUInt32 CArrayInitializerSize(ILType *type, ILNode *init)
! {
!       ILType *elemType = CTypeGetElemType(type);
!       ILNode *list = ((ILNode_CArrayInit *)init)->expr;
!       ILNode_ListIter iter;
!       ILUInt32 len = 0;
! 
!       /* Scan the list, skipping over elements as we find them.
!          Type checking of the elements is performed later */
!       ILNode_ListIter_Init(&iter, list);
!       while(IterLookAhead(&iter) != 0)
!       {
!               if(!SkipInitializer(&iter, elemType))
                {
!                       CCErrorOnLine(yygetfilename(init), yygetlinenum(init),
!                                                 _("invalid array 
initializer"));
                        return 1;
                }
!               ++len;
        }
  
***************
*** 91,95 ****
  ILNode_CSemAnalysis(ILNode_CArrayInit)
  {
!       /* TODO */
        return CSemValueError;
  }
--- 165,169 ----
  ILNode_CSemAnalysis(ILNode_CArrayInit)
  {
!       /* Not used - semantic analysis for initializers is handled elsewhere */
        return CSemValueError;
  }