/*
 * gen_cpp.c - Generate C++ source code from "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
 */

#include "system.h"
#include "input.h"
#include "info.h"
#include "gen.h"

#ifdef	__cplusplus
extern	"C" {
#endif

/*
 * Define the node numbers.
 */
static void DefineNodeNumbers(TreeCCContext *context,
							  TreeCCNode *node)
{
	TreeCCStream *stream = node->header;
	if((node->flags & (TREECC_NODE_ENUM | TREECC_NODE_ENUM_VALUE)) == 0)
	{
		TreeCCStreamPrint(stream, "const int %s_kind = %d;\n",
						  node->name, node->number);
	}
}

/*
 * Declare the fields for a node type.
 */
static void DeclareFields(TreeCCContext *context,
						  TreeCCStream *stream, TreeCCNode *node)
{
	TreeCCField *field;
	field = node->fields;
	while(field != 0)
	{
		TreeCCStreamPrint(stream, "\t%s %s;\n", field->type, field->name);
		field = field->next;
	}
}

/*
 * Declare the virtuals for a node type.
 */
static void DeclareVirtuals(TreeCCContext *context, TreeCCStream *stream,
							TreeCCNode *node, TreeCCNode *actualNode)
{
	TreeCCVirtual *virt;
	TreeCCParam *param;
	int num, needComma;
	TreeCCOperationCase *operCase;
	int declareCase, abstractCase;
	TreeCCNode *tempNode;
	if(node->parent)
	{
		DeclareVirtuals(context, stream, node->parent, actualNode);
	}
	virt = node->virtuals;
	while(virt != 0)
	{
		/* Determine if we need a definition for this virtual,
		   and whether the definition is real or abstract */
		operCase = TreeCCOperationFindCase(context, actualNode, virt->name);
		if(!operCase)
		{
			tempNode = actualNode->parent;
			abstractCase = 1;
			while(tempNode != 0)
			{
				operCase = TreeCCOperationFindCase
								(context, tempNode, virt->name);
				if(operCase != 0)
				{
					abstractCase = 0;
					break;
				}
				tempNode = tempNode->parent;
			}
			declareCase = abstractCase;
		}
		else
		{
			declareCase = 1;
			abstractCase = 0;
		}
		if(declareCase)
		{
			TreeCCStreamPrint(stream, "\tvirtual %s %s(",
							  virt->returnType, virt->name);
			param = virt->params;
			num = 1;
			needComma = 0;
			while(param != 0)
			{
				if(needComma)
				{
					TreeCCStreamPrint(stream, ", ");
				}
				else
				{
					needComma = 1;
				}
				if(param->name)
				{
					TreeCCStreamPrint(stream, "%s %s",
									  param->type, param->name);
				}
				else
				{
					TreeCCStreamPrint(stream, "%s P%d__",
									  param->type, num);
					++num;
				}
				param = param->next;
			}
			if(abstractCase)
			{
				TreeCCStreamPrint(stream, ") = 0;\n");
			}
			else
			{
				TreeCCStreamPrint(stream, ");\n");
			}
		}
		virt = virt->next;
	}
}

/*
 * Declare the type definitions for a node type.
 */
static void DeclareTypeDefs(TreeCCContext *context,
						    TreeCCNode *node)
{
	TreeCCStream *stream = node->header;
	if((node->flags & TREECC_NODE_ENUM) != 0)
	{
		/* Define an enumerated type */
		TreeCCNode *child;
		TreeCCStreamPrint(stream, "typedef enum {\n");
		child = node->firstChild;
		while(child != 0)
		{
			if((child->flags & TREECC_NODE_ENUM_VALUE) != 0)
			{
				TreeCCStreamPrint(stream, "\t%s,\n", child->name);
			}
			child = child->nextSibling;
		}
		TreeCCStreamPrint(stream, "} %s;\n\n", node->name);
	}
	else if((node->flags & TREECC_NODE_ENUM_VALUE) == 0)
	{
		/* Define a regular node type */
		TreeCCStreamPrint(stream, "class %s;\n", node->name);
	}
}

/*
 * Output the parameters for a node creation function.
 */
static int CreateParams(TreeCCContext *context, TreeCCStream *stream,
						TreeCCNode *node, int needComma)
{
	TreeCCField *field;
	if(node->parent)
	{
		needComma = CreateParams(context, stream, node->parent, needComma);
	}
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			TreeCCStreamPrint(stream, "%s %s", field->type, field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * Build the type declarations for a node type.
 */
static void BuildTypeDecls(TreeCCContext *context,
						   TreeCCNode *node)
{
	TreeCCStream *stream = node->header;
	int needComma;

	/* Ignore if this is an enumerated type node */
	if((node->flags & (TREECC_NODE_ENUM | TREECC_NODE_ENUM_VALUE)) != 0)
	{
		return;
	}

	/* Output the class header */
	if(node->parent)
	{
		/* Inherit from a specified parent type */
		TreeCCStreamPrint(stream, "class %s : public %s\n{\n",
						  node->name, node->parent->name);
	}
	else
	{
		/* This type is the base of a class hierarchy */
		if(context->baseType)
		{
			TreeCCStreamPrint(stream, "class %s : public %s\n{\n", node->name,context->baseType);
		}
		else
		{
			TreeCCStreamPrint(stream, "class %s\n{\n", node->name);
		}

		/* The following fields have protected access */
		TreeCCStreamPrint(stream, "protected:\n\n");

		/* Declare the node kind member variable */
		TreeCCStreamPrint(stream, "\tint kind__;\n");

		/* Declare the filename and linenum fields if we are tracking lines */
		if(context->track_lines)
		{
			TreeCCStreamPrint(stream, "\tchar *filename__;\n");
			TreeCCStreamPrint(stream, "\tlong linenum__;\n");
		}

		/* Declare the public methods for access to the above fields */
		TreeCCStreamPrint(stream, "\npublic:\n\n");
		TreeCCStreamPrint(stream, "\tint getKind() const { return kind__; }\n");
		if(context->track_lines)
		{
			TreeCCStreamPrint(stream,
				"\tconst char *getFilename() const { return filename__; }\n");
			TreeCCStreamPrint(stream,
				"\tlong getLinenum() const { return linenum__; }\n");
			TreeCCStreamPrint(stream,
			 "\tvoid setFilename(char *filename) { filename__ = filename; }\n");
			TreeCCStreamPrint(stream,
				"\tvoid setLinenum(long linenum) { linenum__ = linenum; }\n");
		}
		TreeCCStreamPrint(stream, "\n");

		/* Declare the overloaded "new" and "delete" operators */
		if(!(context->reentrant))
		{
			TreeCCStreamPrint(stream,
					"\tvoid *operator new(size_t);\n");
			TreeCCStreamPrint(stream,
					"\tvoid operator delete(void *, size_t);\n\n");
		}
	}

	/* Declare the constructor for the node type */
	if(context->reentrant)
	{
		/* Re-entrant systems use a factory to create the nodes */
		if(context->virtual_factory || context->abstract_factory)
		{
			TreeCCStreamPrint(stream, "public: // for virtual factory\n\n");
		}
		else
		{
			TreeCCStreamPrint(stream, "protected:\n\n");
			TreeCCStreamPrint(stream, "\tfriend class %s;\n\n",
							  context->state_type);
		}
	}
	else
	{
		/* Non-reentrant systems can construct nodes directly,
		   unless the node happens to be abstract, in which
		   case we force the constructor to be protected */
		if((node->flags & TREECC_NODE_ABSTRACT) != 0)
		{
			TreeCCStreamPrint(stream, "protected:\n\n");
		}
		else
		{
			TreeCCStreamPrint(stream, "public:\n\n");
		}
	}
	TreeCCStreamPrint(stream, "\t%s(", node->name);
	if(context->reentrant)
	{
		TreeCCStreamPrint(stream, "%s *state__", context->state_type);
		needComma = 1;
	}
	else
	{
		needComma = 0;
	}
	CreateParams(context, stream, node, needComma);
	TreeCCStreamPrint(stream, ");\n\n");

	/* Declare the fields */
	TreeCCStreamPrint(stream, "public:\n\n");
	if(node->fields)
	{
		DeclareFields(context, stream, node);
		TreeCCStreamPrint(stream, "\n");
	}

	/* Declare the virtual function prototypes */
	DeclareVirtuals(context, stream, node, node);
	TreeCCStreamPrint(stream, "\n");

	/* Declare the "isA" and "getKindName" helper methods */
	TreeCCStreamPrint(stream, "\tvirtual int isA(int kind) const;\n");
	TreeCCStreamPrint(stream, "\tvirtual const char *getKindName() const;\n\n");

	/* Declare the protected destructor for the node type.
	   The destructor is never called, but we need it to
	   keep C++ compilers from whinging about classes with
	   virtuals, but no virtual destructor */
	TreeCCStreamPrint(stream, "protected:\n\n");
	TreeCCStreamPrint(stream, "\tvirtual ~%s();\n\n", node->name);

	/* Output the class footer */
	TreeCCStreamPrint(stream, "};\n\n");
}

/*
 * Declare the prototypes for the non-virtual operations.
 */
static void DeclareNonVirtuals(TreeCCContext *context,
						  	   TreeCCOperation *oper)
{
	TreeCCStream *stream = oper->header;
	TreeCCParam *param;
	int num;
	int needComma;

	/* Bail out if the operation is virtual */
	if((oper->flags & TREECC_OPER_VIRTUAL) != 0)
	{
		return;
	}

	/* Output a class header if the operation is inside a class */
	if(oper->className)
	{
		TreeCCStreamPrint(stream, "class %s\n", oper->className);
		TreeCCStreamPrint(stream, "{\n");
		TreeCCStreamPrint(stream, "public:\n\n");
		TreeCCStreamPrint(stream, "\tstatic ");
	}

	/* Output the prototype */
	TreeCCStreamPrint(stream, "%s %s(", oper->returnType, oper->name);
	param = oper->params;
	num = 1;
	needComma = 0;
	while(param != 0)
	{
		if(needComma)
		{
			TreeCCStreamPrint(stream, ", ");
		}
		if(param->name)
		{
			TreeCCStreamPrint(stream, "%s %s", param->type, param->name);
		}
		else
		{
			TreeCCStreamPrint(stream, "%s P%d__", param->type, num);
			++num;
		}
		needComma = 1;
		param = param->next;
	}
	if(!needComma)
	{
		TreeCCStreamPrint(stream, "void");
	}
	TreeCCStreamPrint(stream, ");\n");

	/* Output a class footer if the operation is inside a class */
	if(oper->className)
	{
		TreeCCStreamPrint(stream, "};\n\n");
	}
}

/*
 * Output a constructor parameter list to the source stream.
 */
static int CreateParamsSource(TreeCCContext *context, TreeCCStream *stream,
							  TreeCCNode *node, int needComma)
{
	TreeCCField *field;
	if(node->parent)
	{
		needComma = CreateParamsSource(context, stream,
									   node->parent, needComma);
	}
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			TreeCCStreamPrint(stream, "%s %s", field->type, field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * Output the parameters to call an inherited constructor.
 */
static int InheritParamsSource(TreeCCContext *context, TreeCCStream *stream,
							   TreeCCNode *node, int needComma)
{
	TreeCCField *field;
	if(node->parent)
	{
		needComma = InheritParamsSource(context, stream,
									    node->parent, needComma);
	}
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			TreeCCStreamPrint(stream, "%s", field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * Output the constructor implementation for a node type.
 */
static void ImplementConstructor(TreeCCContext *context, TreeCCStream *stream,
								 TreeCCNode *node)
{
	int needComma;
	TreeCCField *field;

	/* Output the constructor function header */
	TreeCCStreamPrint(stream, "%s::%s(", node->name, node->name);
	if(context->reentrant)
	{
		TreeCCStreamPrint(stream, "%s *state__", context->state_type);
		needComma = 1;
	}
	else
	{
		needComma = 0;
	}
	CreateParamsSource(context, stream, node, needComma);
	TreeCCStreamPrint(stream, ")\n");

	/* Call the parent class constructor */
	if(node->parent)
	{
		TreeCCStreamPrint(stream, "\t: %s(", node->parent->name);
		if(context->reentrant)
		{
			TreeCCStreamPrint(stream, "state__");
			needComma = 1;
		}
		else
		{
			needComma = 0;
		}
		InheritParamsSource(context, stream, node->parent, needComma);
		TreeCCStreamPrint(stream, ")\n");
	}

	/* Output the beginning of the function body */
	TreeCCStreamPrint(stream, "{\n");

	/* Set the node kind */
	TreeCCStreamPrint(stream, "\tthis->kind__ = %s_kind;\n", node->name);

	/* Track the filename and line number if necessary */
	if(context->track_lines && !(node->parent))
	{
		if(context->reentrant)
		{
			TreeCCStreamPrint(stream,
					"\tthis->filename__ = state__->currFilename();\n");
			TreeCCStreamPrint(stream,
					"\tthis->linenum__ = state__->currLinenum();\n");
		}
		else
		{
			TreeCCStreamPrint(stream,
					"\tthis->filename__ = %s::getState()->currFilename();\n",
					context->state_type);
			TreeCCStreamPrint(stream,
					"\tthis->linenum__ = %s::getState()->currLinenum();\n",
					context->state_type);
		}
	}

	/* Initialize the fields that are specific to this node type */
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			TreeCCStreamPrint(stream, "\tthis->%s = %s;\n",
							  field->name, field->name);
		}
		else if(field->value)
		{
			TreeCCStreamPrint(stream, "\tthis->%s = %s;\n",
							  field->name, field->value);
		}
		field = field->next;
	}

	/* Output the constructor function footer */
	TreeCCStreamPrint(stream, "}\n\n");
}

/*
 * Implement the virtual methods that have implementations in a node type.
 */
static void ImplementVirtuals(TreeCCContext *context, TreeCCStream *stream,
							  TreeCCNode *node, TreeCCNode *actualNode)
{
	TreeCCVirtual *virt;
	TreeCCParam *param;
	TreeCCOperationCase *operCase;
	TreeCCOperation *oper;
	int num, first;
	int needComma;
	if(node->parent)
	{
		ImplementVirtuals(context, stream, node->parent, actualNode);
	}
	virt = node->virtuals;
	while(virt != 0)
	{
		operCase = TreeCCOperationFindCase(context, actualNode, virt->name);
		if(!operCase)
		{
			/* We don't have a direct implementation in this class */
			virt = virt->next;
			continue;
		}
		TreeCCStreamPrint(stream, "%s %s::%s(", virt->returnType,
						  actualNode->name, virt->name);
		oper = operCase->oper;
		param = oper->params;
		needComma = 0;
		num = 1;
		first = 1;
		while(param != 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			if(first)
			{
				/* Skip the first argument, which corresponds to "this" */
				if(!(param->name))
				{
					++num;
				}
				first = 0;
			}
			else
			{
				if(param->name)
				{
					TreeCCStreamPrint(stream, "%s %s",
									  param->type, param->name);
				}
				else
				{
					TreeCCStreamPrint(stream, "%s P%d__",
									  param->type, num);
					++num;
				}
				needComma = 1;
			}
			param = param->next;
		}
		TreeCCStreamPrint(stream, ")\n");
		if(!(oper->params->name) || !strcmp(oper->params->name, "this"))
		{
			/* The first parameter is called "this", so we don't
			   need to declare it at the head of the function */
			TreeCCStreamLine(stream, operCase->codeLinenum,
							 operCase->codeFilename);
			TreeCCStreamPrint(stream, "{");
			TreeCCStreamCode(stream, operCase->code);
			TreeCCStreamPrint(stream, "}\n");
			TreeCCStreamFixLine(stream);
		}
		else
		{
			/* The first parameter is called something else,
			   so create a temporary variable to hold "this" */
		   	TreeCCStreamPrint(stream, "{\n\t%s *%s = this;\n",
							  actualNode->name, oper->params->name);
			TreeCCStreamLine(stream, operCase->codeLinenum,
							 operCase->codeFilename);
			TreeCCStreamPrint(stream, "\t{");
			TreeCCStreamCodeIndent(stream, operCase->code, 1);
			TreeCCStreamPrint(stream, "}\n");
			TreeCCStreamFixLine(stream);
			TreeCCStreamPrint(stream, "}\n");
		}
		TreeCCStreamPrint(stream, "\n");
		virt = virt->next;
	}
}

/*
 * Implement a node type.
 */
static void ImplementNodeTypes(TreeCCContext *context, TreeCCNode *node)
{
	TreeCCStream *stream = node->source;

	/* Ignore if this is an enumerated type node */
	if((node->flags & (TREECC_NODE_ENUM | TREECC_NODE_ENUM_VALUE)) != 0)
	{
		return;
	}

	/* Implement the "new" and "delete" operators if this is a top-level node */
	if(!(node->parent) && !(context->reentrant))
	{
		TreeCCStreamPrint(stream, "void *%s::operator new(size_t size__)\n",
						  node->name);
		TreeCCStreamPrint(stream, "{\n");
		TreeCCStreamPrint(stream, "\treturn %s::getState()->alloc(size__);\n",
						  context->state_type);
		TreeCCStreamPrint(stream, "}\n\n");
		TreeCCStreamPrint(stream,
				"void %s::operator delete(void *ptr__, size_t size__)\n",
						  node->name);
		TreeCCStreamPrint(stream, "{\n");
		TreeCCStreamPrint(stream, "\t%s::getState()->dealloc(ptr__, size__);\n",
						  context->state_type);
		TreeCCStreamPrint(stream, "}\n\n");
	}

	/* Implement the constructor */
	ImplementConstructor(context, stream, node);

	/* Implement the destructor */
	TreeCCStreamPrint(stream, "%s::~%s()\n", node->name, node->name);
	TreeCCStreamPrint(stream, "{\n");
	TreeCCStreamPrint(stream, "\t// not used\n");
	TreeCCStreamPrint(stream, "}\n\n");

	/* Implement the virtual methods that reside in this node type */
	ImplementVirtuals(context, stream, node, node);

	/* Implement the "isA" helper method */
	TreeCCStreamPrint(stream, "int %s::isA(int kind) const\n", node->name);
	TreeCCStreamPrint(stream, "{\n");
	TreeCCStreamPrint(stream, "\tif(kind == %s_kind)\n", node->name);
	TreeCCStreamPrint(stream, "\t\treturn 1;\n");
	TreeCCStreamPrint(stream, "\telse\n");
	if(node->parent)
	{
		TreeCCStreamPrint(stream, "\t\treturn %s::isA(kind);\n",
						  node->parent->name);
	}
	else
	{
		TreeCCStreamPrint(stream, "\t\treturn 0;\n");
	}
	TreeCCStreamPrint(stream, "}\n\n");

	/* Implement the "getKindName" helper method */
	TreeCCStreamPrint(stream, "const char *%s::getKindName() const\n",
					  node->name);
	TreeCCStreamPrint(stream, "{\n");
	TreeCCStreamPrint(stream, "\treturn \"%s\";\n", node->name);
	TreeCCStreamPrint(stream, "}\n\n");
}

/*
 * Declare the parameters for a factory method in the state type.
 */
static int FactoryCreateParams(TreeCCContext *context, TreeCCStream *stream,
							   TreeCCNode *node, int needComma)
{
	TreeCCField *field;
	if(node->parent)
	{
		needComma = FactoryCreateParams(context, stream,
										node->parent, needComma);
	}
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			TreeCCStreamPrint(stream, "%s %s", field->type, field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * Declare the create function for a node type.
 */
static void DeclareCreateFuncs(TreeCCContext *context, TreeCCNode *node)
{
	TreeCCStream *stream;

	/* Ignore if this is an enumerated type node */
	if((node->flags & (TREECC_NODE_ENUM | TREECC_NODE_ENUM_VALUE)) != 0)
	{
		return;
	}

	/* Ignore this if it is an abstract node */
	if((node->flags & TREECC_NODE_ABSTRACT) != 0)
	{
		return;
	}

	/* Determine which stream to write to */
	if(context->commonHeader)
	{
		stream = context->commonHeader;
	}
	else
	{
		stream = context->headerStream;
	}

	/* Output the start of the function definition */
	if(context->virtual_factory || context->abstract_factory)
	{
		TreeCCStreamPrint(stream, "\tvirtual %s *%sCreate(",
						  node->name, node->name);
	}
	else
	{
		TreeCCStreamPrint(stream, "\t%s *%sCreate(",
						  node->name, node->name);
	}

	/* Output the parameters for the create function */
	FactoryCreateParams(context, stream, node, 0);

	/* Terminate the function definition */
	if(context->abstract_factory)
	{
		TreeCCStreamPrint(stream, ") = 0;\n");
	}
	else
	{
		TreeCCStreamPrint(stream, ");\n");
	}
}

/*
 * Declare the state type in the header stream.
 */
static void DeclareStateType(TreeCCContext *context, TreeCCStream *stream)
{
	/* Declare the class header */
	TreeCCStreamPrint(stream, "class %s\n{\n", context->state_type);

	/* Declare the constructor and destructor */
	TreeCCStreamPrint(stream, "public:\n\n");
	TreeCCStreamPrint(stream, "\t%s();\n", context->state_type);
	TreeCCStreamPrint(stream, "\tvirtual ~%s();\n\n", context->state_type);

	/* Include the header skeleton */
	if(context->use_gc_allocator)
	{
		TreeCCIncludeSkeleton(context, stream, "cpp_gc_skel.h");
	}
	else
	{
		TreeCCIncludeSkeleton(context, stream, "cpp_skel.h");
	}

	/* Singleton handling for non-reentrant systems */
	if(!(context->reentrant))
	{
		TreeCCStreamPrint(stream, "private:\n\n");
		TreeCCStreamPrint(stream, "\tstatic %s *state__;\n\n",
						  context->state_type);
		TreeCCStreamPrint(stream, "public:\n\n");
		TreeCCStreamPrint(stream, "\tstatic %s *getState()\n",
						  context->state_type);
		TreeCCStreamPrint(stream, "\t\t{\n");
		TreeCCStreamPrint(stream, "\t\t\tif(state__) return state__;\n");
		TreeCCStreamPrint(stream, "\t\t\tstate__ = new %s();\n",
						  context->state_type);
		TreeCCStreamPrint(stream, "\t\t\treturn state__;\n");
		TreeCCStreamPrint(stream, "\t\t}\n\n");
	}

	/* Declare the create functions for all of the node types */
	if(context->reentrant)
	{
		TreeCCStreamPrint(stream, "public:\n\n");
		TreeCCNodeVisitAll(context, DeclareCreateFuncs);
		TreeCCStreamPrint(stream, "\n");
	}

	/* Declare the node pool handling functions */
	TreeCCStreamPrint(stream, "public:\n\n");
	TreeCCStreamPrint(stream, "\tvoid *alloc(size_t);\n");
	TreeCCStreamPrint(stream, "\tvoid dealloc(void *, size_t);\n");
	TreeCCStreamPrint(stream, "\tint push();\n");
	TreeCCStreamPrint(stream, "\tvoid pop();\n");
	TreeCCStreamPrint(stream, "\tvoid clear();\n");

	/* Declare the "failed" method for out of memory error reporting */
	TreeCCStreamPrint(stream, "\tvirtual void failed();\n");

	/* Declare the line number tracking methods */
	if(context->track_lines)
	{
		TreeCCStreamPrint(stream, "\tvirtual char *currFilename();\n");
		TreeCCStreamPrint(stream, "\tvirtual long currLinenum();\n");
	}

	/* Declare the end of the state type */
	TreeCCStreamPrint(stream, "\n};\n\n");
}

/*
 * Output invocation parameters for a call to a constructor
 * from within a factory method.
 */
static int FactoryInvokeParams(TreeCCContext *context, TreeCCStream *stream,
							   TreeCCNode *node, int needComma)
{
	TreeCCField *field;
	if(node->parent)
	{
		needComma = FactoryInvokeParams(context, stream,
										node->parent, needComma);
	}
	field = node->fields;
	while(field != 0)
	{
		if((field->flags & TREECC_FIELD_NOCREATE) == 0)
		{
			if(needComma)
			{
				TreeCCStreamPrint(stream, ", ");
			}
			TreeCCStreamPrint(stream, "%s", field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * Implement the create function for a node type.
 */
static void ImplementCreateFuncs(TreeCCContext *context, TreeCCNode *node)
{
	TreeCCStream *stream;

	/* Ignore if this is an enumerated type node */
	if((node->flags & (TREECC_NODE_ENUM | TREECC_NODE_ENUM_VALUE)) != 0)
	{
		return;
	}

	/* Ignore this if it is an abstract node */
	if((node->flags & TREECC_NODE_ABSTRACT) != 0)
	{
		return;
	}

	/* Determine which stream to write to */
	if(context->commonSource)
	{
		stream = context->commonSource;
	}
	else
	{
		stream = context->sourceStream;
	}

	/* Output the start of the function definition */
	TreeCCStreamPrint(stream, "%s *%s::%sCreate(",
					  node->name, context->state_type, node->name);

	/* Output the parameters for the create function */
	FactoryCreateParams(context, stream, node, 0);
	TreeCCStreamPrint(stream, ")\n");

	/* Output the body of the creation function */
	TreeCCStreamPrint(stream, "{\n");
	TreeCCStreamPrint(stream, "\tvoid *buf__ = this->alloc(sizeof(%s));\n",
					  node->name);

	/* Bail out to the caller if "alloc" returned NULL */
	TreeCCStreamPrint(stream, "\tif(buf__ == 0) return 0;\n");

	/* Invoke the constructor and return the node to the caller */
	TreeCCStreamPrint(stream, "\treturn new (buf__) %s(this", node->name);
	FactoryInvokeParams(context, stream, node, 1);
	TreeCCStreamPrint(stream, ");\n");
	TreeCCStreamPrint(stream, "}\n\n");
}

/*
 * Implement the state type in the source stream.
 */
static void ImplementStateType(TreeCCContext *context, TreeCCStream *stream)
{
	/* Include the common definitions from the skeleton */
	if(context->block_size)
	{
		TreeCCStreamPrint(stream, "#define %s_BLKSIZ %d\n",
						  context->state_type, context->block_size);
	}
	if(context->reentrant)
	{
		TreeCCStreamPrint(stream, "#define %s_REENTRANT 1\n",
						  context->state_type);
	}
	if(context->track_lines)
	{
		TreeCCStreamPrint(stream, "#define %s_TRACK_LINES 1\n",
						  context->state_type);
	}
	if(context->use_allocator)
	{
		TreeCCStreamPrint(stream, "#define %s_USE_ALLOCATOR 1\n",
						  context->state_type);
	}
	if(context->use_gc_allocator)
	{
		TreeCCIncludeSkeleton(context, stream, "cpp_gc_skel.cc");
	}
	else
	{
		TreeCCIncludeSkeleton(context, stream, "cpp_skel.cc");
	}

	/* Implement the create functions for all of the node types */
	if(context->reentrant && !(context->abstract_factory))
	{
		TreeCCNodeVisitAll(context, ImplementCreateFuncs);
	}
}

/*
 * Write out header information for all streams.
 */
static void WriteCPPHeaders(TreeCCContext *context)
{
	TreeCCStream *stream = context->streamList;
	while(stream != 0)
	{
		if(stream->isHeader)
		{
			TreeCCStreamHeaderTop(stream);
			TreeCCStreamPrint(stream, "\n");
			TreeCCStreamPrint(stream, "#include <new>\n");
			TreeCCStreamPrint(stream, "\n");
		}
		else
		{
			TreeCCStreamSourceTop(stream);
			TreeCCStreamPrint(stream, "\n");
		}
		if(context->namespace)
		{
			TreeCCStreamPrint(stream, "namespace %s\n{\n\n",
					context->namespace);
		}
		if(stream->defaultFile)
		{
			/* Reset the dirty flag if this is a default stream,
			   because we don't want to write out the final file
			   if it isn't actually written to in practice */
			stream->dirty = 0;
		}
		stream = stream->nextStream;
	}
}

/*
 * Write out footer information for all streams.
 */
static void WriteCPPFooters(TreeCCContext *context)
{
	TreeCCStream *stream = context->streamList;
	while(stream != 0)
	{
		if(stream->defaultFile && !(stream->dirty))
		{
			/* Clear the default file's contents, which we don't need */
			TreeCCStreamClear(stream);
		}
		else
		{
			if(context->namespace)
			{
				TreeCCStreamPrint(stream, "}\n");
			}
			if(stream->isHeader)
			{
				TreeCCStreamHeaderBottom(stream);
			}
			else
			{
				TreeCCStreamSourceBottom(stream);
			}
		}
		stream = stream->nextStream;
	}
}

void TreeCCGenerateCPP(TreeCCContext *context)
{
	/* Write all stream headers */
	WriteCPPHeaders(context);

	/* Generate the contents of the header stream */
	TreeCCNodeVisitAll(context, DefineNodeNumbers);
	TreeCCStreamPrint(context->headerStream, "\n");
	TreeCCNodeVisitAll(context, DeclareTypeDefs);
	TreeCCStreamPrint(context->headerStream, "\n");
	if(context->commonHeader)
	{
		DeclareStateType(context, context->commonHeader);
	}
	else
	{
		DeclareStateType(context, context->headerStream);
	}
	TreeCCNodeVisitAll(context, BuildTypeDecls);
	TreeCCStreamPrint(context->headerStream, "\n");
	TreeCCOperationVisitAll(context, DeclareNonVirtuals);
	TreeCCStreamPrint(context->headerStream, "\n");

	/* Implement the state type */
	if(context->commonSource)
	{
		ImplementStateType(context, context->commonSource);
	}
	else
	{
		ImplementStateType(context, context->sourceStream);
	}

	/* Generate the contents of the source stream */
	TreeCCNodeVisitAll(context, ImplementNodeTypes);
	TreeCCGenerateNonVirtuals(context, &TreeCCNonVirtualFuncsC);

	/* Write all stream footers */
	WriteCPPFooters(context);
}

#ifdef	__cplusplus
};
#endif