cparser.c

这是一个Linux下的集成开发环境

   while( True )
   {
      LongStringMyFree( &sDeclarator.name  );
      LongStringMyFree( &sDeclarator.type  );
      LongStringMyFree( &sDeclarator.types );
      LongStringMyFree( &sDeclarator.names );
      sDeclarator.base_typ = 0;
      sDeclarator.pure     = 0;
      sDeclarator.lineno_beg = 0;
      sDeclarator.charno_beg = 0;
      sDeclarator.lineno_end = 0;
      sDeclarator.charno_end = 0;
      sDeclarator.name_lineno_beg = 0; /* Zsolt Koppany, 18-apr-97 */
      sDeclarator.name_charno_beg = 0; /* Zsolt Koppany, 18-apr-97 */

      if( declarator( &sDeclarator ))
      {
         switch( token( 0 ))
         {
         case '=':
            initializer();
            break;

         case SN_RETURN:   /* gc++: inline Int operator - (Int &a) return r(a) {}; miatt 11.09.96 rigo */
         case SN_THROW:    /* gc++: int m1() throw(char*); miatt 02.10.97 rigo*/
         case ':':
            ctor_initializer();
            break;
         }

         if( token( 0 ) == ',' )
         {
            variable( Declaration, &sDeclarator );
            step( 1 );
            continue;
         }

         if( token( 0 ) == ';' )
         {
            variable( Declaration, &sDeclarator );
            step( 1 );
            goto return_true;
         }

         if( sDeclarator.base_typ == FUNCTION && token( 0 ) != LBRACE )
         {
            if( ! skip_macro( LBRACE ))
            {
               if( ! kr_argument_declaration_list( &sDeclarator.types, &sDeclarator.names ))
               {
/* Az elso nekifutasra False-szal terunk vissza, ami lehetoseget ad arra,
** hogy az ellentetes keyw_cpp ertekkel ujra megprobaljuk az egesz deklaraciot
** feldolgozni .
** A masodik nekifutasra is False-szal terunk vissza, ami lehetoseget ad arra,
** hogy visszaallitsuk a keyw_cpp-t az eredeti ertekre.
** A harmadik nekifutasra True-val terunk vissza.
*/
                  if( declaration_try == 1 || declaration_try == 2 )
                  {
                     goto return_false;
                  }
                  else
                  {
                     goto return_true;
                  }
               }
            }
         }

         if( sDeclarator.base_typ == FUNCTION && token( 0 ) == LBRACE )
         {
            int lineno = f_lineno( 0 );
            int charno = f_charno( 0 );
            char *comment = get_comment( f_lineno( -1 ));
            char *classname_save = classname_g;             /* 08.04.97 */
            char *funcname_save = funcname_g;               /* 08.04.97 */

            classname_g = my_strdup( get_scope( sDeclarator.name.buf )); /* 07.04.97 */
            funcname_g  = my_strdup( get_name ( sDeclarator.name.buf )); /* 07.04.97 */

            compound_statement();
            function( Declaration, &sDeclarator, f_lineno( -1 ), f_charno( -1 ), lineno, charno, comment );

            my_free( classname_g );                         /* 08.04.97 */
            my_free( funcname_g );                          /* 08.04.97 */
            classname_g = classname_save;                   /* 08.04.97 */
            funcname_g = funcname_save;                     /* 08.04.97 */

            goto return_true;
         }
         Restore_d();
         goto return_false;
      }
      Restore_d();
      goto return_false;
   }

return_false:
   niveau--;
   LongStringMyFree( &sDeclarator.name  );
   LongStringMyFree( &sDeclarator.type  );
   LongStringMyFree( &sDeclarator.types );
   LongStringMyFree( &sDeclarator.names );
   return False;

return_true:
   niveau--;
   LongStringMyFree( &sDeclarator.name  );
   LongStringMyFree( &sDeclarator.type  );
   LongStringMyFree( &sDeclarator.types );
   LongStringMyFree( &sDeclarator.names );
   return True;
}

extern int declarator( Declarator_t Declarator )
{
   int ret;
   int len = Declarator->type.len;

   niveau++;

   switch( token( 0 ))
   {
   case '('           :
      ret = declarator_paren( Declarator );
      break;
   case '*'           :
      ret = declarator_star( Declarator );
      break;
   case '&'           :
      ret = declarator_star( Declarator );
      break;

   case SN_IDENTIFIER :
   case SN_CLCL       :
      ret = declarator_identifier( Declarator );
      break;

   case SN_OPERATOR   : ret = declarator_operator  ( Declarator ); break;
   case '~'           : ret = declarator_tilde     ( Declarator ); break;
   default            : ret = False;
   }

   if( ! ret )
   {
      LongStringMySetLen( &Declarator->type, len );
   }

   niveau--;
/*    printf( "declarator return: %d\n", ret ); */
   return ret;
}

extern int declarator_paren( Declarator_t Declarator )
{
   Save_d();
   int len;

   len = Declarator->type.len;

   niveau++;

   LongStringMyAppend( &Declarator->type, "(" );

   step( 1 );
   if( declarator( Declarator ))
   {
      if( token( 0 ) == ')' )
      {
         LongStringMyAppend( &Declarator->type, ")" );
         step( 1 );
         if( function_or_array_list( Declarator ))
         {
            niveau--;
/*             printf( "declarator_paren return: 1\n" ); */
            return True;
         }
         else
         {
            Restore_d();
            LongStringMySetLen( &Declarator->type, len );
            niveau--;
/*             printf( "declarator_paren return: 0\n" ); */
            return False;
         }
      }
      else
      {
         Restore_d();
         LongStringMySetLen( &Declarator->type, len );
         niveau--;
/*          printf( "declarator_paren return: 0\n" ); */
         return False;
      }
   }
   else
   {
      Restore_d();
      LongStringMySetLen( &Declarator->type, len );
      niveau--;
/*       printf( "declarator_paren return: 0\n" ); */
      return False;
   }
   LongStringMySetLen( &Declarator->type, len );
   niveau--;
/*    printf( "declarator_paren return: 0\n" ); */
   return False;
}

extern int declarator_star( Declarator_t Declarator )
{
   Save_d();
   LongString aname;
   int len;
   int retval;

   niveau++;
   LongStringInit( &aname, -1 );

   if( ptr_operator( &aname ))
   {
      LongStringsMyAppend( &Declarator->type, &aname );
      len = Declarator->type.len;
      if( declarator( Declarator ))
      {
         if( Declarator->base_typ == 0 )
         {
            Declarator->base_typ = POINTER;
         }
         Return( True )
      }
      else
      {
         LongStringMySetLen( &Declarator->type, len );
         Restore_d();
         Return( False )
      }
   }
   else
   {
      Restore_d();
      Return( False )
   }

return_label:
   LongStringMyFree( &aname );
   niveau--;
   return retval;
}

extern int declarator_identifier( Declarator_t Declarator )
{
   Save_d();
   int lineno = f_lineno( 0 );
   int charno = f_charno( 0 );
   int t;
   LongString aname;
   int len;

   niveau++;
   LongStringInit( &aname, -1 );

   t = token( 0 );

   if( t == SN_IDENTIFIER )
   {
      t = token( 1 );

      if( t == SN_IDENTIFIER )
      {
         if( token( 2 ) == '(' && token( 3 ) == '(' )
         {
         /* int f ANSI(( int b )); miatt */
         }
         else
         {
         /* const CString& AFXAPI AfxGetEmptyString(); miatt */
            step( 1 );
            lineno = f_lineno( 0 );
            charno = f_charno( 0 );
         }
      }
      else if( token( 1 ) == SN_OPERATOR )
         /* void* AFX_CDECL operator new( void ); miatt */
      {
         step( 1 );
         lineno = f_lineno( 0 );
         charno = f_charno( 0 );
         if( declarator_operator( Declarator ))
         {
            LongStringMyFree( &aname );
            niveau--;
            return True;
         }
         else
         {
            Restore_d();
            LongStringMyFree( &aname );
            niveau--;
            return False;
         }
      }
   }

   LongStringMyFree( &aname );

   if( ptr_operator( &aname ))
   {
      LongStringsMyAppend( &Declarator->type, &aname );
      LongStringMyFree( &aname );
      len = Declarator->type.len;
      if( declarator( Declarator ))
      {
         if( Declarator->base_typ == 0 )
         { /* 07.03.97 rigo: int (XX:*a)(); miatt */
            Declarator->base_typ = POINTER;
         }
         niveau--;
         return True;
      }
      else
      {
         LongStringMySetLen( &Declarator->type, len );
         Restore_d();
         niveau--;
         return False;
      }
   }
   else if( qualified_name( &Declarator->name
                          , &Declarator->name_lineno_beg
                          , &Declarator->name_charno_beg ))
   {
      LongStringMyFree( &aname );
      Declarator->lineno_beg = lineno;
      Declarator->charno_beg = charno;
      Declarator->lineno_end = f_lineno( -1 );
      Declarator->charno_end = f_charno( -1 ) + identleng( -1 );
      if( function_or_array_list( Declarator ))
      {
         niveau--;
         return True;
      }
      else
      {
         LongStringMySetLen( &Declarator->name, 0 );
         Restore_d();
         niveau--;
         return False;
      }
   }
   else
   {
      LongStringMyFree( &aname );
      LongStringMySetLen( &Declarator->name, 0 );
      Restore_d();
      niveau--;
      return False;
   }
   LongStringMyFree( &aname );
   Restore_d();
   niveau--;
   return False;
}

extern int declarator_operator( Declarator_t Declarator )
{
   int lineno = f_lineno( 0 );
   int charno = f_charno( 0 );
   niveau++;

   if( operator_function_name( &Declarator->name ))
   {
      Declarator->name_lineno_beg = Declarator->lineno_beg = lineno;
      Declarator->name_charno_beg = Declarator->charno_beg = charno;
      Declarator->lineno_end = f_lineno( -1 );
      Declarator->charno_end = f_charno( -1 ) + identleng( -1 );
      if( function_or_array_list( Declarator ))
      {
         niveau--;
         return True;
      }
      else
      {
         LongStringMySetLen( &Declarator->name, 0 );
         niveau--;
         return False;
      }
   }
   else
   {
      LongStringMySetLen( &Declarator->name, 0 );
      niveau--;
      return False;
   }
}

extern int declarator_tilde( Declarator_t Declarator )
{
   int lineno_beg;
   int charno_beg;
   Save_d();
   niveau++;

   lineno_beg = f_lineno( 0 );
   charno_beg = f_charno( 0 );

   step( 1 );

   if( token( 0 ) == SN_IDENTIFIER )
   {
      Declarator->name_lineno_beg = Declarator->lineno_beg = lineno_beg;
      Declarator->name_charno_beg = Declarator->charno_beg = charno_beg;

      LongStringMyCopy  ( &Declarator->name, "~" );
      LongStringIdAppend( &Declarator->name, ident( 0 ));
      Declarator->lineno_end = f_lineno( 0 );
      Declarator->charno_end = f_charno( 0 ) + identleng( 0 );
      step( 1 );
      if( function_or_array_list( Declarator ))
      {
         niveau--;
         return True;
      }
      else
      {
         Restore_d();
         LongStringMySetLen( &Declarator->name, 0 );
         niveau--;
         return False;
      }
   }
   else
   {
      Restore_d();
      niveau--;
      return False;
   }
   niveau--;
}

extern int ptr_operator( LongString *plstr )
{
   Save_d();
   niveau++;

   switch( token( 0 ))
   {
   case '*'        :
   case '&'        :
      if( plstr )
      {
         LongStringIdAppend( plstr, ident( 0 ));
      }
      step( 1 );
      cv_qualifier_list_opt( plstr );
      niveau--;
/*       printf( "***** ptr operator ***** return True\n" ); */
      return True;
      break;

   case SN_IDENTIFIER :
   case SN_CLCL       :
      if( complete_class_name( plstr ))
      {
         if( token( 0 ) == SN_CLCL && token( 1 ) == '*' )
         {
            step( 1 );
            step( 1 );
            if( plstr )
            {
               LongStringMyAppend( plstr, "::*" );
            }
            cv_qualifier_list_opt( plstr );