MultiSource/Applications/treecc/info.h

   1 /*
   2  * info.h - Store information about parsed "treecc" input files.
   3  *
   4  * Copyright (C) 2001  Southern Storm Software, Pty Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #ifndef _TREECC_INFO_H
  22 #define _TREECC_INFO_H
  23
  24 #include "stream.h"
  25
  26 #ifdef  __cplusplus
  27 extern  "C" {
  28 #endif
  29
  30 /*
  31  * Forward declarations.
  32  */
  33 typedef struct _tagTreeCCField                  TreeCCField;
  34 typedef struct _tagTreeCCNode                   TreeCCNode;
  35 typedef struct _tagTreeCCOperation              TreeCCOperation;
  36 typedef struct _tagTreeCCParam                  TreeCCParam;
  37 typedef struct _tagTreeCCVirtual                TreeCCVirtual;
  38 typedef struct _tagTreeCCTrigger                TreeCCTrigger;
  39 typedef struct _tagTreeCCOperationCase  TreeCCOperationCase;
  40
  41 /*
  42  * Field definition flags.
  43  */
  44 #define TREECC_FIELD_NOCREATE           1
  45
  46 /*
  47  * Node definition flags.
  48  */
  49 #define TREECC_NODE_UNDEFINED           1
  50 #define TREECC_NODE_ABSTRACT            2
  51 #define TREECC_NODE_TYPEDEF                     4
  52 #define TREECC_NODE_ENUM                        8
  53 #define TREECC_NODE_ENUM_VALUE          16
  54 #define TREECC_NODE_MARK(n)                     (0x100 << (n))
  55 #define TREECC_NODE_MARK_BITS           0xFF00
  56
  57 /*
  58  * Operation flags.
  59  */
  60 #define TREECC_OPER_VIRTUAL                     1
  61 #define TREECC_OPER_INLINE                      2
  62 #define TREECC_OPER_SPLIT                       4
  63
  64 /*
  65  * Parameter flags.
  66  */
  67 #define TREECC_PARAM_TRIGGER            1
  68
  69 /*
  70  * Language values.
  71  */
  72 #define TREECC_LANG_C                           0
  73 #define TREECC_LANG_CPP                         1
  74 #define TREECC_LANG_JAVA                        2
  75 #define TREECC_LANG_CSHARP                      3
  76 #define TREECC_LANG_RUBY                        4
  77 #define TREECC_LANG_PHP                         5
  78
  79 /*
  80  * Information that is stored about a field.
  81  */
  82 struct _tagTreeCCField
  83 {
  84         char               *name;               /* Name of the field */
  85         char               *type;               /* Type associated with the field */
  86         char               *value;              /* Default value for the field */
  87         int                             flags;          /* Field flags */
  88         char               *filename;   /* File that defines the field */
  89         long                    linenum;        /* Line where the field is defined */
  90         TreeCCField        *next;               /* Next field for the node type */
  91
  92 };
  93
  94 /*
  95  * Information that is stored about a node type.
  96  */
  97 struct _tagTreeCCNode
  98 {
  99         TreeCCNode         *parent;             /* Parent node type */
 100         TreeCCNode         *firstChild; /* First child node type */
 101         TreeCCNode         *lastChild;  /* Last child node type */
 102         TreeCCNode         *nextSibling;/* Next sibling node type under parent */
 103         char               *name;               /* Name of this node type */
 104         int                             flags;          /* Node flags */
 105         int                             number;         /* Number associated with this node type */
 106         int                             position;       /* Position within the tree for operations */
 107         char               *filename;   /* File that defines the node type */
 108         long                    linenum;        /* Line where the node type is defined */
 109         TreeCCField    *fields;         /* List of fields for this node type */
 110         TreeCCVirtual  *virtuals;       /* List of virtual methods for this node */
 111         TreeCCNode         *nextHash;   /* Next in the name hash table */
 112         TreeCCStream   *header;         /* Stream to write header to */
 113         TreeCCStream   *source;         /* Stream to write source to */
 114
 115 };
 116
 117 /*
 118  * Information that is stored about an operation.
 119  */
 120 struct _tagTreeCCOperation
 121 {
 122         char               *name;               /* Name of the operation */
 123         char               *className;  /* Name of the enclosing class */
 124         char               *returnType; /* Return type for the operation */
 125         char               *defValue;   /* Default value for the operation */
 126         TreeCCParam    *params;         /* Parameters for the operation */
 127         int                             flags;          /* Flags associated with the operation */
 128         int                             numTriggers;/* Number of trigger parameters */
 129         char               *filename;   /* File where the operation is declared */
 130         long                    linenum;        /* Line where the operation is declared */
 131         TreeCCOperation *nextHash;      /* Next in the operation hash table */
 132         TreeCCOperationCase *firstCase; /* First case associated with operation */
 133         TreeCCOperationCase *lastCase;  /* Last case associated with operation */
 134         TreeCCOperationCase **sortedCases; /* Cases sorted for non-virtual ops */
 135         int                             numCases;       /* Number of operation cases */
 136         TreeCCStream   *header;         /* Stream to write header to */
 137         TreeCCStream   *source;         /* Stream to write source to */
 138
 139 };
 140
 141 /*
 142  * Information that is stored about an operation parameter.
 143  */
 144 struct _tagTreeCCParam
 145 {
 146         char               *name;               /* Name of the parameter */
 147         char               *type;               /* Type for the parameter */
 148         int                             flags;          /* Flags associated with the parameter */
 149         int                             size;           /* Dimension size for non-virtual operations */
 150         TreeCCParam        *next;               /* Next parameter for the operation */
 151
 152 };
 153
 154 /*
 155  * Information that is stored about a virtual method on a node type.
 156  */
 157 struct _tagTreeCCVirtual
 158 {
 159         char               *name;               /* Name of the virtual method */
 160         char               *returnType; /* Return type for the virtual method */
 161         TreeCCParam        *params;             /* Non-instance parameters */
 162         TreeCCOperation *oper;          /* Operation block for the virtual */
 163         TreeCCVirtual  *next;           /* Next virtual method for the node type */
 164
 165 };
 166
 167 /*
 168  * Information that is stored about a trigger match on an operation case.
 169  */
 170 struct _tagTreeCCTrigger
 171 {
 172         TreeCCNode         *node;               /* Node type for the trigger */
 173         TreeCCTrigger  *next;           /* Next trigger for this case */
 174
 175 };
 176
 177 /*
 178  * Information that is stored about an operation case.
 179  */
 180 struct _tagTreeCCOperationCase
 181 {
 182         TreeCCTrigger  *triggers;       /* Trigger list for this case */
 183         char               *code;               /* Code associated with the case */
 184         TreeCCOperation *oper;          /* Operation this case is associated with */
 185         int                             number;         /* Reference number for code generation */
 186         char               *filename;   /* File that starts the case definition */
 187         long                    linenum;        /* Line that starts the case definition */
 188         char               *codeFilename;/* File that starts the code */
 189         long                    codeLinenum;/* Line that starts the code */
 190         TreeCCOperationCase *next;      /* Next case for the operation */
 191         TreeCCOperationCase *nextHeader; /* Next header for same code block */
 192
 193 };
 194
 195 /*
 196  * Context object that stores all definitions parsed from the input.
 197  */
 198 #define TREECC_HASH_SIZE        512
 199 typedef struct _tagTreeCCContext
 200 {
 201         /* Hash table that allows quick lookup of node types */
 202         TreeCCNode         *nodeHash[TREECC_HASH_SIZE];
 203
 204         /* Hash table that allows quick lookup of operation names */
 205         TreeCCOperation *operHash[TREECC_HASH_SIZE];
 206
 207         /* Current input stream */
 208         TreeCCInput        *input;
 209
 210         /* Output streams */
 211         TreeCCStream   *streamList;                     /* List of all streams */
 212         TreeCCStream   *headerStream;           /* Current header stream */
 213         TreeCCStream   *sourceStream;           /* Current source stream */
 214         TreeCCStream   *commonHeader;           /* Stream for common definitions */
 215         TreeCCStream   *commonSource;           /* Stream for common source */
 216
 217         /* Flags that control the behaviour of the program */
 218         int                             debugMode : 1;          /* Enable debug output */
 219         int                             track_lines : 1;        /* Track node creation lines */
 220         int                             no_singletons : 1;      /* Don't handle singletons specially */
 221         int                             reentrant : 1;          /* Build a re-entrant system */
 222         int                             force : 1;                      /* Force the creation of files */
 223         int                             virtual_factory : 1;/* Allow overrides of factory methods */
 224         int                             abstract_factory : 1;/* Declare factory methods abstract */
 225         int                             kind_in_vtable : 1;     /* Put kind value in vtable only */
 226         int                             strip_filenames : 1; /* Strip names in #line directives */
 227         int                             print_lines : 1;        /* Dont emit #line directives */
 228         int                             internal_access : 1; /* Use "internal" classes in C# */
 229         int                             use_allocator : 1;      /* Use the skeleton allocator */
 230         int                             use_gc_allocator : 1; /* Use the libgc allocator */
 231
 232         /* String to use to replace "yy" in output files */
 233         char               *yy_replacement;
 234
 235         /* Name of the type to use for re-entrant state */
 236         char               *state_type;
 237
 238         /* Namespace to store declarations within */
 239         char               *namespace;
 240
 241         /* Current node type number */
 242         int                             nodeNumber;
 243
 244         /* Output source language to use */
 245         int                             language;
 246
 247         /* Size of blocks to use in C/C++ memory alloction */
 248         int                             block_size;
 249
 250         /* Name of the directory to output Java source files to */
 251         char               *outputDirectory;
 252
 253         /* name of the base type which is what %typedef expands to */
 254         char               *baseType;
 255
 256 } TreeCCContext;
 257
 258 /*
 259  * Create a context.
 260  */
 261 TreeCCContext *TreeCCContextCreate(TreeCCInput *input);
 262
 263 /*
 264  * Destroy a context.
 265  */
 266 void TreeCCContextDestroy(TreeCCContext *context);
 267
 268 /*
 269  * Hash a string.
 270  */
 271 unsigned int TreeCCHashString(const char *str);
 272
 273 /*
 274  * Flags for "TreeCCAddLiteralDefn".
 275  */
 276 #define TREECC_LITERAL_CODE                     1               /* In source */
 277 #define TREECC_LITERAL_DECLS            2               /* In header */
 278 #define TREECC_LITERAL_END                      4               /* Place at end */
 279
 280 /*
 281  * Add a literal code definition block to the context.
 282  */
 283 void TreeCCAddLiteralDefn(TreeCCContext *context, char *code, int flags);
 284
 285 /*
 286  * Free a node definition.
 287  */
 288 void TreeCCNodeFree(TreeCCNode *node);
 289
 290 /*
 291  * Create a new node definition.
 292  */
 293 TreeCCNode *TreeCCNodeCreate(TreeCCContext *context, long linenum,
 294                                                          char *name, char *parent, int flags);
 295
 296 /*
 297  * Find a node definition given its name.
 298  */
 299 TreeCCNode *TreeCCNodeFind(TreeCCContext *context, const char *name);
 300
 301 /*
 302  * Find a node definition given a type name, which may be
 303  * either "identifier" or "identifier *".
 304  */
 305 TreeCCNode *TreeCCNodeFindByType(TreeCCContext *context, const char *name);
 306
 307 /*
 308  * Validate the node type hierarchy to ensure that everything is defined.
 309  */
 310 void TreeCCNodeValidate(TreeCCContext *context);
 311
 312 /*
 313  * Visit every node type in a context's hierarchy.
 314  */
 315 typedef void (*TreeCCNodeVisitor)(TreeCCContext *context, TreeCCNode *node);
 316 void TreeCCNodeVisitAll(TreeCCContext *context, TreeCCNodeVisitor visitor);
 317
 318 /*
 319  * Determine if a node type is a singleton.  i.e. no fields.
 320  */
 321 int TreeCCNodeIsSingleton(TreeCCNode *node);
 322
 323 /*
 324  * Determine if a node type has abstract virtual operation cases.
 325  */
 326 int TreeCCNodeHasAbstracts(TreeCCContext *context, TreeCCNode *node);
 327
 328 /*
 329  * Add a virtual operation to a node.
 330  */
 331 void TreeCCNodeAddVirtual(TreeCCContext *context, TreeCCNode *node,
 332                                                   TreeCCOperation *oper);
 333
 334 /*
 335  * Determine if "nodea" inherits from "nodeb".
 336  */
 337 int TreeCCNodeInheritsFrom(TreeCCNode *nodea, TreeCCNode *nodeb);
 338
 339 /*
 340  * Clear all marking bits that are used to track operation coverage.
 341  */
 342 void TreeCCNodeClearMarking(TreeCCContext *context, int flags);
 343
 344 /*
 345  * Assign positions to all nodes started at a particular place
 346  * in the node type hierarchy.  Returns the number of positions.
 347  */
 348 int TreeCCNodeAssignPositions(TreeCCNode *node);
 349
 350 /*
 351  * Create a new field definition and add it to a node.
 352  */
 353 void TreeCCFieldCreate(TreeCCContext *context, TreeCCNode *node,
 354                                            char *name, char *type, char *value, int flags);
 355
 356 /*
 357  * Free an operation.
 358  */
 359 void TreeCCOperationFree(TreeCCOperation *oper);
 360
 361 /*
 362  * Create a new operation.
 363  */
 364 TreeCCOperation *TreeCCOperationCreate(TreeCCContext *context,
 365                                                                            char *returnType, char *name,
 366                                                                            char *className, char *defValue,
 367                                                                            TreeCCParam *params, int flags,
 368                                                                            int numTriggers, char *filename,
 369                                                                            long linenum);
 370
 371 /*
 372  * Find an operation with a specific name.
 373  */
 374 TreeCCOperation *TreeCCOperationFind(TreeCCContext *context, char *name);
 375
 376 /*
 377  * Add a case definition to an operation.
 378  */
 379 TreeCCOperationCase *TreeCCOperationAddCase
 380                                 (TreeCCContext *context, TreeCCOperation *oper,
 381                                  TreeCCTrigger *triggers, char *filename, long linenum);
 382
 383 /*
 384  * Validate all operations.
 385  */
 386 void TreeCCOperationValidate(TreeCCContext *context);
 387
 388 /*
 389  * Find the operation case that corresponds to a virtual method.
 390  * Returns NULL if the node does not have a virtual implementation.
 391  */
 392 TreeCCOperationCase *TreeCCOperationFindCase
 393                 (TreeCCContext *context, TreeCCNode *node, char *name);
 394
 395 /*
 396  * Visit all operations declared by a context.
 397  */
 398 typedef void (*TreeCCOperationVisitor)(TreeCCContext *context,
 399                                                                            TreeCCOperation *oper);
 400 void TreeCCOperationVisitAll(TreeCCContext *context,
 401                                                          TreeCCOperationVisitor visitor);
 402
 403 /*
 404  * Include the contents of a skeleton file in an output stream.
 405  */
 406 void TreeCCIncludeSkeleton(TreeCCContext *context, TreeCCStream *stream,
 407                                                    const char *skeleton);
 408
 409 #ifdef  __cplusplus
 410 };
 411 #endif
 412
 413 #endif  /* _TREECC_INFO_H */