Category : Miscellaneous Language Source Code
Archive   : FTNCHECK.ZIP
Filename : SYMTAB.H

 
Output of file : SYMTAB.H contained in archive : FTNCHECK.ZIP

/* symtab.h:

Shared declarations for symbol-table routines. Note: uses
declarations in defs.h.

Copyright (C) 1992 by Robert K. Moniot.
This program is free software. Permission is granted to
modify it and/or redistribute it, retaining this notice.
No guarantees accompany this software.


*/

#ifdef SYMTAB /* "home" for variables is symtab.c */
#define SYM_SHARED
#else
#define SYM_SHARED extern
#endif

/* Definitions of symbol table information */

/* Token subclasses (classes are in tokdefs.h)
*/

#define relop_EQ 0
#define relop_NE 1
#define relop_LE 2
#define relop_LT 3
#define relop_GE 4
#define relop_GT 5



/* Storage Class types for variables, consts, and externals */
#define class_VAR 0
#define class_SUBPROGRAM 1
#define class_COMMON_BLOCK 2
#define class_STMT_FUNCTION 3
#define class_LABEL 4
#define class_NAMELIST 5


/* Data types for variables, consts, and externals */
/* N.B. 0 thru 7 are wired into lookup tables in exprtype.c */
#define type_UNDECL 0
#define type_ERROR 0 /* for result of erroneous operation */
#define type_INTEGER 1
#define type_REAL 2
#define type_DP 3
#define type_COMPLEX 4
#define type_LOGICAL 5
#define type_STRING 6
#define type_HOLLERITH 7
#define type_GENERIC 8
#define type_SUBROUTINE 9
#define type_COMMON_BLOCK 10
#define type_PROGRAM 11
#define type_BLOCK_DATA 12
#define type_LABEL 13
#define type_NAMELIST 14

/* test for types usable in exprs */
#define is_computational_type(t) ((t) <= 7)
/* test for arith, char, or logical type */
#define is_const_type(t) ((datatype_of(t) > 0) && (datatype_of(t) <= 6))


typedef unsigned char BYTE;


/* Array of class and type name translations */
#ifdef SYMTAB
char *class_name[] = {
"",
"subprog",
"common",
"stmt fun",
"label",
"namelist",
};
char *type_name[] = {
"undf",
"intg",
"real",
"dble",
"cplx",
"logl",
"char",
"holl",
"genr",
"subr",
"comm",
"prog",
"data",
"labl",
"naml",
};

/* Typical sizes of objects of each data type */
BYTE type_size[]={ /* for use in check_mixed_common */
0, /*undf*/
4, /*intg*/
4, /*real*/
8, /*dble*/
8, /*cplx*/
4, /*logl*/
1, /*char*/
4, /*holl*/
0, /*genr*/
0, /*subr*/
0, /*comm*/
0, /*prog*/
0, /*data*/
0, /*labl*/
0, /*naml*/
};

#else
extern char *class_name[];
extern char *type_name[];
extern BYTE type_size[];
#endif


/* implicit and default typing lookup table */
SYM_SHARED
int implicit_type[26]; /* indexed by [char - 'A'] */



/* Declaration of Token data structure. N.B. do not change without
consulting preamble of fortran.y for uses with nonterminals.
*/
struct tokstruct {
union {
long integer;
double dbl;
char *string;
} value;
struct tokstruct *next_token;
long class,subclass;
unsigned line_num; /* Line and column where token occurred */
unsigned col_num : 8;
};

typedef struct tokstruct Token;

#define YYSTYPE Token /* Type defn for yylval and Yacc stack */



SYM_SHARED
unsigned long loc_symtab_top, /* Next avail spot in local symbol table */
glob_symtab_top; /* Ditto global */

SYM_SHARED
char strspace[STRSPACESZ]; /* String space for storing identifiers */
/* Stringspace is partitioned into local (growing from bottom up)
and global (growing from top down). */

SYM_SHARED
unsigned long loc_str_top, /* Top of local stringspace */
glob_str_bot; /* Bottom of global stringspace */

SYM_SHARED
unsigned long token_space_top; /* Top of token space */
SYM_SHARED
Token tokenspace[TOKENSPACESZ];


/* Define names for anonymous things */
#ifdef SYMTAB
char *blank_com_name = "%BLANK", /* id for blank common entry in symtab */
*unnamed_prog="%MAIN", /* id for unnamed program module */
*unnamed_block_data="%DAT00"; /* id for unnamed block data module */
int block_data_number=0; /* count of multiple anonymous block data */
#else
extern char *blank_com_name,
*unnamed_prog,
*unnamed_block_data;
extern int block_data_number;
#endif

/* Symbol table argument list declarations */

typedef union { /* InfoUnion: misc info about symtab entry */
unsigned long array_dim; /* array size and no. of dims */
struct ALHead *arglist; /* ptr to func/subr argument list */
struct CMHead *comlist; /* ptr to common block list */
struct TLHead *toklist; /* ptr to token list */
struct IInfo *intrins_info;/* ptr to intrinsic func info */
long int_value; /* value of integer parameter */
} InfoUnion;

typedef struct { /* ArgListElement: holds subprog argument data */
InfoUnion info;
BYTE type;
unsigned is_lvalue: 1,
set_flag: 1,
assigned_flag: 1,
used_before_set: 1,
array_var: 1,
array_element: 1,
declared_external: 1;
} ArgListElement;


typedef struct ALHead { /* ArgListHeader: head node of argument list */
BYTE type;
short numargs;
ArgListElement *arg_array;
struct gSymtEntry *module;
char *filename,*topfile;
unsigned
line_num,
is_defn: 1,
is_call: 1,
external_decl: 1, /* EXTERNAL decl, not arg list */
actual_arg: 1; /* subprog passed as arg */
struct ALHead *next;
} ArgListHeader;

/* Symbol table common block list declarations */

typedef struct { /* ComListElement: holds common var data */
unsigned long dimen_info;
BYTE type;
} ComListElement;

typedef struct CMHead { /* ComListHeader: head node of common var list */
short numargs;
short flags;
unsigned line_num;
ComListElement *com_list_array;
struct gSymtEntry *module;
char *filename,*topfile;
struct CMHead *next;
} ComListHeader;


typedef struct TLHead { /* TokenListHeader: head node of token list */
Token *tokenlist;
struct TLHead *next;
char *filename;
unsigned line_num;
unsigned
external_decl:1,
actual_arg:1;
} TokenListHeader;


/* Structure for intrinsic-function info */
typedef struct IInfo{
char *name;
short num_args,arg_type,result_type;
} IntrinsInfo;


/* Structure for call-tree child list */
typedef struct childlist {
struct gSymtEntry *child; /* Pointer to child's symtab entry */
struct childlist *next;/* Pointer to next child on list */
} ChildList;

/* Identifier symbol table declaration */


typedef struct lSymtEntry{
char *name; /* Identifier name in stringspace */
InfoUnion info;
struct lSymtEntry *equiv_link; /* Link for equivalence lists */
BYTE type; /* Type & storage class: see macros below */
/* Flags */
unsigned
used_flag: 1,
set_flag: 1,
assigned_flag: 1,
used_before_set: 1,
is_current_module: 1,
library_module: 1,
array_var: 1,
common_var: 1,
entry_point: 1,
parameter: 1,
argument: 1,
external: 1,
intrinsic: 1,
invoked_as_func: 1,
defined_in_include: 1,
declared_external: 1;
} Lsymtab;

typedef struct gSymtEntry{ /* Global symbol table element */
char *name; /* Identifier name in stringspace */
InfoUnion info;
union {
struct childlist *child_list; /* List of callees (for module) */
struct gSymtEntry *module; /* Module (for interior entry) */
} link;
BYTE type; /* Type & storage class: see macros below */
/* Flags */
unsigned
used_flag: 1,
set_flag: 1,
assigned_flag: 1,
used_before_set: 1,
library_module: 1,
internal_entry: 1, /* entry point other than at the top */
invoked_as_func: 1,
visited: 1, /* this entry point is in call tree */
visited_somewhere: 1, /* some entry point of module is in call tree */
defined_in_include: 1,
declared_external: 1;
} Gsymtab;



/* Macro to zero out symbol table entry */

#define clear_symtab_entry(S) {register int i;\
for(i=0;i

/* These macros pack and unpack datatype and storage class in type
field of symbol table entry. Datatype is least 4 bits. */

#define datatype_of(TYPE) ((TYPE) & 0xF)
#define storage_class_of(TYPE) ((TYPE) >> 4)
#define type_byte(SCLASS,DTYPE) (((SCLASS)<<4) + (DTYPE))


/* This macro is for pattern matching in flag checking */

#define flag_combo(A,B,C) (((A)<<2) | ((B)<<1) | (C))


/* These macros are for dimensions & sizes of arrays */

#define array_dims(dim_info) ((dim_info)&0xF)
#define array_size(dim_info) ((dim_info)>>4)
#define array_dim_info(dim,size) (((long)(size)<<4)+(dim))



/* Defns used by expression type propagation mechanisms
in fortran.y and exprtype.c The flags go in token.subclass
*/

#define make_true(flag,x) ((x) |= (flag)) /* x.flag <-- true */
#define make_false(flag,x) ((x) &= ~(flag)) /* x.flag <-- false */
#define is_true(flag,x) ((x) & (flag)) /* x.flag == true? */
#define copy_flag(flag,x,y) ((x) |= ((y)&(flag))) /* x.flag <-- y.flag */

#define ID_EXPR 0x1 /* a variable */
#define LVALUE_EXPR 0x2 /* assignable */
#define CONST_EXPR 0x4 /* compile-time constant */
#define NUM_CONST 0x8 /* a number */
#define ARRAY_ID_EXPR 0x10 /* an array or array element */
#define INT_QUOTIENT_EXPR 0x20 /* contains INT/INT */
#define STMT_FUNCTION_EXPR 0x40
#define PARAMETER_EXPR 0x80 /* == CONST_EXPR or intrinsic funcs */
#define SET_FLAG 0x100 /* these are for id's and lvalues */
#define ASSIGNED_FLAG 0x200
#define USED_BEFORE_SET 0x400
#define COMMA_FLAG 0x800 /* keeps track of extra or missing commas
in exprlists */
#define COMPLEX_FLAG 0x1000 /* keeps track of complex_const_allowed */


SYM_SHARED
Lsymtab loc_symtab[LOCSYMTABSZ];
SYM_SHARED
Gsymtab glob_symtab[GLOBSYMTABSZ];

/* Identifier hashtable declaration */

SYM_SHARED
struct {
char *name; /* Identifier name in stringspace */
Lsymtab *loc_symtab, /* Local symtab entry for vars etc. */
*com_loc_symtab;/* Local symtab entry for common blocks */
Gsymtab *glob_symtab, /* Global symtab entry for vars etc. */
*com_glob_symtab;/* Global symtab entry for common blocks */
} hashtab[HASHSZ];



/* Shared routines */

/* in fortran.y/fortran.c */
void
check_seq_header();

/* in prsymtab.c */
void
debug_symtabs(), print_loc_symbols();

/* in symtab.c */
void
call_func(), call_subr(), declare_type(), def_arg_name(),
def_array_dim(), def_com_block(), def_com_variable(),
def_equiv_name(), def_ext_name(), def_function(), def_intrins_name(),
def_namelist(), def_namelist_item(), def_parameter(),
def_stmt_function(), do_ASSIGN(), do_assigned_GOTO(), do_ENTRY(),
do_RETURN(), equivalence(),
init_globals(), init_symtab(),
process_lists(), ref_array(), ref_namelist(), ref_variable(),
set_implicit_type(),
stmt_function_stmt(),use_actual_arg(), use_implied_do_index(),
use_io_keyword(), use_special_open_keywd(),
use_lvalue(), use_parameter(),
use_function_arg(), use_variable();

Token
*new_token();

Lsymtab
*install_local();
Gsymtab
*install_global();

unsigned
hash_lookup();

int
def_curr_module(), get_type(), int_expr_value();

char *
token_name();
/* in hash.c (now symtab.c) */
unsigned long
hash(), kwd_hash(), rehash();

/* in symtab2.c */
void /* exprtype routines */
binexpr_type(),unexpr_type(),assignment_stmt_type(),
func_ref_expr(),primary_id_expr();