/*
 * 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 */