cp_process.c

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

            , scope_ret
            , type_ret
            , define_ret /* 16.02.98 rigo */
            , *paf_type_ret
            );
#endif
      if( test_fp )
      {
         fprintf( test_fp
                ,"%d xref_g %d.%d %d.%d\n"
                , PAF_HIGH
                , lineno_beg
                , charno_beg
                , lineno_end
                , charno_end
                );
      }
      TypeReturn = f_TypeFromString( type_ret );
      if( TypeReturn == 0 ) TypeReturn = f_TypeCreateInt();
   }
   else
   {
#ifdef PRINT
      printf( "<-- not found : get_function_type: <%s> <%s> %s( %s ) **** not found\n"
            , scope_global ? scope_global : ""
            , scope ? scope : ""
            , name
            , arglist
            );
#endif
      if( test_fp )
      {
         fprintf( test_fp
                ,"%d xref_u %d.%d %d.%d\n"
                , PAF_HIGH
                , lineno_beg
                , charno_beg
                , lineno_end
                , charno_end
                );
      }
      TypeReturn = f_TypeCreateUnknown();
   }

   return TypeReturn;
}

static char *get_scope( char *name )
{
   char *pc;
   static char ac[10000];  /* old: 1000 */

   if(( pc = strrchr( name, ':' )))
   {
      if( pc[-1] == ':' )
      {
         pc[-1] = 0;
         strcpy( ac, name );
         pc[-1] = ':';
         return ac;
      }
   }
   return 0;
}

static char *get_name( char *name )
{
   char *pc;

   if(( pc = strrchr( name, ':' )))
   {
      return pc+1;
   }
   else
   {
      return name;
   }
}

static int my_Get_symbol( char *scope_global, char *scope, char *name, char *arg_list, char *scope_ret, char *type_ret, char *define_ret, int exact )
{
   int paf_type_ret;
   char acName[10000];  /* old: 1000 */
   char *pc1, *pc2;
      
   for( pc1 = name, pc2 = acName; *pc1; pc1++, pc2++ )
   {
      if( *pc1 == ' ' ) *pc2 = '_';
      else              *pc2 = *pc1;
   }

   *pc2 = 0;

   paf_type_ret = Get_symbol( scope_global
                            , scope
                            , acName
                            , arg_list
                            , scope_ret
                            , type_ret
                            , define_ret /* 16.02.98 rigo */
                            , exact );

   /* ha nem talaltuk, akkor megegyszer megkerdezzuk template arglist nelkul */
   if( paf_type_ret == 0 )
   {
      if( scope )
      {
         char *pcTemplateArg;

         if(( pcTemplateArg = strchr( scope, '<' )))
         {
            *pcTemplateArg = 0;

            paf_type_ret = Get_symbol( scope_global
                                     , scope
                                     , acName
                                     , arg_list
                                     , scope_ret
                                     , type_ret
                                     , define_ret /* 16.02.98 rigo */
                                     , exact );

            *pcTemplateArg = '<';
         }
      }
   }

   return paf_type_ret;
}

extern int Get_symbol( char *scope_global, char *scope, char *name, char *arg_list, char *scope_ret, char *type_ret, char *define_ret, int exact )
{
   int retval;

   retval = get_symbol( scope_global
                      , scope
                      , name
                      , arg_list
                      , scope_ret
                      , type_ret
                      , define_ret	/* 16.02.98 rigo */
                      , exact );

   if( pf )
   {
      fprintf( pf, "get_symbol : |%s|%s|%s|%s|%d| --> %s|%s|%s|%s|\n"
            , null_safe( scope_global )
            , null_safe( scope )
            , null_safe( name )
            , null_safe( arg_list )
            , exact
            , paf_type_to_string( retval )
            , null_safe( scope_ret )
            , null_safe( type_ret )
            , null_safe( define_ret ) /* 16.02.98 rigo */
            );
   }

#if 0
   printf( "get_symbol : |%s|%s|%s|%s|%d| --> %s|%s|%s|%s|\n"
         , null_safe( scope_global )
         , null_safe( scope )
         , null_safe( name )
         , null_safe( arg_list )
         , exact
         , paf_type_to_string( retval )
         , null_safe( scope_ret )
         , null_safe( type_ret )
         , null_safe( define_ret ) /* 16.02.98 rigo */
         );
#endif

   return retval;
}

extern int Get_class_or_typedef( char *name, char *type_ret )
{
   int retval;

   retval = get_class_or_typedef( name, type_ret );

   if( pf )
   {
      fprintf( pf, "get_class  : |%s| --> %s|%s|\n"
            , null_safe( name )
            , paf_type_to_string( retval )
            , null_safe( type_ret )
            );
   }

#if 0
   printf( "get_class  : |%s| --> %s|%s|\n"
         , null_safe( name )
         , paf_type_to_string( retval )
         , null_safe( type_ret )
         );
#endif

   return retval;
}

extern void Put_cross_ref( int type, int scope_type, int scope_lev, char *fnc_cls, char *fnc, char *fnc_arg_types, char *scope, char *what, char *arg_types, char *file, int lineno, int acc )
{

    put_cross_ref( type
                 , scope_type
                 , scope_lev
                 , fnc_cls
                 , fnc
                 , fnc_arg_types
                 , scope
                 , what
                 , arg_types
                 , file
                 , lineno
                 , acc );
#ifdef TEST
     printf( "put_cross  : |%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%d|%d|\n"
               , paf_type_to_string( type )
               , paf_type_to_string( scope_type )
               , paf_type_to_string( scope_lev )
               , null_safe( fnc_cls )
               , null_safe( fnc )
               , null_safe( fnc_arg_types )
               , null_safe( scope )
               , null_safe( what )
               , null_safe( arg_types )
               , null_safe( file )
               , lineno
               , acc
               );
#endif /*TEST*/
   if( pf )
   {
      fprintf( pf, "put_cross  : |%s|%s|%s|%s|%s|%s|%s|%s|%s|%s|%d|%d|\n"
               , paf_type_to_string( type )
               , paf_type_to_string( scope_type )
               , paf_type_to_string( scope_lev )
               , null_safe( fnc_cls )
               , null_safe( fnc )
               , null_safe( fnc_arg_types )
               , null_safe( scope )
               , null_safe( what )
               , null_safe( arg_types )
               , null_safe( file )
               , lineno
               , acc
               );
   }
}

char *paf_type_to_string( int paf_type )
{
   char *atype;
   static char acType[100];   /* old: 100 */

   switch( paf_type )
   {
   case  PAF_FILE              : atype = "FILE          "; break;
   case  PAF_TYPE_DEF          : atype = "TYPE_DEF      "; break;
   case  PAF_CLASS_DEF         : atype = "CLASS_DEF     "; break;
/* case  PAF_STRUCT_DEF        : atype = "STRUCT_DEF    "; break; */
   case  PAF_MBR_FUNC_DEF      : atype = "MBR_FUNC_DEF  "; break;
   case  PAF_MBR_VAR_DEF       : atype = "MBR_VAR_DEF   "; break;
   case  PAF_ENUM_DEF          : atype = "ENUM_DEF      "; break;
   case  PAF_CONS_DEF          : atype = "CONS_DEF      "; break;
   case  PAF_MACRO_DEF         : atype = "MACRO_DEF     "; break;
   case  PAF_FUNC_DEF          : atype = "FUNC_DEF      "; break;
   case  PAF_SUBR_DEF          : atype = "SUBR_DEF      "; break;
   case  PAF_GLOB_VAR_DEF      : atype = "GLOB_VAR_DEF  "; break;
   case  PAF_COMMON_DEF        : atype = "COMMON_DEF    "; break;
   case  PAF_COMMON_MBR_VAR_DEF: atype = "COMMON_MBR    "; break;
   case  PAF_CLASS_INHERIT     : atype = "CLASS_INHERIT "; break;
   case  PAF_FILE_SYMBOLS      : atype = "FILE_SYMBOLS  "; break;
   case  PAF_CROSS_REF_BY      : atype = "CROSS_REF_BY  "; break;
   case  PAF_CROSS_REF         : atype = "CROSS_REF     "; break;
   case  PAF_MBR_FUNC_DCL      : atype = "MBR_FUNC_DCL  "; break;
   case  PAF_FUNC_DCL          : atype = "FUNC_DCL      "; break;
   case  PAF_ENUM_CONST_DEF    : atype = "ENUM_CONST_DEF"; break;
/* case  PAF_UNION_DEF         : atype = "UNION_DEF     "; break; */
   case  PAF_NAMESPACE_DEF     : atype = "NAMESPACE_DEF "; break;
   case  PAF_EXCEPTION_DEF     : atype = "EXCEPTION_DEF "; break;
   case  PAF_LOCAL_VAR_DEF     : atype = "LOCAL_VAR_DEF "; break;
   case  PAF_VAR_DCL           : atype = "VAR_DCL       "; break;
   case  PAF_INCLUDE_DEF       : atype = "INCLUDE_DEF   "; break;
   case  PAF_COMMENT_DEF       : atype = "COMMENT_DEF   "; break;
   case  PAF_FRIEND_DCL        : atype = "FRIEND_DCL    "; break;
   case  PAF_REF_UNDEFINED     : atype = "REF_UNDEFINED "; break;
    default:
      sprintf( acType, "%3d           ", paf_type );
      atype = acType;
      break;
   }

   return atype;
}

extern char *f_NameFromType( Type_t Type )
{
   char *name;

   if( Type->Name )
   {
      name = Type->Name->pcName;
   }
   else if( Type->Class )
   {
      if( Type->Class->Name )
         name = Type->Class->Name->pcName;
      else
         name = 0;
   }
   else if( Type->Enum )
   {
      if( Type->Enum->Name )
         name = Type->Enum->Name->pcName;
      else
         name = 0;
   }
   else
   {
      name = 0;
   }

   if( name )
   {
      name = SN_StrDup( name );
   }

   return name;
}

extern char *f_NameFromDeclaration( Declaration_t Declaration )
{
   char *name;

   if( Declaration->Name )
   {
      name = Declaration->Name->pcName;
   }
   else if( Declaration->Class )
   {
      if( Declaration->Class->Name )
         name = Declaration->Class->Name->pcName;
      else
         name = 0;
   }
   else if( Declaration->Enum )
   {
      if( Declaration->Enum->Name )
         name = Declaration->Enum->Name->pcName;
      else
         name = 0;
   }
   else
   {
      name = 0;
   }

   if( name )
   {
      name = SN_StrDup( name );
   }

   return name;
}


static Type_t f_OperatorCall2( char *pcOperator, Type_t Type1, Type_t Type2, int access, int lineno )
{
   Type_t TypeReturn;
   char acName[10000];  /* old: 1000 */
   char acScope[10000]; /* old: 1000 */
   char acType[10000];  /* old: 1000 */
   char acDefine[10000];  /* 16.02.98 rigo */
   char acArglist[10000];  /* old: 1000 */
   int paf_type_ret;

   sprintf( acName, "operator%s", pcOperator );
   acArglist[0] = 0;

   f_TypeToString( Type1, acArglist, 0 );
   strcat( acArglist, "," );
   f_TypeToString( Type2, acArglist + strlen( acArglist ), 0 );

   /* itt nem a my_Get_symbol-t hivjuk, mert nincs template */
   if(( paf_type_ret = Get_symbol( scope_g
                                  , 0
                                  , acName
                                  , acArglist
                                  , acScope
                                  , acType
                                  , acDefine /* 16.02.98 rigo */
                                  , 1 /* exact */ )))
   {
      int paf_access = 0;

      if( access & WRITE ) paf_access |= PAF_REF_WRITE | PAF_REF_READ;
      if( access & READ  ) paf_access |= PAF_REF_READ ;
/*    if( pass           ) paf_access |= PAF_REF_PASS ; */

      Put_cross_ref( paf_type_ret
                   , scope_g[0] ? PAF_MBR_FUNC_DEF : PAF_FUNC_DEF
                   , PAF_REF_SCOPE_GLOBAL
                   , scope_g
                   , sym_name_g
                   , arg_types_g
                   , acScope
                   , acName
                   , acArglist
                   , filename_g
                   , lineno
                   , paf_access
                   );

      TypeReturn = f_TypeFromString( acType );
   }
   else
   {
      TypeReturn = 0;
   }

   return TypeReturn;
}