symbol_table.c File Reference

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "properties.h"
#include "pipsdbm.h"
#include "text-util.h"
#include "ri-util.h"
#include "prettyprint.h"

Include dependency graph for symbol_table.c:

Go to the source code of this file.

Macros
#define	NL   "\n"

Functions
static string	check_derived_and_typedef (basic b, int indent, const char *parent)
static string	entities_type_and_name (list entities, int indent, const char *parent)
void	dump_common_layout (string_buffer result, entity c, bool debug_p, bool isfortran)
	This function is called from c_parse() via ResetCurrentModule() and fprint_environment() More...
string	get_symbol_table (entity m, bool isfortran)
void	actual_symbol_table_dump (const char *module_name, bool is_parsed)
bool	parsed_symbol_table (const char *module_name)
	bool c_symbol_table(const char* module_name) More...
bool	symbol_table (const char *module_name)
	To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table. More...

Variables
static string	indent_table [9]

Macro Definition Documentation

NL

#define NL   "\n"

Definition at line 42 of file symbol_table.c.

Function Documentation

actual_symbol_table_dump()

void actual_symbol_table_dump	(	const char *	module_name,
		bool	is_parsed
	)

This function is called in two different context: as a standalone phase or as part of debugging the parser?!?

Parameters

module_name	odule_name
is_parsed	s_parsed

Definition at line 582 of file symbol_table.c.

{
  FILE *out;
  string ppt;
  bool isfortran = false;
 
  entity module = module_name_to_entity(module_name);
  value v = entity_initial(module);
  if(value_code_p(v)) {
    code c = value_code(v);
    language l = code_language(c);
    if(language_fortran_p(l)||language_fortran95_p(l)) {
      isfortran = true;
    }
    else if(language_c_p(l)) {
      isfortran = false;
      set_prettyprint_language_tag(is_language_c);
    }
    else {
      pips_internal_error("Language %d is not supported.\n");
    }
  }
  else {
    pips_internal_error("Module \"%s\" has no code.\n", module_name);
  }
 
  string symboltable = db_build_file_resource_name(DBR_SYMBOL_TABLE_FILE,
                                                   module_name, NULL);
  string dir = db_get_current_workspace_directory();
  string filename = strdup(concatenate(dir, "/", symboltable, NULL));
  bool reset_p = false;
 
  debug_on("SYMBOL_TABLE_DEBUG_LEVEL");
 
  /* This function is called in two different context: as a
     standalone phase or as part of debugging the parser?!? */
  if(entity_undefined_p(get_current_module_entity())) {
    reset_p = true;
    set_current_module_entity(module);
  }
 
  out = safe_fopen(filename, "w");
 
  ppt = get_symbol_table(module, isfortran);
 
  fprintf(out, "%s\n%s", module_name, ppt);
  safe_fclose(out, filename);
 
  free(dir);
  free(filename);
 
  if(reset_p)
    reset_current_module_entity();
 
  debug_off();
 
  if(is_parsed)
    DB_PUT_FILE_RESOURCE(DBR_PARSED_SYMBOL_TABLE_FILE, module_name, symboltable);
  else
    DB_PUT_FILE_RESOURCE(DBR_SYMBOL_TABLE_FILE, module_name, symboltable);
 
}

References code_language, concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_initial, entity_undefined_p, fprintf(), free(), get_current_module_entity(), get_symbol_table(), is_language_c, language_c_p, language_fortran95_p, language_fortran_p, module, module_name(), module_name_to_entity(), out, pips_internal_error, reset_current_module_entity(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_prettyprint_language_tag(), strdup(), value_code, and value_code_p.

Referenced by parsed_symbol_table(), and symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

check_derived_and_typedef()

static string check_derived_and_typedef ( basic  b, int  indent, const char *  parent  )

static

Definition at line 93 of file symbol_table.c.

                                                                                                     {
  string result = NULL;
  if (basic_derived_p (b)) {
        pips_debug(3, "Derived found, let's look at it\n");
        entity e2 = basic_derived (b);
        type t2 = entity_type (e2);
        if (type_struct_p(t2)) {
          pips_debug(3, "Struct found, let's go deeper\n");
          result = entities_type_and_name (type_struct (t2), indent, parent);
        }
  }
  if (basic_typedef_p (b)) {
        pips_debug(3, "typedef found, let's look at it\n");
        entity e2 = basic_typedef (b);
        type t2 = entity_type (e2);
        if (type_variable_p(t2)) {
          variable v2 = type_variable(t2);
          basic b2 = variable_basic(v2);
          result = check_derived_and_typedef (b2, indent, parent);
        }
  }
  return ((result == NULL) ? strdup ("") : result);
}

References b2, basic_derived, basic_derived_p, basic_typedef, basic_typedef_p, entities_type_and_name(), entity_type, pips_debug, strdup(), type_struct, type_struct_p, type_variable, type_variable_p, and variable_basic.

Referenced by dump_common_layout(), and entities_type_and_name().

Here is the call graph for this function:

Here is the caller graph for this function:

dump_common_layout()

void dump_common_layout	(	string_buffer	result,
		entity	c,
		bool	debug_p,
		bool	isfortran
	)

This function is called from c_parse() via ResetCurrentModule() and fprint_environment()

symbol_table.c

FI: a weaker test to stay independent from the syntax library and its internal static variables.

This piece of code can be used in a pass or as debugging code for library syntax.

Parameters

result	esult
debug_p	ebug_p
isfortran	sfortran

Definition at line 120 of file symbol_table.c.

{
  entity mod = get_current_module_entity();
  list members = get_common_members(c, mod, false);
  list equiv_members = NIL;
 
  string_buffer_append(result,
                       concatenate(NL,"Layout for ",
                                   isfortran?"common /":"memory area \"",
                                   entity_name(c),isfortran?"/":"\""," of size ",
                                   i2a(area_size(type_area(entity_type(c)))),
                                   ":",NL,NULL));
 
 
  if(ENDP(members)) {
    pips_assert("An empty area has size 0",
                area_size(type_area(entity_type(c))) ==0);
    string_buffer_append(result, concatenate("\t* empty area *",NL,NL,NULL));
  }
  else {
    // Different preconditions for C and fortran
 
    if(isfortran){
      if(area_size(type_area(entity_type(c)))==0
         /* FI: a weaker test to stay independent from the syntax
          * library and its internal static variables.
          *
          * This piece of code can be used in a pass or as debugging
          * code for library syntax.
          */
         //              && fortran_relevant_area_entity_p(c))
         && !heap_area_p(c) && !stack_area_p(c))
        {
          if(debug_p) {
            user_warning("dump_common_layout",
                         "Non-empty area %s should have a final size greater than 0\n",
                         entity_module_name(c));
          }
          else {
            pips_internal_error("Non-empty area %s should have a size greater than 0",
                                entity_module_name(c));
          }
        }
    }
    else {
      if(area_size(type_area(entity_type(c))) == 0)
        {
          if(debug_p) {
            user_warning("dump_common_layout",
                         "Non-empty area %s should have a final size greater than 0\n",
                         entity_module_name(c));
          }
        }
    }
 
    if(isfortran){
      FOREACH(ENTITY, m, members) {
        pips_assert("RAM storage",
                    storage_ram_p(entity_storage(m)));
        if(ram_function(storage_ram(entity_storage(m)))==mod) {
          int s;
 
          if(ram_section(storage_ram(entity_storage(m)))!=c) {
            pips_internal_error("Variable %s declared in area %s but allocated in area %s",
                                entity_local_name(m), entity_module_name(c),
                                entity_module_name(ram_section(storage_ram(entity_storage(m)))));
          }
 
          if(!SizeOfArray(m, &s)) {
            if(ram_section(storage_ram(entity_storage(m)))==HeapArea
               || ram_section(storage_ram(entity_storage(m)))==StackArea) {
              s = -1;
            }
            else {
              user_warning("print_common_layout",
                           "Varying size of array \"%s\"\n", entity_name(m));
              pips_internal_error("Fortran standard prohibit varying size array\n");
            }
          }
 
          string_buffer_append(result,
                               concatenate
                               ("\tVariable ",entity_name(m),"\toffset = ",
                                i2a(ram_offset(storage_ram(entity_storage(m)))),NULL));
          string_buffer_append(result,
                               concatenate("\tsize = ",i2a(s),NL,NULL));
        }
      }
    }
    else { // C language
      FOREACH(ENTITY, m, members) {
        if(!place_holder_variable_p(m)) {
          pips_assert("RAM storage",
                      storage_ram_p(entity_storage(m)));
          int s;
 
          SizeOfArray(m, &s);
 
          pips_assert("An area has no offset as -1",
                      (ram_offset(storage_ram(entity_storage(m)))!= -1));
 
          if(ram_offset(storage_ram(entity_storage(m))) == DYNAMIC_RAM_OFFSET) {
            string_buffer_append(result,
                                 concatenate(
                                             "\tDynamic Variable \"",entity_name(m),
                                             "\"\toffset = UNKNOWN, \tsize = DYNAMIC",
                                             NL,NULL));
          }
          else if (ram_offset(storage_ram(entity_storage(m))) == UNDEFINED_RAM_OFFSET) {
            string_buffer_append(result,
                                 concatenate
                                 ("\tExternal Variable \"", entity_name(m),
                                  "\"\toffset = UNKNOWN,\tsize = ",
                                  s>0?i2a(s): "unknown", NL, NULL));
          }
          else {
            string_buffer_append(result,
                                 concatenate
                                 ("\tVariable \"", entity_name(m),"\"\toffset = ",
                                  i2a(ram_offset(storage_ram(entity_storage(m)))),NULL));
            if (get_bool_property("EXTENDED_VARIABLE_INFORMATION")) {
              pips_debug(3, "extended information required\n");
              type t = entity_type (m);
              if (type_variable_p(t)) {
                variable v = type_variable(t);
                basic b = variable_basic(v);
                string_buffer_append(result,
                                     concatenate("\ttype = \"",
                                                 basic_to_string(b), "\"",
                                                 "\tuser name = \"",
                                                 entity_user_name (m), "\"",
                                                 NULL));
                // check if the basic is derived or typedef to be investigated
                string deeper = check_derived_and_typedef (b, 2, entity_user_name (m));
                if (strcmp (deeper, "") != 0) {
                  string_buffer_append (result, NL);
                  string_buffer_append (result, deeper);
                }
                else free (deeper);
              }
            }
            string_buffer_append(result,
                                 concatenate("\tsize = ",i2a(s),NL,NULL));
          }
        }
      }
    }
 
    string_buffer_append(result, NL);
 
    FOREACH(ENTITY, m, members) {
      list equiv = ram_shared(storage_ram(entity_storage(m)));
 
      equiv_members = arguments_union(equiv_members, equiv);
    }
 
    if(!ENDP(equiv_members)){
      equiv_members = arguments_difference(equiv_members, members);
      if(!ENDP(equiv_members)) {
        sort_list_of_entities(equiv_members);
 
        string_buffer_append(result, concatenate("\tVariables aliased to this common:",NL,
                                                 NULL));
 
        FOREACH(ENTITY, m, equiv_members) {
          pips_assert("RAM storage",
                      storage_ram_p(entity_storage(m)));
          string_buffer_append(result,
                               concatenate
                               ("\tVariable", entity_name(m) ,"\toffset =",
                                ram_offset(storage_ram(entity_storage(m))),"\tsize = ",
                                array_size(m),NL,NULL));
        }
        string_buffer_append(result, concatenate(NL,NULL));
        gen_free_list(equiv_members);
      }
    }
  }
  gen_free_list(members);
}

References area_size, arguments_difference(), arguments_union(), array_size(), basic_to_string(), check_derived_and_typedef(), concatenate(), DYNAMIC_RAM_OFFSET, ENDP, ENTITY, entity_local_name(), entity_module_name(), entity_name, entity_storage, entity_type, entity_user_name(), FOREACH, free(), gen_free_list(), get_bool_property(), get_common_members(), get_current_module_entity(), heap_area_p(), HeapArea, i2a(), NIL, NL, pips_assert, pips_debug, pips_internal_error, place_holder_variable_p(), ram_function, ram_offset, ram_section, ram_shared, SizeOfArray(), sort_list_of_entities(), stack_area_p(), StackArea, storage_ram, storage_ram_p, string_buffer_append(), type_area, type_variable, type_variable_p, UNDEFINED_RAM_OFFSET, user_warning, and variable_basic.

Referenced by get_symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

entities_type_and_name()

static string entities_type_and_name ( list  entities, int  indent, const char *  parent  )

static

Definition at line 57 of file symbol_table.c.

                                                                                               {
  string result = strdup ("");
  string indent_str = (indent < 9)? indent_table[indent] : indent_table[8];
  string old = NULL;
 
  // if more that 8 indentation required continue to build the indentation
  // string
  for (int i = 8; i < indent; i++) {
        old = indent_str;
        indent_str = concatenate (indent_str, "\t", NULL);
        free (old);
  }
 
  FOREACH (ENTITY, e, entities) {
        type t = entity_type (e);
        if (type_variable_p(t)) {
          old = result;
          variable v = type_variable(t);
          basic b = variable_basic(v);
          string name = strdup (concatenate (parent, ".", entity_user_name (e),
                                                                                 NULL));
          string deeper = check_derived_and_typedef (b, indent + 1, name);
          result = strdup (concatenate(result, indent_str, "type = \"",
                                                                   basic_to_string(b), "\"",
                                                                   "\tuser name = \"", name, "\"\n",
                                                                   deeper, NULL)
                                           );
          free (deeper);
          free (name);
          free (old);
        }
  }
  return result;
}

References basic_to_string(), check_derived_and_typedef(), concatenate(), ENTITY, entity_type, entity_user_name(), FOREACH, free(), indent_table, strdup(), type_variable, type_variable_p, and variable_basic.

Referenced by check_derived_and_typedef().

Here is the call graph for this function:

Here is the caller graph for this function:

get_symbol_table()

string get_symbol_table	(	entity	m,
		bool	isfortran
	)

return variable

To simplify validation, at the expense of some information about the parsing process.

FI: struct, union and enum are also declared (in theory...), but their characteristics should be given differently.

&& (storage_ram_p(s) || storage_return_p(s) || storage_formal_p(s))

FI: How do we want to print out structures, unions and enums?

FI: How do we want to print out typedefs?

FI: it would be useful to dump more information aout fields and members

Formal parameters

Return variable

Structure of each area/common

Parameters

isfortran

sfortran

Definition at line 304 of file symbol_table.c.

{
  string_buffer result = string_buffer_make(true);
  string result2;
  list decls = gen_copy_seq(code_declarations(value_code(entity_initial(m))));
  int nth = 0;
  entity rv = entity_undefined; /* return variable */
  list ce = list_undefined;
 
  pips_assert("m is a module", entity_module_p(m));
  pips_assert("decls is a list of entities", entity_list_p(decls));
 
  /* To simplify validation, at the expense of some information about
     the parsing process. */
 
  gen_sort_list(decls, (gen_cmp_func_t)compare_entities);
 
  string_buffer_append(result, concatenate(NL,"Declarations for module \"",
                                           module_local_name(m),"\" with type \"", NULL));
 
  dump_functional(type_functional(entity_type(m)), result);
  string_buffer_append(result, "\"" NL);
 
  /*
   * List of implicitly and explicitly declared variables, functions
   * and areas
   *
   */
  if(ENDP(decls))
    string_buffer_append(result, concatenate("\n* empty declaration list *",NL,NL,NULL));
  else
    string_buffer_append(result, concatenate("\nVariable list:",NL,NL,NULL));
 
  FOREACH(ENTITY, e, decls) {
    // FI: more filtering needed for entities generated by the
    // different passes, such as location entities
    if(!typedef_entity_p(e) && !derived_entity_p(e)) {
      type t = entity_type(e);
 
      pips_debug(8, "Processing entity \"%s\"\n", entity_name(e));
      string_buffer_append(result, concatenate("\tDeclared entity \"",
                                               entity_name(e),"\" with type \"",
                                               type_to_string(t),"\" ",NULL));
 
      /* FI: struct, union and enum are also declared (in theory...), but
         their characteristics should be given differently. */
      if(type_variable_p(t)
         /* && (storage_ram_p(s) || storage_return_p(s) || storage_formal_p(s))*/) {
        variable v = type_variable(t);
        list dl = variable_dimensions(v);
        list ql = variable_qualifiers(v);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\""NL);
        }
        else {
          if(ENDP(dl)) {
            if(ENDP(ql)) {
              string_buffer_append(result,
                                   concatenate("\"", basic_to_string(b), "\""NL,NULL));
            }
            else {
              string sql = list_to_string(words_qualifiers(ql));
              string_buffer_append(result,
                                   concatenate("\"", sql, basic_to_string(b), "\""NL,NULL));
            }
          }
          else {
            list pdl = NIL;
            string sdl = list_to_string(words_dimensions(dl, &pdl));
            gen_free_list(pdl);
            if(ENDP(ql)) {
              string_buffer_append(result,
                                   concatenate("\"", basic_to_string(b), sdl, "\""NL,NULL));
            }
            else {
              string sql = list_to_string(words_qualifiers(ql));
              string_buffer_append(result,
                                   concatenate("\"", sql, basic_to_string(b), sdl, "\""NL,NULL));
            }
          }
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\""NL);
      }
      else if(type_area_p(t)) {
        string_buffer_append(result,concatenate("with size ",
                                                i2a(area_size(type_area(t))),NL, NULL));
      }
      else {
        /* FI: How do we want to print out structures, unions and enums? */
        /* FI: How do we want to print out typedefs? */
        string_buffer_append(result, NL);
      }
    }
  }
 
  /*
   * Extern declarations
   */
 
  if(!isfortran) {
    list edecls = gen_copy_seq(code_externs(value_code(entity_initial(m))));
 
    //gen_sort_list(decls, compare_entities);
 
    if(ENDP(edecls))
      string_buffer_append(result, concatenate("\n* empty extern declaration list *",NL,NL,NULL));
    else
      string_buffer_append(result, concatenate("\nExternal variable list:",NL,NL,NULL));
 
    for(ce=edecls; !ENDP(ce); POP(ce)) {
      entity e = ENTITY(CAR(ce));
      type t = entity_type(e);
 
      pips_debug(8, "Processing external entity \"%s\"\n", entity_name(e));
      pips_assert("e is an entity", entity_domain_number(e)==entity_domain);
      string_buffer_append(result, concatenate("\tDeclared external entity \"",
                                               entity_name(e),"\"\twith type \"",
                                               type_to_string(t),"\" ",NULL));
 
      if(type_variable_p(t)) {
        variable v = type_variable(t);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\"" NL);
        }
        else {
          string_buffer_append(result,
                               concatenate("\"", basic_to_string(b), "\""NL,NULL));
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\"" NL);
      }
      else if(type_area_p(t)) {
        string_buffer_append(result,concatenate("with size ",
                                                i2a(area_size(type_area(t))),NL, NULL));
      }
      else
        string_buffer_append(result, NL);
    }
  }
 
  /*
   * Derived entities: struct, union and enum
   */
 
  nth = 0;
  FOREACH(ENTITY, de, decls) {
    if(entity_struct_p(de) || entity_union_p(de) || entity_enum_p(de)) {
        nth++;
        if(nth==1) {
          string_buffer_append(result, concatenate(NL,"Derived entities:"
                                                   ,NL,NL,NULL));
        }
        /* FI: it would be useful to dump more information aout
           fields and members */
        string_buffer_append(result, concatenate("\tVariable \"", entity_name(de),
                                                 "\"\tkind = ",
                                                 entity_struct_p(de)? "struct" :
                                                 entity_union_p(de)? "union" : "enum",
                                                 "\n", NULL));
      }
  }
 
  /*
   * Typedefs
   */
 
  nth = 0;
  FOREACH(ENTITY, te, decls) {
    if(typedef_entity_p(te)) {
      type t = entity_type(te);
      nth++;
      if(nth==1) {
        string_buffer_append(result, concatenate(NL,"Typedef entities:"
                                                 ,NL,NL,NULL));
      }
      string_buffer_append(result, concatenate("\tTypedef \"", entity_name(te),
                                               "\"\twith type \"",type_to_string(t),"\" ", NULL));
 
      if(type_variable_p(t)) {
        variable v = type_variable(t);
        basic b = variable_basic(v);
        if(basic_pointer_p(b) && type_functional_p(basic_pointer(b))) {
          functional f = type_functional(basic_pointer(b));
          string_buffer_append(result, "\"(");
          dump_functional(f,result);
          string_buffer_append(result, ") *\"" NL);
        }
        else {
          string_buffer_append(result,
                               concatenate("\"", basic_to_string(b), "\""NL,NULL));
        }
      }
      else if(type_functional_p(t)) {
        string_buffer_append(result, "\"");
        dump_functional(type_functional(t),result);
        string_buffer_append(result, "\"" NL);
      }
      else if(type_void_p(t)) {
        string_buffer_append(result, "\"void\"" NL);
      }
      else {
        pips_internal_error("unexpected type for a typedef");
      }
    }
  }
 
  /* Formal parameters */
  nth = 0;
  FOREACH(ENTITY, v, decls) {
      storage vs = entity_storage(v);
 
      pips_assert("All storages are defined", !storage_undefined_p(vs));
 
      if(storage_formal_p(vs)) {
        nth++;
        if(nth==1) {
          string_buffer_append(result, concatenate(NL,"Layout for formal parameters:"
                                                   ,NL,NL,NULL));
        }
        string_buffer_append(result, concatenate("\tVariable ", entity_name(v),
                                                 "\toffset = ",
                                                 i2a(formal_offset(storage_formal(vs))),
                                                 "\n", NULL));
      }
      else if(storage_return_p(vs)) {
        pips_assert("No more than one return variable", entity_undefined_p(rv));
        rv = v;
      }
  }
 
  /* Return variable */
  if(!entity_undefined_p(rv)) {
    basic rb = variable_basic(type_variable(ultimate_type(entity_type(rv))));
    string_buffer_append(result, concatenate(NL,"Layout for return variable:",NL,NL,NULL));
    string_buffer_append(result, concatenate("\tVariable \"",
                                             entity_name(rv),
                                             "\"\tsize = ",
                                             strdup(i2a(SizeOfElements(rb))),
                                             "\n", NULL));
  }
 
  /* Structure of each area/common */
  if(!ENDP(decls)) {
    string_buffer_append(result, concatenate(NL,"Layouts for ",isfortran?"commons:":"memory areas:",NL,NULL));
  }
 
  FOREACH (ENTITY, e, decls) {
        if(type_area_p(entity_type(e))) {
          dump_common_layout(result, e, false, isfortran);
        }
  }
 
  string_buffer_append(result, concatenate("End of declarations for module ",
                                           module_local_name(m), NL,NL, NULL));
 
  gen_free_list(decls);
 
  result2 = string_buffer_to_string(result);
  string_buffer_free(&result);
 
  return result2;
}

References area_size, basic_pointer, basic_pointer_p, basic_to_string(), CAR, code_declarations, code_externs, compare_entities(), concatenate(), derived_entity_p(), dump_common_layout(), dump_functional(), ENDP, ENTITY, entity_domain, entity_domain_number, entity_enum_p(), entity_initial, entity_list_p(), entity_module_p(), entity_name, entity_storage, entity_struct_p(), entity_type, entity_undefined, entity_undefined_p, entity_union_p(), f(), FOREACH, formal_offset, gen_copy_seq(), gen_free_list(), gen_sort_list(), i2a(), list_to_string(), list_undefined, module_local_name(), NIL, NL, pips_assert, pips_debug, pips_internal_error, POP, SizeOfElements(), storage_formal, storage_formal_p, storage_return_p, storage_undefined_p, strdup(), string_buffer_append(), string_buffer_free(), string_buffer_make(), string_buffer_to_string(), type_area, type_area_p, type_functional, type_functional_p, type_to_string(), type_variable, type_variable_p, type_void_p, typedef_entity_p(), ultimate_type(), value_code, variable_basic, variable_dimensions, variable_qualifiers, words_dimensions(), and words_qualifiers().

Referenced by actual_symbol_table_dump().

Here is the call graph for this function:

Here is the caller graph for this function:

parsed_symbol_table()

bool parsed_symbol_table

(

const char *

module_name

)

bool c_symbol_table(const char* module_name)

{ set_prettyprint_language_tag(is_language_c); //all the way down to words_basic() actual_symbol_table_dump(module_name, false); return true; } bool fortran_symbol_table(const char* module_name) { actual_symbol_table_dump(module_name, true); return true; } To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table.

This the symbol table is never duplicated, this function's output is correct only if the controlizer has not been applied.

Parameters

module_name

odule_name

Definition at line 665 of file symbol_table.c.

{
  actual_symbol_table_dump(module_name, true);
  return true;
}

References actual_symbol_table_dump(), and module_name().

Here is the call graph for this function:

symbol_table()

bool symbol_table

(

const char *

module_name

)

To replace c_symbol_table() and fortran_symbol_table() because the information about the language is available in the symbol table.

Parameters

module_name

odule_name

Definition at line 673 of file symbol_table.c.

{
  actual_symbol_table_dump(module_name, false);
  return true;
}

References actual_symbol_table_dump(), and module_name().

Referenced by expression_similar_get_context_p(), and expression_similar_p().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

indent_table

string indent_table[9]

static

Initial value:

= {"",
                                                                  "\t",
                                                                  "\t\t",
                                                                  "\t\t\t",
                                                                  "\t\t\t\t",
                                                                  "\t\t\t\t\t",
                                                                  "\t\t\t\t\t\t",
                                                                  "\t\t\t\t\t\t\t",
                                                                  "\t\t\t\t\t\t\t\t"}

Definition at line 44 of file symbol_table.c.

Referenced by entities_type_and_name().