/*
 * gen_java.c - Generate Java 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

/*
 * Convert enumerated types into "int", because Java
 * doesn't support enumerations.
 */
static const char *ConvertType(TreeCCContext *context, char *type)
{
	TreeCCNode *node = TreeCCNodeFind(context, type);
	if(node && (node->flags & TREECC_NODE_ENUM) != 0)
	{
		return "int";
	}
	else
	{
		return type;
	}
}

/*
 * 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, "\tpublic %s %s;\n",
						  ConvertType(context, field->type), field->name);
		field = field->next;
	}
}

/*
 * Declare the type definitions for a node type.
 */
static void DeclareTypeDefs(TreeCCContext *context,
						    TreeCCNode *node)
{
	if((node->flags & TREECC_NODE_ENUM) != 0)
	{
		/* Define an enumerated type */
		TreeCCStream *stream = TreeCCStreamGetJava(context, node->name);
		TreeCCNode *child;
		int num;
		TreeCCStreamPrint(stream, "public class %s\n", node->name);
		TreeCCStreamPrint(stream, "{\n");
		child = node->firstChild;
		num = 0;
		while(child != 0)
		{
			if((child->flags & TREECC_NODE_ENUM_VALUE) != 0)
			{
				TreeCCStreamPrint(stream,
						"\tpublic static final int %s = %d;\n",
						child->name, num);
				++num;
			}
			child = child->nextSibling;
		}
		TreeCCStreamPrint(stream, "}\n");
	}
}

/*
 * 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",
							  ConvertType(context, 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;
}

/*
 * 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;
	int declareCase, abstractCase;
	TreeCCNode *tempNode;
	int num, first;
	int needComma;
	if(node->parent)
	{
		ImplementVirtuals(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)
		{
			if(abstractCase)
			{
				TreeCCStreamPrint(stream, "\tpublic abstract %s %s(",
								  ConvertType(context, virt->returnType),
								  virt->name);
			}
			else
			{
				TreeCCStreamPrint(stream, "\tpublic %s %s(",
								  ConvertType(context, virt->returnType),
								  virt->name);
			}
			param = virt->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",
										  ConvertType(context, param->type),
										  param->name);
					}
					else
					{
						TreeCCStreamPrint(stream, "%s P%d__",
										  ConvertType(context, param->type),
										  num);
						++num;
					}
					needComma = 1;
				}
				param = param->next;
			}
			if(!abstractCase)
			{
				TreeCCStreamPrint(stream, ")\n");
				TreeCCStreamPrint(stream, "\t{\n");
				if(!(virt->oper->params->name) ||
				   !strcmp(virt->oper->params->name, "this"))
				{
					/* The first parameter is called "this", so we don't
					   need to declare it at the head of the function */
					TreeCCStreamCodeIndent(stream, operCase->code, 1);
				}
				else
				{
					/* The first parameter is called something else,
					   so create a temporary variable to hold "this" */
				   	TreeCCStreamPrint(stream, "\t\t%s %s = this;\n",
									  actualNode->name,
									  virt->oper->params->name);
					TreeCCStreamCodeIndent(stream, operCase->code, 1);
				}
				TreeCCStreamPrint(stream, "}\n\n");
			}
			else
			{
				TreeCCStreamPrint(stream, ");\n\n");
			}
		}
		virt = virt->next;
	}
}

/*
 * Build the type declarations for a node type.
 */
static void BuildTypeDecls(TreeCCContext *context,
						   TreeCCNode *node)
{
	TreeCCStream *stream;
	int needComma;
	const char *constructorAccess;
	TreeCCField *field;
	int isAbstract;

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

	/* Determine if this class has abstract virtuals */
	isAbstract = TreeCCNodeHasAbstracts(context, node);

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

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

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

		/* Declare the public methods for access to the above fields */
		TreeCCStreamPrint(stream,
				"\tpublic int getKind() { return kind__; }\n");
		if(context->track_lines)
		{
			TreeCCStreamPrint(stream,
				"\tpublic String getFilename() { return filename__; }\n");
			TreeCCStreamPrint(stream,
				"\tpublic long getLinenum() { return linenum__; }\n");
			TreeCCStreamPrint(stream,
			 	"\tpublic void setFilename(String filename) "
					"{ filename__ = filename; }\n");
			TreeCCStreamPrint(stream,
				"\tpublic void setLinenum(long linenum) "
					"{ linenum__ = linenum; }\n");
		}
		TreeCCStreamPrint(stream, "\n");
	}

	/* Declare the kind value */
	TreeCCStreamPrint(stream, "\tpublic static final int KIND = %d;\n\n",
					  node->number);

	/* Declare the fields */
	if(node->fields)
	{
		DeclareFields(context, stream, node);
		TreeCCStreamPrint(stream, "\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)
		{
			/* Subclasses need to be able to construct the node */
			constructorAccess = "public ";
		}
		else
		{
			/* Only the state type needs to be able to construct the node */
			constructorAccess = "";
		}
	}
	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)
		{
			constructorAccess = "protected ";
		}
		else
		{
			constructorAccess = "public ";
		}
	}
	TreeCCStreamPrint(stream, "\t%s%s(", constructorAccess, 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");
	TreeCCStreamPrint(stream, "\t{\n");

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

	/* Set the node kind */
	TreeCCStreamPrint(stream, "\t\tthis.kind__ = KIND;\n");

	/* Track the filename and line number if necessary */
	if(context->track_lines && !(node->parent))
	{
		if(context->reentrant)
		{
			TreeCCStreamPrint(stream,
					"\t\tthis.filename__ = state__.currFilename();\n");
			TreeCCStreamPrint(stream,
					"\t\tthis.linenum__ = state__.currLinenum();\n");
		}
		else
		{
			TreeCCStreamPrint(stream,
					"\t\tthis.filename__ = %s.getState().currFilename();\n",
					context->state_type);
			TreeCCStreamPrint(stream,
					"\t\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, "\t\tthis.%s = %s;\n",
							  field->name, field->name);
		}
		else if(field->value)
		{
			TreeCCStreamPrint(stream, "\t\tthis.%s = %s;\n",
							  field->name, field->value);
		}
		field = field->next;
	}
	TreeCCStreamPrint(stream, "\t}\n\n");

	/* Implement the virtual functions */
	ImplementVirtuals(context, stream, node, node);

	/* Declare the "isA" and "getKindName" helper methods */
	TreeCCStreamPrint(stream, "\tpublic int isA(int kind)\n");
	TreeCCStreamPrint(stream, "\t{\n");
	TreeCCStreamPrint(stream, "\t\tif(kind == KIND)\n");
	TreeCCStreamPrint(stream, "\t\t\treturn 1;\n");
	TreeCCStreamPrint(stream, "\t\telse\n");
	if(node->parent)
	{
		TreeCCStreamPrint(stream, "\t\t\treturn super.isA(kind);\n");
	}
	else
	{
		TreeCCStreamPrint(stream, "\t\t\treturn 0;\n");
	}
	TreeCCStreamPrint(stream, "\t}\n\n");
	TreeCCStreamPrint(stream, "\tpublic String getKindName()\n");
	TreeCCStreamPrint(stream, "\t{\n");
	TreeCCStreamPrint(stream, "\t\treturn \"%s\";\n", node->name);
	TreeCCStreamPrint(stream, "\t}\n");

	/* Output the class footer */
	TreeCCStreamPrint(stream, "}\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",
							  ConvertType(context, field->type),
							  field->name);
			needComma = 1;
		}
		field = field->next;
	}
	return needComma;
}

/*
 * 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 */
	stream = TreeCCStreamGetJava(context, context->state_type);

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

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

	/* Output the body of the creation function */
	if(context->abstract_factory)
	{
		TreeCCStreamPrint(stream, ");\n");
	}
	else
	{
		TreeCCStreamPrint(stream, ")\n");
		TreeCCStreamPrint(stream, "\t{\n");
		TreeCCStreamPrint(stream, "\t\treturn new %s(this", node->name);
		FactoryInvokeParams(context, stream, node, 1);
		TreeCCStreamPrint(stream, ");\n");
		TreeCCStreamPrint(stream, "\t}\n\n");
	}
}

/*
 * Implement the state type in the source stream.
 */
static void ImplementStateType(TreeCCContext *context, TreeCCStream *stream)
{
	/* Declare the class header */
	if(context->reentrant && context->abstract_factory)
	{
		TreeCCStreamPrint(stream, "public abstract class %s\n{\n\n",
						  context->state_type);
	}
	else
	{
		TreeCCStreamPrint(stream, "public class %s\n{\n\n",
						  context->state_type);
	}

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

	/* Implement the constructor */
	if(context->reentrant)
	{
		TreeCCStreamPrint(stream, "\tpublic %s() {}\n\n", context->state_type);
	}
	else
	{
		TreeCCStreamPrint(stream, "\tpublic %s() { state__ = this; }\n\n",
						  context->state_type);
	}

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

	/* Implement the line number tracking methods */
	if(context->track_lines)
	{
		TreeCCStreamPrint(stream,
			"\tpublic String currFilename() { return null; }\n");
		TreeCCStreamPrint(stream,
			"\tpublic long currLinenum() { return 0; }\n\n");
	}

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

/*
 * Determine if a type name corresponds to an enumerated type.
 */
static int IsEnumType(TreeCCContext *context, const char *type)
{
	TreeCCNode *node = TreeCCNodeFindByType(context, type);
	if(node)
	{
		if((node->flags & TREECC_NODE_ENUM) != 0)
		{
			return 1;
		}
	}
	return 0;
}

/*
 * Generate the start declarations for a non-virtual operation.
 */
static void Java_GenStart(TreeCCContext *context, TreeCCStream *stream,
					      TreeCCOperation *oper)
{
	const char *accessMode;
	if(context->internal_access && context->language == TREECC_LANG_CSHARP)
	{
		accessMode = "internal";
	}
	else
	{
		accessMode = "public";
	}
	if(oper->className)
	{
		TreeCCStreamPrint(stream, "%s class %s\n{\n",
						  accessMode, oper->className);
	}
	else
	{
		TreeCCStreamPrint(stream, "%s class %s\n{\n",
						  accessMode, oper->name);
	}
}

/*
 * Generate the entry point for a non-virtual operation.
 */
static void JavaGenEntry(TreeCCContext *context, TreeCCStream *stream,
					     TreeCCOperation *oper, int number)
{
	TreeCCParam *param;
	int num;
	int needComma;
	if(number != -1)
	{
		TreeCCStreamPrint(stream, "\tprivate static %s %s_split_%d__(",
						  oper->returnType, oper->name, number);
	}
	else
	{
		TreeCCStreamPrint(stream, "\tpublic static %s %s(",
						  oper->returnType, oper->name);
	}
	param = oper->params;
	num = 1;
	needComma = 0;
	while(param != 0)
	{
		if(needComma)
		{
			TreeCCStreamPrint(stream, ", ");
		}
		if(context->language == TREECC_LANG_CSHARP)
		{
			TreeCCStreamPrint(stream, "%s ", param->type);
		}
		else
		{
			TreeCCStreamPrint(stream, "%s ", ConvertType(context, param->type));
		}
		if(param->name)
		{
			TreeCCStreamPrint(stream, "%s", param->name);
		}
		else
		{
			TreeCCStreamPrint(stream, "P%d__", num);
			++num;
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if(!IsEnumType(context, param->type))
			{
				TreeCCStreamPrint(stream, "__");
			}
		}
		needComma = 1;
		param = param->next;
	}
	TreeCCStreamPrint(stream, ")\n");
	TreeCCStreamPrint(stream, "\t{\n");
}

/*
 * Generate the entry point for a non-virtual operation.
 */
static void Java_GenEntry(TreeCCContext *context, TreeCCStream *stream,
					      TreeCCOperation *oper)
{
	JavaGenEntry(context, stream, oper, -1);
}

/*
 * Generate the entry point for a split-out function.
 */
static void Java_GenSplitEntry(TreeCCContext *context, TreeCCStream *stream,
					           TreeCCOperation *oper, int number)
{
	JavaGenEntry(context, stream, oper, number);
}

/*
 * Output TAB's for a specific level of indenting.
 */
static void Indent(TreeCCStream *stream, int indent)
{
	while(indent >= 4)
	{
		TreeCCStreamPrint(stream, "\t\t\t\t");
		indent -= 4;
	}
	if(indent == 1)
	{
		TreeCCStreamPrint(stream, "\t");
	}
	else if(indent == 2)
	{
		TreeCCStreamPrint(stream, "\t\t");
	}
	else if(indent == 3)
	{
		TreeCCStreamPrint(stream, "\t\t\t");
	}
}

/*
 * Generate the head of a "switch" statement.
 */
static void Java_GenSwitchHead(TreeCCContext *context, TreeCCStream *stream,
							   char *paramName, int level, int isEnum)
{
	Indent(stream, level * 2 + 2);
	if(isEnum)
	{
		TreeCCStreamPrint(stream, "switch(%s)\n", paramName);
	}
	else
	{
		TreeCCStreamPrint(stream, "switch(%s__.getKind())\n", paramName);
	}
	Indent(stream, level * 2 + 2);
	TreeCCStreamPrint(stream, "{\n");
}

/*
 * Generate a selector for a "switch" case.
 */
static void Java_GenSelector(TreeCCContext *context, TreeCCStream *stream,
						     TreeCCNode *node, int level)
{
	if((node->flags & TREECC_NODE_ENUM_VALUE) != 0)
	{
		Indent(stream, level * 2 + 3);
		TreeCCStreamPrint(stream, "case %s.%s:\n",
						  node->parent->name, node->name);
	}
	else if((node->flags & TREECC_NODE_ENUM) == 0)
	{
		Indent(stream, level * 2 + 3);
		TreeCCStreamPrint(stream, "case %s.KIND:\n", node->name);
	}
}

/*
 * Terminate the selectors and begin the body of a "switch" case.
 */
static void Java_GenEndSelectors(TreeCCContext *context, TreeCCStream *stream,
							     int level)
{
	Indent(stream, level * 2 + 3);
	TreeCCStreamPrint(stream, "{\n");
}

/*
 * Generate the code for a case within a function.
 */
static void Java_GenCaseFunc(TreeCCContext *context, TreeCCStream *stream,
						     TreeCCOperationCase *operCase, int number)
{
	TreeCCParam *param;
	TreeCCTrigger *trigger;
	int num;
	int needComma;
	char *type;

	/* Output the header for the function */
	TreeCCStreamPrint(stream, "\tprivate static %s %s_%d__(",
					  ConvertType(context, operCase->oper->returnType),
					  operCase->oper->name, number);
	param = operCase->oper->params;
	trigger = operCase->triggers;
	num = 1;
	needComma = 0;
	while(param != 0)
	{
		if(needComma)
		{
			TreeCCStreamPrint(stream, ", ");
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
		   	if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
		   	   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
			{
				type = trigger->node->name;
			}
			else
			{
				type = param->type;
			}
			trigger = trigger->next;
		}
		else
		{
			type = param->type;
		}
		if(param->name)
		{
			if(context->language == TREECC_LANG_CSHARP)
			{
				TreeCCStreamPrint(stream, "%s %s", type, param->name);
			}
			else
			{
				TreeCCStreamPrint(stream, "%s %s",
								  ConvertType(context, type), param->name);
			}
		}
		else
		{
			if(context->language == TREECC_LANG_CSHARP)
			{
				TreeCCStreamPrint(stream, "%s P%d__", type, num);
			}
			else
			{
				TreeCCStreamPrint(stream, "%s P%d__",
								  ConvertType(context, type), num);
			}
			++num;
		}
		needComma = 1;
		param = param->next;
	}
	TreeCCStreamPrint(stream, ")\n");

	/* Output the code for the operation case */
	if(context->language == TREECC_LANG_CSHARP)
	{
		TreeCCStreamLine(stream, operCase->codeLinenum, operCase->codeFilename);
	}
	TreeCCStreamPrint(stream, "\t{");
	if(operCase->code)
	{
		TreeCCStreamCodeIndent(stream, operCase->code, 1);
	}
	TreeCCStreamPrint(stream, "}\n");
	if(context->language == TREECC_LANG_CSHARP)
	{
		TreeCCStreamFixLine(stream);
	}
	TreeCCStreamPrint(stream, "\n");
}

/*
 * Generate a call to a case function from within the "switch".
 */
static void Java_GenCaseCall(TreeCCContext *context, TreeCCStream *stream,
						     TreeCCOperationCase *operCase, int number,
						     int level)
{
	TreeCCParam *param;
	TreeCCTrigger *trigger;
	int num;
	int needComma;

	/* Indent to the correct level */
	Indent(stream, level * 2 + 4);

	/* Add "return" to the front if the operation is non-void */
	if(strcmp(operCase->oper->returnType, "void") != 0)
	{
		TreeCCStreamPrint(stream, "return ");
	}

	/* Print out the call */
	TreeCCStreamPrint(stream, "%s_%d__(", operCase->oper->name, number);
	param = operCase->oper->params;
	trigger = operCase->triggers;
	num = 1;
	needComma = 0;
	while(param != 0)
	{
		if(needComma)
		{
			TreeCCStreamPrint(stream, ", ");
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
		   	   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
			{
				TreeCCStreamPrint(stream, "(%s)", trigger->node->name);
			}
		}
		if(param->name)
		{
			TreeCCStreamPrint(stream, "%s", param->name);
		}
		else
		{
			TreeCCStreamPrint(stream, "P%d__", num);
			++num;
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
		   	   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
			{
				TreeCCStreamPrint(stream, "__");
			}
			trigger = trigger->next;
		}
		needComma = 1;
		param = param->next;
	}
	TreeCCStreamPrint(stream, ");\n");
}

/*
 * Generate the code for a case inline within the "switch".
 */
static void Java_GenCaseInline(TreeCCContext *context, TreeCCStream *stream,
						       TreeCCOperationCase *operCase, int level)
{
	TreeCCParam *param;
	TreeCCTrigger *trigger;

	/* Copy the parameters to new variables of the correct types */
	param = operCase->oper->params;
	trigger = operCase->triggers;
	while(param != 0)
	{
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if(param->name != 0)
			{
				if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
				   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
				{
					Indent(stream, level * 2 + 4);
					TreeCCStreamPrint(stream, "%s %s = (%s)%s__;\n",
									  trigger->node->name, param->name,
									  trigger->node->name, param->name);
				}
			}
			trigger = trigger->next;
		}
		param = param->next;
	}

	/* Output the inline code for the case */
	if(context->language == TREECC_LANG_CSHARP)
	{
		TreeCCStreamLine(stream, operCase->codeLinenum, operCase->codeFilename);
	}
	Indent(stream, level * 2 + 4);
	TreeCCStreamPrint(stream, "{");
	if(operCase->code)
	{
		TreeCCStreamCodeIndent(stream, operCase->code, level * 2 + 4);
	}
	TreeCCStreamPrint(stream, "}\n");
	if(context->language == TREECC_LANG_CSHARP)
	{
		TreeCCStreamFixLine(stream);
	}
}

/*
 * Generate a call to a split function from within the "switch".
 */
static void Java_GenCaseSplit(TreeCCContext *context, TreeCCStream *stream,
						      TreeCCOperationCase *operCase,
							  int number, int level)
{
	TreeCCParam *param;
	TreeCCTrigger *trigger;
	int num;
	int needComma;

	/* Indent to the correct level */
	Indent(stream, level * 2 + 4);

	/* Add "return" to the front if the operation is non-void */
	if(strcmp(operCase->oper->returnType, "void") != 0)
	{
		TreeCCStreamPrint(stream, "return ");
	}

	/* Print out the call */
	TreeCCStreamPrint(stream, "%s_split_%d__(", operCase->oper->name, number);
	param = operCase->oper->params;
	trigger = operCase->triggers;
	num = 1;
	needComma = 0;
	while(param != 0)
	{
		if(needComma)
		{
			TreeCCStreamPrint(stream, ", ");
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
		   	   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
			{
				TreeCCStreamPrint(stream, "(%s)", trigger->node->name);
			}
		}
		if(param->name)
		{
			TreeCCStreamPrint(stream, "%s", param->name);
		}
		else
		{
			TreeCCStreamPrint(stream, "P%d__", num);
			++num;
		}
		if((param->flags & TREECC_PARAM_TRIGGER) != 0)
		{
			if((trigger->node->flags & TREECC_NODE_ENUM) == 0 &&
		   	   (trigger->node->flags & TREECC_NODE_ENUM_VALUE) == 0)
			{
				TreeCCStreamPrint(stream, "__");
			}
			trigger = trigger->next;
		}
		needComma = 1;
		param = param->next;
	}
	TreeCCStreamPrint(stream, ");\n");
}

/*
 * Terminate a "switch" case.
 */
static void Java_GenEndCase(TreeCCContext *context, TreeCCStream *stream,
						    int level)
{
	Indent(stream, level * 2 + 3);
	TreeCCStreamPrint(stream, "}\n");
	Indent(stream, level * 2 + 3);
	TreeCCStreamPrint(stream, "break;\n\n");
}

/*
 * Terminate the "switch" statement.
 */
static void Java_GenEndSwitch(TreeCCContext *context, TreeCCStream *stream,
						      int level)
{
	Indent(stream, level * 2 + 3);
	TreeCCStreamPrint(stream, "default: break;\n");
	Indent(stream, level * 2 + 2);
	TreeCCStreamPrint(stream, "}\n");
}

/*
 * Generate the exit point for a non-virtual operation.
 */
static void Java_GenExit(TreeCCContext *context, TreeCCStream *stream,
					     TreeCCOperation *oper)
{
	if(strcmp(oper->returnType, "void") != 0)
	{
		/* Generate a default return value for the function */
		if(oper->defValue)
		{
			TreeCCStreamPrint(stream, "\treturn (%s);\n", oper->defValue);
		}
		else
		{
			TreeCCStreamPrint(stream, "\treturn 0;\n");
		}
	}
	TreeCCStreamPrint(stream, "\t}\n");
}

/*
 * Generate the end declarations for a non-virtual operation.
 */
static void Java_GenEnd(TreeCCContext *context, TreeCCStream *stream,
					    TreeCCOperation *oper)
{
	TreeCCStreamPrint(stream, "}\n");
	if(context->language == TREECC_LANG_CSHARP)
	{
		TreeCCStreamPrint(stream, "\n");
	}
}

/*
 * Table of non-virtual code generation functions.
 */
TreeCCNonVirtual const TreeCCNonVirtualFuncsJava = {
	Java_GenStart,
	Java_GenEntry,
	Java_GenSplitEntry,
	Java_GenSwitchHead,
	Java_GenSelector,
	Java_GenEndSelectors,
	Java_GenCaseFunc,
	Java_GenCaseCall,
	Java_GenCaseInline,
	Java_GenCaseSplit,
	Java_GenEndCase,
	Java_GenEndSwitch,
	Java_GenExit,
	Java_GenEnd,
};

/*
 * Write out header information for all streams.
 */
static void WriteJavaHeaders(TreeCCContext *context)
{
	TreeCCStream *stream = context->streamList;
	while(stream != 0)
	{
		if(!(stream->isHeader))
		{
			TreeCCStreamSourceTop(stream);
			TreeCCStreamPrint(stream, "\n");
			if(context->namespace)
			{
				TreeCCStreamPrint(stream, "package %s;\n\n",
								  context->namespace);
			}
			TreeCCStreamPrint(stream, "import java.lang.*;\n\n");
		}
		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 WriteJavaFooters(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(!(stream->isHeader))
		{
			TreeCCStreamSourceBottom(stream);
		}
		stream = stream->nextStream;
	}
}

/*
 * Create streams for all of the node types.
 */
static void CreateNodeStreams(TreeCCContext *context, TreeCCNode *node)
{
	if((node->flags & TREECC_NODE_ENUM_VALUE) == 0)
	{
		TreeCCStreamGetJava(context, node->name);
	}
}

/*
 * Create streams for all of the non-virtual operations
 */
static void CreateNonVirtualStreams(TreeCCContext *context,
						  	   	    TreeCCOperation *oper)
{
	if((oper->flags & TREECC_OPER_VIRTUAL) == 0)
	{
		if(oper->className)
		{
			TreeCCStreamGetJava(context, oper->className);
		}
		else
		{
			TreeCCStreamGetJava(context, oper->name);
		}
	}
}

void TreeCCGenerateJava(TreeCCContext *context)
{
	/* Create all streams that we will require later */
	TreeCCStreamGetJava(context, context->state_type);
	TreeCCNodeVisitAll(context, CreateNodeStreams);
	TreeCCOperationVisitAll(context, CreateNonVirtualStreams);

	/* Write all stream headers */
	WriteJavaHeaders(context);

	/* Generate the contents of the source stream */
	TreeCCNodeVisitAll(context, DeclareTypeDefs);
	ImplementStateType(context,
					   TreeCCStreamGetJava(context, context->state_type));
	TreeCCNodeVisitAll(context, BuildTypeDecls);
	TreeCCGenerateNonVirtuals(context, &TreeCCNonVirtualFuncsJava);

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

#ifdef	__cplusplus
};
#endif