/* * info.h - Store information about parsed "treecc" input files. * * Copyright (C) 2001 Southern Storm Software, Pty Ltd. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef _TREECC_INFO_H #define _TREECC_INFO_H #include "stream.h" #ifdef __cplusplus extern "C" { #endif /* * Forward declarations. */ typedef struct _tagTreeCCField TreeCCField; typedef struct _tagTreeCCNode TreeCCNode; typedef struct _tagTreeCCOperation TreeCCOperation; typedef struct _tagTreeCCParam TreeCCParam; typedef struct _tagTreeCCVirtual TreeCCVirtual; typedef struct _tagTreeCCTrigger TreeCCTrigger; typedef struct _tagTreeCCOperationCase TreeCCOperationCase; /* * Field definition flags. */ #define TREECC_FIELD_NOCREATE 1 /* * Node definition flags. */ #define TREECC_NODE_UNDEFINED 1 #define TREECC_NODE_ABSTRACT 2 #define TREECC_NODE_TYPEDEF 4 #define TREECC_NODE_ENUM 8 #define TREECC_NODE_ENUM_VALUE 16 #define TREECC_NODE_MARK(n) (0x100 << (n)) #define TREECC_NODE_MARK_BITS 0xFF00 /* * Operation flags. */ #define TREECC_OPER_VIRTUAL 1 #define TREECC_OPER_INLINE 2 #define TREECC_OPER_SPLIT 4 /* * Parameter flags. */ #define TREECC_PARAM_TRIGGER 1 /* * Language values. */ #define TREECC_LANG_C 0 #define TREECC_LANG_CPP 1 #define TREECC_LANG_JAVA 2 #define TREECC_LANG_CSHARP 3 #define TREECC_LANG_RUBY 4 #define TREECC_LANG_PHP 5 /* * Information that is stored about a field. */ struct _tagTreeCCField { char *name; /* Name of the field */ char *type; /* Type associated with the field */ char *value; /* Default value for the field */ int flags; /* Field flags */ char *filename; /* File that defines the field */ long linenum; /* Line where the field is defined */ TreeCCField *next; /* Next field for the node type */ }; /* * Information that is stored about a node type. */ struct _tagTreeCCNode { TreeCCNode *parent; /* Parent node type */ TreeCCNode *firstChild; /* First child node type */ TreeCCNode *lastChild; /* Last child node type */ TreeCCNode *nextSibling;/* Next sibling node type under parent */ char *name; /* Name of this node type */ int flags; /* Node flags */ int number; /* Number associated with this node type */ int position; /* Position within the tree for operations */ char *filename; /* File that defines the node type */ long linenum; /* Line where the node type is defined */ TreeCCField *fields; /* List of fields for this node type */ TreeCCVirtual *virtuals; /* List of virtual methods for this node */ TreeCCNode *nextHash; /* Next in the name hash table */ TreeCCStream *header; /* Stream to write header to */ TreeCCStream *source; /* Stream to write source to */ }; /* * Information that is stored about an operation. */ struct _tagTreeCCOperation { char *name; /* Name of the operation */ char *className; /* Name of the enclosing class */ char *returnType; /* Return type for the operation */ char *defValue; /* Default value for the operation */ TreeCCParam *params; /* Parameters for the operation */ int flags; /* Flags associated with the operation */ int numTriggers;/* Number of trigger parameters */ char *filename; /* File where the operation is declared */ long linenum; /* Line where the operation is declared */ TreeCCOperation *nextHash; /* Next in the operation hash table */ TreeCCOperationCase *firstCase; /* First case associated with operation */ TreeCCOperationCase *lastCase; /* Last case associated with operation */ TreeCCOperationCase **sortedCases; /* Cases sorted for non-virtual ops */ int numCases; /* Number of operation cases */ TreeCCStream *header; /* Stream to write header to */ TreeCCStream *source; /* Stream to write source to */ }; /* * Information that is stored about an operation parameter. */ struct _tagTreeCCParam { char *name; /* Name of the parameter */ char *type; /* Type for the parameter */ int flags; /* Flags associated with the parameter */ int size; /* Dimension size for non-virtual operations */ TreeCCParam *next; /* Next parameter for the operation */ }; /* * Information that is stored about a virtual method on a node type. */ struct _tagTreeCCVirtual { char *name; /* Name of the virtual method */ char *returnType; /* Return type for the virtual method */ TreeCCParam *params; /* Non-instance parameters */ TreeCCOperation *oper; /* Operation block for the virtual */ TreeCCVirtual *next; /* Next virtual method for the node type */ }; /* * Information that is stored about a trigger match on an operation case. */ struct _tagTreeCCTrigger { TreeCCNode *node; /* Node type for the trigger */ TreeCCTrigger *next; /* Next trigger for this case */ }; /* * Information that is stored about an operation case. */ struct _tagTreeCCOperationCase { TreeCCTrigger *triggers; /* Trigger list for this case */ char *code; /* Code associated with the case */ TreeCCOperation *oper; /* Operation this case is associated with */ int number; /* Reference number for code generation */ char *filename; /* File that starts the case definition */ long linenum; /* Line that starts the case definition */ char *codeFilename;/* File that starts the code */ long codeLinenum;/* Line that starts the code */ TreeCCOperationCase *next; /* Next case for the operation */ TreeCCOperationCase *nextHeader; /* Next header for same code block */ }; /* * Context object that stores all definitions parsed from the input. */ #define TREECC_HASH_SIZE 512 typedef struct _tagTreeCCContext { /* Hash table that allows quick lookup of node types */ TreeCCNode *nodeHash[TREECC_HASH_SIZE]; /* Hash table that allows quick lookup of operation names */ TreeCCOperation *operHash[TREECC_HASH_SIZE]; /* Current input stream */ TreeCCInput *input; /* Output streams */ TreeCCStream *streamList; /* List of all streams */ TreeCCStream *headerStream; /* Current header stream */ TreeCCStream *sourceStream; /* Current source stream */ TreeCCStream *commonHeader; /* Stream for common definitions */ TreeCCStream *commonSource; /* Stream for common source */ /* Flags that control the behaviour of the program */ int debugMode : 1; /* Enable debug output */ int track_lines : 1; /* Track node creation lines */ int no_singletons : 1; /* Don't handle singletons specially */ int reentrant : 1; /* Build a re-entrant system */ int force : 1; /* Force the creation of files */ int virtual_factory : 1;/* Allow overrides of factory methods */ int abstract_factory : 1;/* Declare factory methods abstract */ int kind_in_vtable : 1; /* Put kind value in vtable only */ int strip_filenames : 1; /* Strip names in #line directives */ int print_lines : 1; /* Dont emit #line directives */ int internal_access : 1; /* Use "internal" classes in C# */ int use_allocator : 1; /* Use the skeleton allocator */ int use_gc_allocator : 1; /* Use the libgc allocator */ /* String to use to replace "yy" in output files */ char *yy_replacement; /* Name of the type to use for re-entrant state */ char *state_type; /* Namespace to store declarations within */ char *namespace; /* Current node type number */ int nodeNumber; /* Output source language to use */ int language; /* Size of blocks to use in C/C++ memory alloction */ int block_size; /* Name of the directory to output Java source files to */ char *outputDirectory; /* name of the base type which is what %typedef expands to */ char *baseType; } TreeCCContext; /* * Create a context. */ TreeCCContext *TreeCCContextCreate(TreeCCInput *input); /* * Destroy a context. */ void TreeCCContextDestroy(TreeCCContext *context); /* * Hash a string. */ unsigned int TreeCCHashString(const char *str); /* * Flags for "TreeCCAddLiteralDefn". */ #define TREECC_LITERAL_CODE 1 /* In source */ #define TREECC_LITERAL_DECLS 2 /* In header */ #define TREECC_LITERAL_END 4 /* Place at end */ /* * Add a literal code definition block to the context. */ void TreeCCAddLiteralDefn(TreeCCContext *context, char *code, int flags); /* * Free a node definition. */ void TreeCCNodeFree(TreeCCNode *node); /* * Create a new node definition. */ TreeCCNode *TreeCCNodeCreate(TreeCCContext *context, long linenum, char *name, char *parent, int flags); /* * Find a node definition given its name. */ TreeCCNode *TreeCCNodeFind(TreeCCContext *context, const char *name); /* * Find a node definition given a type name, which may be * either "identifier" or "identifier *". */ TreeCCNode *TreeCCNodeFindByType(TreeCCContext *context, const char *name); /* * Validate the node type hierarchy to ensure that everything is defined. */ void TreeCCNodeValidate(TreeCCContext *context); /* * Visit every node type in a context's hierarchy. */ typedef void (*TreeCCNodeVisitor)(TreeCCContext *context, TreeCCNode *node); void TreeCCNodeVisitAll(TreeCCContext *context, TreeCCNodeVisitor visitor); /* * Determine if a node type is a singleton. i.e. no fields. */ int TreeCCNodeIsSingleton(TreeCCNode *node); /* * Determine if a node type has abstract virtual operation cases. */ int TreeCCNodeHasAbstracts(TreeCCContext *context, TreeCCNode *node); /* * Add a virtual operation to a node. */ void TreeCCNodeAddVirtual(TreeCCContext *context, TreeCCNode *node, TreeCCOperation *oper); /* * Determine if "nodea" inherits from "nodeb". */ int TreeCCNodeInheritsFrom(TreeCCNode *nodea, TreeCCNode *nodeb); /* * Clear all marking bits that are used to track operation coverage. */ void TreeCCNodeClearMarking(TreeCCContext *context, int flags); /* * Assign positions to all nodes started at a particular place * in the node type hierarchy. Returns the number of positions. */ int TreeCCNodeAssignPositions(TreeCCNode *node); /* * Create a new field definition and add it to a node. */ void TreeCCFieldCreate(TreeCCContext *context, TreeCCNode *node, char *name, char *type, char *value, int flags); /* * Free an operation. */ void TreeCCOperationFree(TreeCCOperation *oper); /* * Create a new operation. */ TreeCCOperation *TreeCCOperationCreate(TreeCCContext *context, char *returnType, char *name, char *className, char *defValue, TreeCCParam *params, int flags, int numTriggers, char *filename, long linenum); /* * Find an operation with a specific name. */ TreeCCOperation *TreeCCOperationFind(TreeCCContext *context, char *name); /* * Add a case definition to an operation. */ TreeCCOperationCase *TreeCCOperationAddCase (TreeCCContext *context, TreeCCOperation *oper, TreeCCTrigger *triggers, char *filename, long linenum); /* * Validate all operations. */ void TreeCCOperationValidate(TreeCCContext *context); /* * Find the operation case that corresponds to a virtual method. * Returns NULL if the node does not have a virtual implementation. */ TreeCCOperationCase *TreeCCOperationFindCase (TreeCCContext *context, TreeCCNode *node, char *name); /* * Visit all operations declared by a context. */ typedef void (*TreeCCOperationVisitor)(TreeCCContext *context, TreeCCOperation *oper); void TreeCCOperationVisitAll(TreeCCContext *context, TreeCCOperationVisitor visitor); /* * Include the contents of a skeleton file in an output stream. */ void TreeCCIncludeSkeleton(TreeCCContext *context, TreeCCStream *stream, const char *skeleton); #ifdef __cplusplus }; #endif #endif /* _TREECC_INFO_H */