cp_declarator.c

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

/*

Copyright (c) 2000, Red Hat, Inc.

This file is part of Source-Navigator.

Source-Navigator is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 2, or (at your option)
any later version.

Source-Navigator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License along
with Source-Navigator; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.



*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <tcl.h>

#include "crossrefP.h"

static int test = 0;

extern Declarator_t f_Declarator( Boolean_t may_function );
extern Declarator_t f_InitDeclarator( Boolean_t may_function );
extern Declarator_t f_MemberDeclarator( void );
extern Declarator_t f_AbstractDeclarator( void );
extern Declarator_t f_NewDeclarator( void );
extern Declarator_t f_ConversionDeclarator( void );
extern List_t f_InitDeclaratorList( Boolean_t may_function );
extern List_t f_MemberDeclaratorList( void );
extern Declarator_t f_DeclaratorCreate( void );
extern void f_DeclaratorDestroy( Declarator_t Declarator );

static Declarator_t f_DeclaratorParen( Boolean_t may_function );
static Declarator_t f_DeclaratorPtr( Boolean_t may_function );
static Declarator_t f_DeclaratorSymbol( Boolean_t may_function );
static Declarator_t f_DeclaratorPtrOrDname( Boolean_t may_function );
static Declarator_t f_DeclaratorDname( Boolean_t may_function );
static List_t __AbstractDeclarator( void );
static Oper_t f_PtrOperator( void );
static Oper_t f_SimplePtrOperator( void );
static List_t f_FunctionOrArrayList( Boolean_t may_function );
static List_t f_ArrayList( void );
static Oper_t f_OperArray( void );
static Oper_t f_OperFunction( void );
static void f_CvQualifierList( Oper_t Oper );
static void f_OperStrcat( char *pc, Oper_t Oper, int type_prev );

extern Declarator_t f_Declarator( Boolean_t may_function )
{
   switch( token( 0 ))
   {
   case '('           : return f_DeclaratorParen( may_function );
   case '*'           :
   case '&'           : return f_DeclaratorPtr( may_function );
   case SN_ASM        :
   case SN_CATCH      :
   case SN_DELETE     :
   case SN_NAMESPACE  :
   case SN_OVERLOAD   :
   case SN_TEMPLATE   :
   case SN_THIS       :
   case SN_THROW      :
   case SN_TRY        :
   case SN_USING      :
   case SN_CLASS      : return f_DeclaratorSymbol( may_function );
   case SN_IDENTIFIER :
   case SN_CLCL       : return f_DeclaratorPtrOrDname( may_function );
   case SN_OPERATOR   :
   case '~'           : return f_DeclaratorDname( may_function );
   default            : return 0;
   }
}

extern Declarator_t f_InitDeclarator( Boolean_t may_function )
{
   Declarator_t Declarator;
   Save();
   niveau++;

   if(( Declarator = f_Declarator( may_function )))
   {
      if( token( 0 ) == '=' )
      {
         step( 1 );
         if(( Declarator->Init = f_Init( 0 )) == 0 )
         {
            f_StepTo( ',', ';', 0 );
         }
      }
      else if( token( 0 ) == '(' )
      {
         step( 1 );
         if(( Declarator->ListExpr = f_ExpressionList()))
         {
            f_StepTo( ')', 0 );
            step( 1 );
         }
         else
         {
            f_DeclaratorDestroy( Declarator );
            niveau--;
            Restore();
            return 0;
         }
      }
      niveau--;
      return Declarator;
   }
   else
   {
      niveau--;
      return 0;
   }
}

extern Declarator_t f_MemberDeclarator( void )
{
   Declarator_t Declarator;
   niveau++;

   if( token( 0 ) == ':' || ( f_IsLiteral( token( 0 )) && token( 1 ) == ':' ))
   {
      Declarator = f_DeclaratorCreate();
      if( token( 0 ) == ':' )
      {
         step( 1 );
         Declarator->Expr = f_ConstantExpression();
      }
      else
      {
         Declarator->Name = f_NameCreate( ident( 0 ));
         Declarator->lineno_beg = f_lineno( 0 );
         Declarator->charno_beg = f_charno( 0 );
         Declarator->lineno_end = f_lineno( 0 );
         Declarator->charno_end = f_charno( 0 ) + identlen( 0 );
         step( 2 );
         Declarator->Expr = f_ConstantExpression();
      }
      niveau--;    /* Fix from rigo 16-jun-97 */
      return Declarator;
   }

   if(( Declarator = f_Declarator( True )))  /* 12.03.97 rigo: may_function = True */
   {
      if( token( 0 ) == '=' )
      {
         step( 1 );
         if(( Declarator->Init = f_Init( 0 )) == 0 )
         {
            f_StepTo( ',', ';', 0 );
         }
      }
      niveau--;
      return Declarator;
   }
   else
   {
      niveau--;
      return 0;
   }
}

extern Declarator_t f_AbstractDeclarator( void )
{
   List_t List;
   Declarator_t Declarator;

   if(( List = __AbstractDeclarator()))
   {
      Declarator = f_DeclaratorCreate();
      Declarator->ListOper = List;
   }
   else
   {
      Declarator = 0;
   }

   return Declarator;
}

extern Declarator_t f_NewDeclarator( void )
{
   Declarator_t Declarator;
   Oper_t OperPointer;
/* Save(); */

   switch( token( 0 ))
   {
   case '*':
   case SN_IDENTIFIER:
   case SN_CLCL:
      if(( OperPointer = f_SimplePtrOperator()) == 0 )
      {
         return 0;
      }
      if(( Declarator = f_NewDeclarator()))
      {
         f_ListAddLast( &Declarator->ListOper, (Elem_t) OperPointer );
      }
      return Declarator;

   case '[':
      Declarator = f_DeclaratorCreate();
      Declarator->ListOper = f_ArrayList();
      return Declarator;

   default:
      return 0;
   }
}

extern Declarator_t f_ConversionDeclarator( void )
{
   Declarator_t Declarator;
   Oper_t OperPointer;

/* Save(); */

   switch( token( 0 ))
   {
   case '*':
   case SN_IDENTIFIER:
   case SN_CLCL:
      if(( OperPointer = f_PtrOperator()) == 0 )
      {
         return 0;
      }
      Declarator = f_DeclaratorCreate();
      f_ListAddLast( &Declarator->ListOper, (Elem_t) OperPointer );
      return Declarator;

   default:
      return 0;
   }
}

extern List_t f_InitDeclaratorList( Boolean_t may_function )
{
   Save();
   List_t List = f_ListCreate();
   Declarator_t Declarator;

   while( True )
   {
      switch( token( 0 ))
      {
      case ',':
         step( 1 );
         break;

      case ';':
         step( 1 );
         return List;

      default:
         if(( Declarator = f_InitDeclarator( may_function )))
         {
            f_ListAddLast( &List, (Elem_t) Declarator );
            break;
         }
         else
         {
            Restore();
            f_ListDestroy( List, (void(*)()) f_DeclaratorDestroy );
            return 0;
         }
      }
   }
}

extern List_t f_MemberDeclaratorList( void )
{
/* Save(); */
   List_t List = f_ListCreate();
   Declarator_t Declarator;

   while( True )
   {
      switch( token( 0 ))
      {
      case ',':
         step( 1 );
         break;

      case 0:
      case ';':
      case '}':
         return List;

      default:
         if(( Declarator = f_MemberDeclarator()))  /* 15.02.97 rigo */
         {
            f_ListAddLast( &List, (Elem_t) Declarator );
         }
         else
         {
            f_StepTo( ',', ';', '}', 0 );
         }
         break;
      }
   }
}

static Declarator_t f_DeclaratorParen( Boolean_t may_function )
{
   Declarator_t Declarator;
   List_t ListOper;
   Save();
   niveau++;

   if( test ) printf( "f_DeclaratorParen: %s\n", ident( 0 ));

   step( 1 );

   if(( Declarator = f_Declarator( may_function )))
   {
      if( token( 0 ) == ')' )
      {
         Oper_t Oper;
         Oper = (Oper_t) f_ListLastElem( Declarator->ListOper );
         if( ! ( Oper && ( Oper->type == POINTER_STAR || Oper->type == POINTER_AMPERSAND )))
         {
            Declarator->bStrange = True;  /* 01.02.97 rigo */
         }
         step( 1 );
         if( Declarator->ListOper ) /* 12.03.97 rigo */
         {
            may_function = True;
         }
         ListOper = f_FunctionOrArrayList( may_function );
         if( ListOper == 0 )
         {
            Declarator->bStrange = True;  /* 01.02.97 rigo */
         }
         f_ListConcat( &Declarator->ListOper, ListOper );
         niveau--;
         if( test ) printf( "return OK\n" );
         return Declarator;
      }
      else
      {
         f_DeclaratorDestroy( Declarator );
         Restore();
         niveau--;
         if( test ) printf( "return 0\n" );
         return 0;
      }
   }
   else
   {
      Restore();
      niveau--;
      if( test ) printf( "return 0\n" );
      return 0;
   }
}

static Declarator_t f_DeclaratorPtr( Boolean_t may_function )
{
   Declarator_t Declarator;
   Oper_t OperPointer;
   Save();
   niveau++;

   if( test ) printf( "f_DeclaratorPtr: %s\n", ident( 0 ));

   if(( OperPointer = f_PtrOperator()))
   {
      if(( Declarator = f_Declarator( True )))
      {
         f_ListAddLast( &Declarator->ListOper, (Elem_t) OperPointer );
         niveau--;
         if( test ) printf( "return OK\n" );
         return Declarator;
      }
      else
      {
         f_OperDestroy( OperPointer );
         Restore();
         niveau--;
         if( test ) printf( "return 0\n" );
         return 0;
      }
   }
   else
   {
      Restore();
      niveau--;
      if( test ) printf( "return 0\n" );
      return 0;
   }
}

static Declarator_t f_DeclaratorSymbol( Boolean_t may_function )
{
   Declarator_t Declarator;

   if( test ) printf( "f_DeclaratorSymbol: %s\n", ident( 0 ));

   Declarator = f_DeclaratorCreate();
   Declarator->Name = f_NameCreate( ident( 0 ));
   Declarator->lineno_beg = f_lineno( 0 );
   Declarator->charno_beg = f_charno( 0 );
   Declarator->lineno_end = f_lineno( 0 );
   Declarator->charno_end = f_charno( 0 ) + identlen( 0 );
   step( 1 );
   Declarator->ListOper = f_FunctionOrArrayList( may_function );

   if( test ) printf( "return OK\n" );
   return Declarator;
}

static Declarator_t f_DeclaratorPtrOrDname( Boolean_t may_function )
{
   Declarator_t Declarator;
   Oper_t OperPointer;
   Name_t Name;
   int lineno_beg = f_lineno( 0 );
   int charno_beg = f_charno( 0 );
   Save();
   niveau++;

   if(( OperPointer = f_PtrOperator()))
   {
      if(( Declarator = f_Declarator( True )))
      {
         f_ListAddLast( &Declarator->ListOper, (Elem_t) OperPointer );
         niveau--;
         if( test ) printf( "return OK\n" );
         return Declarator;
      }
      else
      {
         f_OperDestroy( OperPointer );
         Restore();
         niveau--;
         if( test ) printf( "return 0\n" );
         return 0;
      }
   }
   else if(( Name = f_Dname()))
   {
      Declarator = f_DeclaratorCreate();
      Declarator->Name = Name;
      Declarator->lineno_beg = lineno_beg;
      Declarator->charno_beg = charno_beg;
      Declarator->lineno_end = f_lineno( -1 );
      Declarator->charno_end = f_charno( -1 ) + identlen( -1 );
      Declarator->ListOper = f_FunctionOrArrayList( may_function );
      niveau--;
      if( test ) printf( "return OK\n" );
      return Declarator;
   }
   else
   {
      Restore();
      niveau--;
      if( test ) printf( "return 0\n" );
      return 0;
   }
}

static Declarator_t f_DeclaratorDname( Boolean_t may_function )
{
   Name_t Name;
   Declarator_t Declarator;
   int lineno_beg = f_lineno( 0 );
   int charno_beg = f_charno( 0 );
   Save();
   niveau++;

   if( test ) printf( "f_DeclaratorDname: %s\n", ident( 0 ));

   if(( Name = f_Dname()))
   {
      Declarator = f_DeclaratorCreate();
      Declarator->Name = Name;
      Declarator->lineno_beg = lineno_beg;
      Declarator->charno_beg = charno_beg;
      Declarator->lineno_end = f_lineno( -1 );
      Declarator->charno_end = f_charno( -1 ) + identlen( -1 );
      Declarator->ListOper = f_FunctionOrArrayList( may_function );
      niveau--;
      if( test ) printf( "return OK\n" );
      return Declarator;
   }
   else
   {
      Restore();
      niveau--;
      if( test ) printf( "return 0\n" );
      return 0;
   }
}

static List_t __AbstractDeclarator( void )
{
   List_t List = 0;
   Oper_t OperPointer;