objects.h Source Code

Routines In This File (Alphabetical)

 Line Name
----- ----
  240 add_caller
  106 add_lang
  237 add_ref
  172 add_srcref
  215 def_begin
  219 def_callers
  216 def_end
  217 def_length
  212 def_name
  230 def_num_callers
  231 def_num_calls
  218 def_refs
  214 def_root
  213 def_source
  220 def_tree_required
  221 def_tree_size
  222 def_xreffile
  242 find_caller
  241 find_ref
  166 inc_source_calls
  160 inc_source_comments
  163 inc_source_empty
  162 inc_source_mixed
  165 inc_source_rlength
  164 inc_source_routines
  161 inc_source_statements
  244 isalready_expanded
  243 isdefined_routine
  278 isrecursive_ref
   98 lang_code
   97 lang_fext
  239 pop_ref
  238 push_ref
  271 ref_caller
  268 ref_definition
  270 ref_line
  269 ref_name
  272 ref_offset
  107 remove_lang
  225 set_def_begin
  226 set_def_end
  224 set_def_root
  223 set_def_source
  227 set_def_tree_req
  228 set_def_tree_size
  229 set_def_xreffile
  100 set_lang_code
   99 set_lang_fext
  159 set_source_byfilefile
  155 source_avglen
  158 source_byfilefile
  156 source_calls
  149 source_comments
  152 source_empty
  148 source_line
  146 source_lines
  151 source_mixed
  145 source_name
  157 source_reflist
  154 source_rlength
  153 source_routines
  144 source_seq
  150 source_statements
  147 source_tabsize

BEGINNING OF FILE

     1: /****************************************************************************/
     2: /*									    */
     3: /*  FACILITY:	Routine Analyzer					    */
     4: /*									    */
     5: /*  MODULE:	Object Management Support Header			    */
     6: /*									    */
     7: /*  AUTHOR:	Steve Branam, Network Product Support Group, Digital	    */
     8: /*		Equipment Corporation, Littleton, MA, USA.		    */
     9: /*									    */
    10: /*  DESCRIPTION: This header file contains all type definitions for the	    */
    11: /*  object types used by Routine Analyzer. Member access routines (get/set  */
    12: /*  values) and a number of object management routines are implemented here */
    13: /*  as macros.								    */
    14: /*									    */
    15: /*  REVISION HISTORY:							    */
    16: /*									    */
    17: /*  V0.1-01 09-JAN-1994 Steve Branam                                        */  
    18: /*                                                                          */
    19: /*      Replace LANGUAGE_C with LANGUAGE_CC to avoid conflict with Unix     */
    20: /*      C compiler predefined symbol.                                       */
    21: /*									    */
    22: /*  V0.1-00 24-AUG-1994 Steve Branam					    */
    23: /*									    */
    24: /*	Original version.						    */
    25: /*									    */
    26: /****************************************************************************/
    27: 
    28: #ifndef __OBJECTS_H
    29: #define __OBJECTS_H
    30: 
    31: /*									    */
    32: /* String object names.							    */
    33: /*									    */
    34: 
    35: #define OBJ_NAME_FILENAME	"File name"
    36: #define OBJ_NAME_LANG_EXT	"Language file extension"
    37: #define OBJ_NAME_ROUTINENAME	"Routine name"
    38: #define OBJ_NAME_AUTHORNAME	"Program author"
    39: 
    40: /****************************************************************************/
    41: /*									    */
    42: /* LIST ENTRY OBJECTS							    */
    43: /*									    */
    44: /*	This general class of objects can be strung together on a	    */
    45: /*	doubly-linked list. There are several specific subtypes in this	    */
    46: /*	general class:							    */
    47: /*									    */
    48: /*	Language Translation Record					    */
    49: /*									    */
    50: /*	    Contains all the information for a file extension-to-language   */
    51: /*	    translation.						    */
    52: /*									    */
    53: /*	Source File Record						    */
    54: /*									    */
    55: /*	    Contains all the information for a single source file.	    */
    56: /*									    */
    57: /*	Routine Definition Record					    */
    58: /*									    */
    59: /*	    Contains all the information for the definition of a single	    */
    60: /*	    routine.							    */
    61: /*									    */
    62: /*	Routine Reference Record					    */
    63: /*									    */
    64: /*	    Contains all the information for a given reference (call) to    */
    65: /*	    a routine.							    */
    66: /*									    */
    67: /****************************************************************************/
    68: 
    69: /****************************************************************************/
    70: /*									    */
    71: /* Language translation record object type.				    */
    72: /*									    */
    73: /****************************************************************************/
    74: 
    75: #define OBJ_NAME_LANGTRANS	"LANGUAGE_TRANSLATION"
    76: 
    77: typedef enum {				    /* List of known languages.	    */
    78:     LANGUAGE_UNKNOWN,
    79:     LANGUAGE_TEXT,
    80:     LANGUAGE_DCL,
    81:     LANGUAGE_BLISS,
    82:     LANGUAGE_CC
    83: } SOURCE_LANGUAGE;
    84: 
    85: typedef struct lang_trans_record {
    86:     LIST_ENTRY_HDR			    /* List linkage.		    */
    87: 	    entry_hdr;
    88:     char    *fext;			    /* File extension string.	    */
    89:     SOURCE_LANGUAGE			    /* Language code.		    */
    90: 	    code;
    91: } LANGUAGE_TRANSLATION;
    92: 
    93: /*									    */
    94: /* Language translation member access routines.				    */
    95: /*									    */
    96: 

    97: #define lang_fext(l) ((l)->fext)

    98: #define lang_code(l) ((l)->code)

    99: #define set_lang_fext(l, s) ((l)->fext = s)

   100: #define set_lang_code(l, x) ((l)->code = x)

   101: 
   102: /*									    */
   103: /* Language translation management routines.				    */
   104: /*									    */
   105: 

   106: #define add_lang(l) (enqueue_entry(global_langlist(), l))

   107: #define remove_lang() (dequeue_entry(global_langlist()))

   108: 
   109: /****************************************************************************/
   110: /*									    */
   111: /* Source file record object type.					    */
   112: /*									    */
   113: /****************************************************************************/
   114: 
   115: #define OBJ_NAME_SOURCEFILE	"SOURCEFILE"
   116: 
   117: typedef struct source_record {
   118:     LIST_ENTRY_HDR			    /* List linkage.		    */
   119: 	    entry_hdr;
   120:     int	    seqnum;			    /* File sequence number.	    */
   121:     char    *name;			    /* File name.		    */
   122:     char    *author;			    /* Program author, that's me!   */
   123:     int	    tabsize;			    /* Source text tab size.	    */
   124:     long    lines;			    /* Total number of lines.	    */
   125:     long    comments;			    /* Number comment-only lines.   */
   126:     long    statements;			    /* Number statement-only lines. */
   127:     long    mixed;			    /* Number mixed comment/	    */
   128: 					    /* statement lines.		    */
   129:     long    routines;			    /* Number routines defined.	    */
   130:     long    rlength;			    /* Length of all routine defs.  */
   131:     long    calls;			    /* Number of routine calls made */
   132: 					    /* in this file.		    */
   133:     LIST    reflist;			    /* List of routines defined in  */
   134: 					    /* this file, treated as	    */
   135: 					    /* callers.			    */
   136:     int	    byfilefile;			    /* By-file report file number   */
   137: 					    /* for linking.		    */
   138: } SOURCEFILE;
   139: 
   140: /*									    */
   141: /* Source file record member access routines.				    */
   142: /*									    */
   143: 

   144: #define source_seq(src) ((src)->seqnum)

   145: #define source_name(src) ((src)->name)

   146: #define source_lines(src) ((src)->lines)

   147: #define source_tabsize(src) ((src)->tabsize)

   148: #define source_line(src) ((src)->lines + 1)

   149: #define source_comments(src) ((src)->comments)

   150: #define source_statements(src) ((src)->statements)

   151: #define source_mixed(src) ((src)->mixed)

   152: #define source_empty(src) ((src)->lines-(src)->mixed-(src)->comments-(src)->statements)

   153: #define source_routines(src) ((src)->routines)

   154: #define source_rlength(src) ((src)->rlength)

   155: #define source_avglen(src) (source_routines(src)==0?0:((source_rlength(src) * 10)/source_routines(src) + 5)/ 10)

   156: #define source_calls(src) ((src)->calls)

   157: #define source_reflist(src) (&(src)->reflist)

   158: #define source_byfilefile(src) ((src)->byfilefile)

   159: #define set_source_byfilefile(src, f) ((src)->byfilefile = f)

   160: #define inc_source_comments(src) ((src)->lines++,(src)->comments++)

   161: #define inc_source_statements(src) ((src)->lines++,(src)->statements++)

   162: #define inc_source_mixed(src) ((src)->lines++,(src)->mixed++)

   163: #define inc_source_empty(src) ((src)->lines++)

   164: #define inc_source_routines(src) ((src)->routines++)

   165: #define inc_source_rlength(src, x) ((src)->rlength += x)

   166: #define inc_source_calls(src, x) ((src)->calls += x)

   167: 
   168: /*									    */
   169: /* Source file record management routines.				    */
   170: /*									    */
   171: 

   172: #define add_srcref(s,r) (insert_ordered_entry(&(s)->reflist, r, compare_caller))

   173: 
   174: /****************************************************************************/
   175: /*									    */
   176: /* Routine definition record object type.				    */
   177: /*									    */
   178: /****************************************************************************/
   179: 
   180: typedef enum {
   181:     NOT_YET_EVALUATED,
   182:     TREE_REQUIRED,
   183:     TREE_NOT_REQUIRED
   184: } TREE_REQ;
   185: 
   186: #define OBJ_NAME_DEFINITION	"DEFINITION"
   187: 
   188: typedef struct definition_record {
   189:     LIST_ENTRY_HDR			    /* List linkage.		    */
   190: 	    entry_hdr;
   191:     char    *name;			    /* Routine name.		    */
   192:     struct source_record
   193: 	    *source;			    /* Ptr to source file record.   */
   194:     struct definition_record		    /* Ptr to root of call tree.    */
   195: 	    *rootdef;
   196:     long    begin;			    /* Beginning line in source.    */
   197:     long    end;			    /* Ending line in source.	    */
   198:     LIST    refs;			    /* List of referenced routines. */
   199:     LIST    callers;			    /* List of referencing	    */
   200: 					    /* routines.		    */
   201:     TREE_REQ				    /* Call tree required flag.	    */
   202: 	    needs_tree;
   203:     int	    treesize;			    /* Number of nodes in tree.	    */
   204:     int	    xreffile;			    /* Xref report file number for  */
   205: 					    /* linking.			    */
   206: } DEFINITION;
   207: 
   208: /*									    */
   209: /* Routine definition record member access routines.			    */
   210: /*									    */
   211: 

   212: #define def_name(def) ((def)->name)

   213: #define def_source(def) ((def)->source)

   214: #define def_root(def) ((def)->rootdef)

   215: #define def_begin(def) ((def)->begin)

   216: #define def_end(def) ((def)->end)

   217: #define def_length(def) (def_end(def) - def_begin(def) + 1)

   218: #define def_refs(def) (&(def)->refs)

   219: #define def_callers(def) (&(def)->callers)

   220: #define def_tree_required(def) ((def)->needs_tree)

   221: #define def_tree_size(def) ((def)->treesize)

   222: #define def_xreffile(def) ((def)->xreffile)

   223: #define set_def_source(def, s) ((def)->source = s)

   224: #define set_def_root(def, x) ((def)->rootdef = x)

   225: #define set_def_begin(def, x) ((def)->begin = x)

   226: #define set_def_end(def, x) ((def)->end = x)

   227: #define set_def_tree_req(def, x) ((def)->needs_tree = x)

   228: #define set_def_tree_size(def, x) ((def)->treesize = x)

   229: #define set_def_xreffile(def, f) ((def)->xreffile = f)

   230: #define def_num_callers(def) (list_entries(&(def)->callers))

   231: #define def_num_calls(def) (list_entries(&(def)->refs))

   232: 
   233: /*									    */
   234: /* Routine definition record management routines.			    */
   235: /*									    */
   236: 

   237: #define add_ref(d, r) (append_list_entry(&(d)->refs, r))

   238: #define push_ref(d, r) (push_entry(&(d)->refs, r))

   239: #define pop_ref(d) (pop_entry(&(d)->refs))

   240: #define add_caller(d,r) (insert_ordered_entry(&(d)->callers, r, compare_caller))

   241: #define find_ref(d,r) (find_list_entry(&(d)->refs, r, compare_ref))

   242: #define find_caller(d,r) (find_list_entry(&(d)->callers, r, compare_caller_name))

   243: #define isdefined_routine(def) ((def)->source != NULL)

   244: #define isalready_expanded(def, root) (!tree_inline_disabled() && isdefined_routine(def) && (def)->rootdef == root)

   245: 
   246: /****************************************************************************/
   247: /*									    */
   248: /* Routine reference record object type.				    */
   249: /*									    */
   250: /****************************************************************************/
   251: 
   252: #define OBJ_NAME_REFERENCE	"REFERENCE"
   253: 
   254: typedef struct reference_record {
   255:     LIST_ENTRY_HDR			    /* List linkage.		    */
   256: 	    entry_hdr;
   257:     struct definition_record		    /* Ptr to routine definition    */
   258: 	    *definition;		    /* record.			    */
   259:     long    line;			    /* Line in source where called. */
   260:     struct definition_record		    /* Ptr to routine definition    */
   261: 	    *caller;			    /* record of caller.	    */
   262: } REFERENCE;
   263: 
   264: /*									    */
   265: /* Routine reference record member access routines.			    */
   266: /*									    */
   267: 

   268: #define ref_definition(ref) (ref->definition)

   269: #define ref_name(ref) (def_name(ref_definition(ref)))

   270: #define ref_line(ref) (ref->line)

   271: #define ref_caller(ref) (ref->caller)

   272: #define ref_offset(ref) (ref_line(ref) - def_begin(ref_caller(ref)) + 1)

   273: 
   274: /*									    */
   275: /* Routine reference record management routines.			    */
   276: /*									    */
   277: 

   278: #define isrecursive_ref(ref, root) (find_ref(root, ref) != NULL)

   279: 
   280: /****************************************************************************/
   281: /*									    */
   282: /* Forward references.							    */
   283: /*									    */
   284: /****************************************************************************/
   285: 
   286: REFERENCE *find_ref_in_tree();
   287: int compare_ref();
   288: int compare_file();
   289: int compare_caller();
   290: char *def_ident();
   291: 
   292: #endif /* #ifndef __OBJECTS_H */

END OF FILE

TOTAL: 64 routines, 1 Avg Length