cp_declaration.c

linux 下的源代码分析阅读器 red hat公司新版

         else
         {
            /* 12.03.97 rigo */
            if( CompAct == 0 || Declaration->storage_class == SN_EXTERN )
            {
               may_function = True;
            }
            else
            {
               may_function = False;
            }

            if(( List = __InitDeclaratorList( may_function )))
            {
               f_ListConcat( &Declaration->ListDeclarator, List );
               if( iLevel == LEVEL_1 && f_IsDeclarationStrange( Declaration ))
               {
                  f_DeclarationDestroy( Declaration );
                  Declaration = 0;
                  Restore();
               }
               niveau--;
               return Declaration;
            }
            else
            {
               goto complete_class_name;
            }
         }
         break;

      case SN_OPERATOR   :
      case '('        :
      case '*'        :
      case '&'        :
      case '~'        :

         /* 12.03.97 rigo */
         if( CompAct == 0 || Declaration->storage_class == SN_EXTERN )
         {
            may_function = True;
         }
         else
         {
            may_function = False;
         }

         if(( List = __InitDeclaratorList( may_function )))
         {
            f_ListConcat( &Declaration->ListDeclarator, List );
            if( iLevel == LEVEL_1 && f_IsDeclarationStrange( Declaration ))
            {
               f_DeclarationDestroy( Declaration );
               Declaration = 0;
               Restore();
            }
            niveau--;
            return Declaration;
         }
         else
         {
            f_DeclarationDestroy( Declaration );
            Restore();
            niveau--;
            return 0;
         }

      default         :
         f_DeclarationDestroy( Declaration );
         Restore();
         niveau--;
         return 0;
      }
   }
}

/* Az f_DeclarationObject-tal csaknem azonos.
   Elteresek:
   (1) nem kell a CompAct figyeleset vegezni
   (2) az InitDeclarator helyett MemberDeclarator-t hivunk
   (3) az InitDeclaratorList helyett MemberDeclaratorList-t hivunk
   (4) a ':' is bevezetheti a Declarator-t (bitfield)
*/

extern Declaration_t f_MemberDeclaration( void )
{
   Declaration_t Declaration;
   Class_t Class;
   Enum_t Enum;
   Name_t Name;
   List_t List;
   int iTypeSpec = 0;
   int iStorage = 0;
   int iFctSpec = 0;
   int storage_class;
   Save();

   niveau++;

   Declaration = f_DeclarationCreate( DECLARATION_MEMBER );

   while( True )
   {
      switch( token( 0 ))
      {
      case SN_PUBLIC     : storage_class = 0     ; goto spec_storage;
      case SN_PRIVATE    : storage_class = SN_STATIC; goto spec_storage;
      case SN_PROTECTED  : storage_class = SN_STATIC; goto spec_storage;
spec_storage:
         step( 1 );
         if( iStorage + iTypeSpec + iFctSpec == 0 )
         {
            iStorage++;
            Declaration->storage_class = storage_class;
         }
         else
         {
            goto identifier;
         }
         break;

      case SN_AUTO       : Declaration->storage_class = SN_AUTO    ; goto label;
      case SN_REGISTER   : Declaration->storage_class = SN_REGISTER; goto label;
      case SN_STATIC     : Declaration->storage_class = SN_STATIC  ; goto label;
      case SN_EXTERN     : Declaration->storage_class = SN_EXTERN  ; goto label;
      case SN_FRIEND     : Declaration->storage_class = SN_FRIEND  ; goto label;
      case SN_TYPEDEF    : Declaration->storage_class = SN_TYPEDEF ; goto label;
label:
         step( 1 );
         iStorage++;
         break;

      case SN_INLINE     : Declaration->fct_specifier = SN_INLINE  ; goto fct_spec;
      case SN_VIRTUAL    : Declaration->fct_specifier = SN_VIRTUAL ; goto fct_spec;
fct_spec:
         step( 1 );
         iFctSpec++;
         break;

      case SN_CLASS      :
         if(( Class = f_Class()) == 0 )
         {
            goto identifier;
         }
         else
         {
            Declaration->Class = Class;
         }
         break;

      case SN_STRUCT     :
      case SN_UNION      :
         if(( Class = f_Class()) == 0 )
         {
            f_InternalError( 35 );
            f_DeclarationDestroy( Declaration );
            Restore();
            niveau--;
            return 0;
         }
         else
         {
            Declaration->Class = Class;
         }
         break;

      case SN_ENUM       :
         if(( Enum = f_Enum()) == 0 )
         {
            f_InternalError( 35 );
            f_DeclarationDestroy( Declaration );
            Restore();
            niveau--;
            return 0;
         }
         else
         {
            Declaration->Enum = Enum;
         }
         break;

      case SN_CONST      : Declaration->s_const       = True; goto type;
      case SN_VOLATILE   : Declaration->s_volatile    = True; goto type;
      case SN_CHAR       : Declaration->s_char        = True; goto type;
      case SN_SHORT      : Declaration->s_short       = True; goto type;
      case SN_INT        : Declaration->s_int         = True; goto type;
      case SN_LONG       : Declaration->s_long        = True; goto type;
      case SN_SIGNED     : Declaration->s_signed      = True; goto type;
      case SN_UNSIGNED   : Declaration->s_unsigned    = True; goto type;
      case SN_FLOAT      : Declaration->s_float       = True; goto type;
      case SN_DOUBLE     : Declaration->s_double      = True; goto type;
      case SN_BOOL       : Declaration->s_bool        = True; goto type;
      case SN_VOID       : Declaration->s_void        = True; goto type;
type:
         step( 1 );
         iTypeSpec++;
         break;

      case ';'        :
         /* empty declarator_list */
         step( 1 );
         niveau--;
         return Declaration;

      case SN_ASM        : /* 13.09.96 rigo */
      case SN_CATCH      : /* 13.09.96 rigo */
      case SN_DELETE     : /* 13.09.96 rigo */
      case SN_NAMESPACE  : /* 13.09.96 rigo */
      case SN_NEW        : /* 13.09.96 rigo */
      case SN_OVERLOAD   : /* 13.09.96 rigo */
      case SN_TEMPLATE   : /* 13.09.96 rigo */
      case SN_THIS       : /* 13.09.96 rigo */
      case SN_THROW      : /* 13.09.96 rigo */
      case SN_TRY        : /* 13.09.96 rigo */
      case SN_USING      : /* 13.09.96 rigo */
      case SN_IDENTIFIER :
      case SN_CLCL       :
identifier:
         if( False ) /* optionalis a decl_specifiers */
         {
complete_class_name:
            if(( Name = f_CompleteClassName()))
            {
               if( Declaration->Name == 0 )
               {
                  iTypeSpec++;
                  Declaration->Name = Name;
               }
               else
               {
                  f_NameDestroy( Name );
               }
               break;
            }
            else
            {
               printf( "Error by MemberDeclaration: ident: %s (%s:%d.%d)\n"
                     , ident( 0 )
                     , filename_g
                     , f_lineno( 0 )
                     , f_charno( 0 )
                     );
               f_DeclarationDestroy( Declaration );
               Restore();
               niveau--;
               return 0;
            }
         }
         else
         {
            if(( List = __MemberDeclaratorList()))
            {
               f_ListConcat( &Declaration->ListDeclarator, List );
               niveau--;
               return Declaration;
            }
            else
            {
               goto complete_class_name;
            }
         }
         break;

      case SN_OPERATOR   :
      case '('        :
      case '*'        :
      case '&'        :
      case '~'        :
      case ':'        : /* a bitfield-ek miatt */
         if(( List = __MemberDeclaratorList()))
         {
            f_ListConcat( &Declaration->ListDeclarator, List );
            niveau--;
            return Declaration;
         }
         else
         {
            f_DeclarationDestroy( Declaration );
            Restore();
            niveau--;
            return 0;
         }

      default         :
         f_DeclarationDestroy( Declaration );
         Restore();
         niveau--;
         return 0;
      }
   }
}

extern Declaration_t f_DeclarationCreate( int iType )
{
   Declaration_t Declaration = (Declaration_t) Malloc( sizeof( Declaration[0] ));
   memset((void *) Declaration, 0, sizeof( Declaration[0] ));
   Declaration->iType = iType;
   Declaration->lineno = f_lineno( 0 );
   Declaration->iCheck = DECLARATION_CHECK;

   return Declaration;
}

extern DeclarationSpecial_t f_DeclarationSpecialCreate( int iType )
{
   DeclarationSpecial_t DeclarationSpecial = (DeclarationSpecial_t) Malloc( sizeof( DeclarationSpecial[0] ));
   memset((void *) DeclarationSpecial, 0, sizeof( DeclarationSpecial[0] ));
   DeclarationSpecial->iType = iType;
   DeclarationSpecial->iCheck = DECLARATION_CHECK;

   return DeclarationSpecial;
}

extern Declaration_t f_DeclarationDuplicate( Declaration_t Declaration )
{
   Declaration_t DeclarationDuplicate;

   if( Declaration == 0 )
   {
      return 0;
   }

   if( Declaration->iCheck != DECLARATION_CHECK ) Abort();

   DeclarationDuplicate = f_DeclarationCreate( Declaration->iType );

   DeclarationDuplicate->storage_class   = Declaration->storage_class;
   DeclarationDuplicate->fct_specifier   = Declaration->fct_specifier;
   DeclarationDuplicate->s_ellipsis      = Declaration->s_ellipsis   ;
   DeclarationDuplicate->s_const         = Declaration->s_const      ;
   DeclarationDuplicate->s_volatile      = Declaration->s_volatile   ;
   DeclarationDuplicate->s_char          = Declaration->s_char       ;
   DeclarationDuplicate->s_short         = Declaration->s_short      ;
   DeclarationDuplicate->s_int           = Declaration->s_int        ;
   DeclarationDuplicate->s_long          = Declaration->s_long       ;
   DeclarationDuplicate->s_signed        = Declaration->s_signed     ;
   DeclarationDuplicate->s_unsigned      = Declaration->s_unsigned   ;
   DeclarationDuplicate->s_float         = Declaration->s_float      ;
   DeclarationDuplicate->s_double        = Declaration->s_double     ;
   DeclarationDuplicate->s_bool          = Declaration->s_bool       ;
   DeclarationDuplicate->s_void          = Declaration->s_void       ;

   DeclarationDuplicate->Name            = f_NameDuplicate( Declaration->Name );
   DeclarationDuplicate->Class           = 0;
   DeclarationDuplicate->Enum            = 0;
   DeclarationDuplicate->ListDeclarator  =
               f_ListDuplicate( Declaration->ListDeclarator
                              , (Elem_t(*)(Elem_t)) f_DeclaratorDuplicate );

   DeclarationDuplicate->lineno          = Declaration->lineno;

   return DeclarationDuplicate;
}

extern void f_DeclarationDestroy( Declaration_t Declaration )
{
   if( Declaration )
   {
/*       printf( "DeclarationDestroy: %d %d\n", Declaration->iType, f_lineno( 0 )); */
      if( Declaration->iCheck != DECLARATION_CHECK ) Abort();

      switch( Declaration->iType )
      {
      case DECLARATION_ASM                        :
      case DECLARATION_TEMPLATE                   :
      case DECLARATION_LINKAGE_SPECIFICATION      :
      case DECLARATION_NAMESPACE_DEFINITION       :
      case DECLARATION_NAMESPACE_ALIAS_DEFINITION :
      case DECLARATION_USING_DIRECTIVE            :
      case DECLARATION_USING                      :
         f_DeclarationSpecialDestroy((DeclarationSpecial_t) Declaration );
         break;

      case DECLARATION_OBJECT                     :
      case DECLARATION_MEMBER                     :
      case DECLARATION_ARGUMENT                   :
         f_NameDestroy( Declaration->Name );
         f_ClassDestroy( Declaration->Class );
         f_EnumDestroy( Declaration->Enum );
         f_ListDestroy( Declaration->ListDeclarator, (void(*)()) f_DeclaratorDestroy );
         ckfree( (char*)Declaration );
         break;
      default:
         printf( "unknown declaration type: %d ( %d )\n"
               , Declaration->iType
               , (int) Declaration );
         f_InternalError( 3 );
         break;
      }
   }
}

extern void f_DeclarationSpecialDestroy( DeclarationSpecial_t DeclarationSpecial )
{
   if( DeclarationSpecial )
   {
      if( DeclarationSpecial->iCheck != DECLARATION_CHECK ) Abort();

      f_NameDestroy( DeclarationSpecial->Name1 );
      f_NameDestroy( DeclarationSpecial->Name2 );
      f_ListDestroy( DeclarationSpecial->ListDeclaration, (void(*)()) f_DeclarationDestroy );
/*       f_ListDestroy( DeclarationSpecial->ListTemplateArgument, (void(*)()) f_TemplateArgumentDestroy ); */
      f_DeclarationDestroy( DeclarationSpecial->Declaration );
      ckfree( (char*)DeclarationSpecial );
   }
}

extern void f_DeclarationStrcat( char *pc, Declaration_t Declaration )
{
   Declarator_t Declarator;
   Boolean_t bType = False;   /* is type explicit defined ? */

   if( Declaration->s_ellipsis )
   {
      f_Strcat( pc, "..." );
/*       return; */
   }

   switch( Declaration->storage_class )
   {
   case SN_EXTERN  : f_Strcat( pc, "extern"   ); break;
   case SN_STATIC  : f_Strcat( pc, "static"   ); break;
   case SN_AUTO    : f_Strcat( pc, "auto"     ); break;
   case SN_REGISTER: f_Strcat( pc, "register" ); break;
   case SN_FRIEND  : f_Strcat( pc, "friend"   ); break;
   case SN_TYPEDEF : f_Strcat( pc, "typedef"  ); break;
   case 0       : break;
   default:
      printf( "unknown storage class: %d ( %d )\n"
            , Declaration->storage_class
            , (int) Declaration
            );
      f_InternalError( 4 );
      break;
   }

   switch( Declaration->fct_specifier )
   {
   case SN_INLINE  : f_Strcat( pc, "inline"   ); break;
   case SN_VIRTUAL : f_Strcat( pc, "virtual"  ); break;
   case 0       : break;
   default      : f_InternalError( 5 ); break;
   }

   if( Declaration->s_const         ) f_Strcat( pc, "const" );
   if( Declaration->s_volatile      ) f_Strcat( pc, "volatile" );
   if( Declaration->s_unsigned      ) f_Strcat( pc, "unsigned" );
   if( Declaration->s_short         )
      if( ! Declaration->s_int &&
          ! Declaration->s_float &&
          ! Declaration->s_double   ) f_Strcat( pc, "short" ), bType = True;
   if( Declaration->s_long          )
      if( ! Declaration->s_int &&
          ! Declaration->s_float &&
          ! Declaration->s_double   ) f_Strcat( pc, "long" ), bType = True;
   if( Declaration->s_char          ) f_Strcat( pc, "char" ), bType = True;
   if( Declaration->s_int           )
      /**/ if( Declaration->s_long  ) f_Strcat( pc, "long" ), bType = True;
      else if( Declaration->s_short ) f_Strcat( pc, "short" ), bType = True;
      else                            f_Strcat( pc, "int" ), bType = True;
   if( Declaration->s_float         )
      if( Declaration->s_long       ) f_Strcat( pc, "double" ), bType = True;
      else                            f_Strcat( pc, "float" ), bType = True;
   if( Declaration->s_double        )
      if( Declaration->s_short      ) f_Strcat( pc, "float" ), bType = True;
      else                            f_Strcat( pc, "double" ), bType = True;
   if( Declaration->s_bool          ) f_Strcat( pc, "bool" ), bType = True;
   if( Declaration->s_void          ) f_Strcat( pc, "void" ), bType = True;
   if( Declaration->Name )
   {
      f_Strcat( pc, Declaration->Name->pcName );
      bType = True;
   }
   if( Declaration->Class )
   {
      if( Declaration->Class->Name )
      {
         f_Strcat( pc, Declaration->Class->Name->pcName );
         bType = True;
      }
      else
      {
         f_Strcat( pc, "anonymous" );
         bType = True;
      }
   }
   if( Declaration->Enum )
   {
      if( Declaration->Enum->Name )
      {
         f_Strcat( pc, Declaration->Enum->Name->pcName );
         bType = True;
      }
      else
      {
         f_Strcat( pc, "anonymous" );
         bType = True;
      }
   }

   if( ! bType )
   {
      f_Strcat( pc, "int" );
      bType = True;
   }

   if( Declaration->ListDeclarator )
   {
      Boolean_t bFirst = True;

      for( Declarator = (Declarator_t) d_ElemFirst( Declaration->ListDeclarator )
         ; Declarator
         ; Declarator = Declarator->DeclaratorNext )
      {
         if( bFirst )
         {
            bFirst = False;
         }
         else
         {
            f_Strcat( pc, "," );