cp_expression.c

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

/*

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"
#include "operator.h"

/* #define TRACE */

static Expr_t assignment_expression( void );
static Expr_t constant_expression( void );
static Expr_t conditional_expression( void );
static Expr_t logical_or_expression( void );
static Expr_t logical_and_expression( void );
static Expr_t inclusive_or_expression( void );
static Expr_t exclusive_or_expression( void );
static Expr_t and_expression( void );
static Expr_t equality_expression( void );
static Expr_t relational_expression( void );
static Expr_t shift_expression( void );
static Expr_t additive_expression( void );
static Expr_t multiplicative_expression( void );
static Expr_t pm_expression( void );
static Expr_t cast_expression( void );
static Expr_t unary_expression( void );
static Expr_t postfix_expression( void );
static Expr_t primary_expression( void );
static Expr_t allocation_expression( void );
static List_t placement_opt( void );
static Expr_t deallocation_expression( void );
static Expr_t expression_member_name( void );
static List_t expression_list( void );
static List_t expression_list_opt( void );
/* static void skip_function_arg( void ); */
static Expr_t ExprCreateOp1( int operator, Expr_t Expr1 );
static Expr_t ExprCreateOp2( int operator, Expr_t Expr1, Expr_t Expr2 );
static Expr_t ExprCreateOp2List( int operator, Expr_t Expr1, List_t ListExpr );
static Expr_t ExprCreateOp3( int operator, Expr_t Expr1, Expr_t Expr2, Expr_t Expr3 );
static Expr_t ExprCreateName( Name_t Name );
static Expr_t ExprCreateMemberName( Name_t Name );
static Expr_t ExprCreateType( Type_t Type );
static Expr_t ExprCreateNew( Expr_t Expr1, Init_t Init, List_t ListExpr );
static Boolean_t f_IsNameSimpleTypeName( Name_t Name );

extern Expr_t f_Expression( void )
{
   return expression();
}

extern Expr_t f_ConstantExpression( void )
{
   return constant_expression();
}

extern Boolean_t f_expression( void )
{
   Expr_t Expr;

   if(( Expr = expression()))
   {
      f_ExprProcess( Expr );
      f_ExprDestroy( Expr );
      return True;
   }
   else
   {
      return False;
   }
}

extern Boolean_t f_constant_expression( void )
{
   Expr_t Expr;

   if(( Expr = constant_expression()))
   {
      f_ExprProcess( Expr );
      f_ExprDestroy( Expr );
      return True;
   }
   else
   {
      return False;
   }
}

extern Boolean_t f_assignment_expression( void )
{
   Expr_t Expr;

   if(( Expr = assignment_expression()))
   {
      f_ExprProcess( Expr );
      f_ExprDestroy( Expr );
      return True;
   }
   else
   {
      return False;
   }
}

extern Expr_t f_AssignmentExpression( void )
{
   return assignment_expression();
}

extern List_t f_ExpressionList( void )
{
   return expression_list();
}

extern Expr_t expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = assignment_expression()) == 0 )
   {
      Restore();
#ifdef PRINT
      printf( "No expression: %s\n", ident( 0 ));
#endif
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case ',': operator = OPERATOR_KOMMA; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = assignment_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
#ifdef PRINT
         printf( "No expression: %s\n", ident( 0 ));
#endif
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t assignment_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "assignment_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = conditional_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '='           : operator = OPERATOR_ASSIGN     ; break;
      case SN_MULTassign : operator = OPERATOR_MULTassign ; break;
      case SN_DIVassign  : operator = OPERATOR_DIVassign  ; break;
      case SN_MODassign  : operator = OPERATOR_MODassign  ; break;
      case SN_PLUSassign : operator = OPERATOR_PLUSassign ; break;
      case SN_MINUSassign: operator = OPERATOR_MINUSassign; break;
      case SN_LSassign   : operator = OPERATOR_LSassign   ; break;
      case SN_RSassign   : operator = OPERATOR_RSassign   ; break;
      case SN_ANDassign  : operator = OPERATOR_ANDassign  ; break;
      case SN_ERassign   : operator = OPERATOR_ERassign   ; break;
      case SN_ORassign   : operator = OPERATOR_ORassign   ; break;
      default            : return Expr1;
      }

      step( 1 );

      if(( Expr2 = conditional_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t constant_expression( void )
{
   return conditional_expression();
}

static Expr_t conditional_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   Expr_t Expr3;
   Save();

#ifdef TRACE
   printf( "conditional_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = logical_or_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   if( token( 0 ) != '?' )
   {
      return Expr1;
   }

   step( 1 );

   if(( Expr2 = expression()) == 0 )
   {
      f_ExprDestroy( Expr1 );
      Restore();
      return 0;
   }

   if( token( 0 ) != ':' )
   {
      f_ExprDestroy( Expr1 );
      f_ExprDestroy( Expr2 );
      Restore();
      return 0;
   }

   step( 1 );

   if(( Expr3 = conditional_expression()) == 0 )
   {
      f_ExprDestroy( Expr1 );
      f_ExprDestroy( Expr2 );
      Restore();
      return 0;
   }
   return ExprCreateOp3( OPERATOR_CONDITIONAL, Expr1, Expr2, Expr3 );
}

static Expr_t logical_or_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "logical_or_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = logical_and_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case SN_OROR: operator = OPERATOR_OROR; break;
      default  : return Expr1;
      }

      step( 1 );

      if(( Expr2 = logical_and_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t logical_and_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "logical_and_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = inclusive_or_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case SN_ANDAND: operator = OPERATOR_ANDAND; break;
      default    : return Expr1;
      }

      step( 1 );

      if(( Expr2 = inclusive_or_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t inclusive_or_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "inclusive_or_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = exclusive_or_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '|': operator = OPERATOR_OR; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = exclusive_or_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}


static Expr_t exclusive_or_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "exclusive_or_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = and_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '^': operator = OPERATOR_ER; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = and_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t and_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "and_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = equality_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '&': operator = OPERATOR_AND; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = equality_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t equality_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "equality_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = relational_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case SN_EQ: operator = OPERATOR_EQ; break;
      case SN_NE: operator = OPERATOR_NE; break;
      default: return Expr1;
      }

      step( 1 );

      if(( Expr2 = relational_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t relational_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "relational_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = shift_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '<': operator = OPERATOR_L ; break;
      case '>':
         if( template_arg )
         {
            return Expr1;
         }
         operator = OPERATOR_G ;
         break;
      case SN_LE : operator = OPERATOR_LE; break;
      case SN_GE : operator = OPERATOR_GE; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = shift_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t shift_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "shift_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = additive_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case SN_LS : operator = OPERATOR_LS; break;
      case SN_RS : operator = OPERATOR_RS; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = additive_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t additive_expression( void )
{
   Expr_t Expr1;
   Expr_t Expr2;
   int operator;
   Save();

#ifdef TRACE
   printf( "additive_expression: %s\n", ident( 0 ));
#endif

   if(( Expr1 = multiplicative_expression()) == 0 )
   {
      Restore();
      return 0;
   }

   while( True )
   {
      switch( token( 0 ))
      {
      case '+': operator = OPERATOR_PLUS ; break;
      case '-': operator = OPERATOR_MINUS; break;
      default : return Expr1;
      }

      step( 1 );

      if(( Expr2 = multiplicative_expression()) == 0 )
      {
         f_ExprDestroy( Expr1 );
         Restore();
         return 0;
      }
      Expr1 = ExprCreateOp2( operator, Expr1, Expr2 );
   }
}

static Expr_t multiplicative_expression( void )
{
   Expr_t Expr1;