/*******************************************************************************
 *	GenBoap.cc	Boap output
 *			T.Barnaby,	BEAM Ltd,	2/5/03
 *******************************************************************************
 */
#define	DEBUG	1

#define	DODATA		0

#include <stdio.h>
#include <stdarg.h>
#include <strings.h>
#include <GenBoap.h>
#include <bidl.h>

void GenBoap::produceIntC(Node* n){
	BIter		i;
	BString		s;
	BString		c;
	BList<Node*>*	nl;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileIntC.writeLine(BString("namespace ") + omodule + " {\n");
		ofileIntC.indentMore();

		ofileIntC.writeLine(BString("const BUInt32 apiVersion = ") + oapiVersion + ";\n\n");
		
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntC(n->nodes()[i]);
		}
		ofileIntC.indentLess();
		ofileIntC.writeLine("}\n");
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		// Client
		ofileIntC.writeLine(BString("class ") + ointerface + " : public BoapClientObject {\n");
		ofileIntC.writeLine("public:\n");
		ofileIntC.indentMore();
		ofileIntC.writeLine(BString("\t") + ointerface + "(BString name = \"\");\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntC(n->nodes()[i]);
		}
		ofileIntC.indentLess();
		ofileIntC.writeLine("private:\n");
		ofileIntC.writeLine("};\n");
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntC(n->nodes()[i]);
		}
		break;
#if DODATA
	case Node::TSTRUCT:
		if((n->nodes().number() == 2) && n->node(1)){
			ofileIntC.writeLine(BString("struct ") + n->name() + " : public " +  n->node(1)->name() + " {\n");
		}
		else {
			ofileIntC.writeLine(BString("struct ") + n->name() + " {\n");
		}
		ofileIntC.indentMore();

		nl = &n->node(0)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			s = getTypeName(nl->get(i)->node(0)) + "\t";
			s = s + nl->get(i)->node(1)->name();
			if(nl->get(i)->node(2) && nl->get(i)->node(2)->nodeType() == Node::TCOMMENT)
				c = BString("\t//") + nl->get(i)->node(2)->name();
			else
				c = "";
			ofileIntC.writeLine(s + c + ";\n");
		}

		ofileIntC.indentLess();
		ofileIntC.writeLine("};\n\n");
		break;
#endif
	case Node::TFUNC:
		s = s + getTypeName(n->node(0)) + " ";
		s = s + n->name() + "(";
		nl = &n->node(1)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			if(i != nl->begin())
				s = s + ", ";
			if(nl->get(i)->node(0)->name() == "in"){
				s = s + getTypeName(nl->get(i)->node(1)) + " ";
			}
			else if(nl->get(i)->node(0)->name() == "inref"){
					s = s + "const " + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			else {
				s = s + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			s = s + nl->get(i)->node(2)->name();
		}
		s = s + ");";
		if(n->node(2) && n->node(2)->nodeType() == Node::TCOMMENT)
			s = s + "\t//" + n->node(2)->name();
		ofileIntC.writeLine(s + "\n");
		break;
	case Node::TCOMMENT:
		s = BString("//") + n->name() + "\n";
		ofileIntC.writeLine(s);
		break;
	case Node::TAPIVERSION:
		oapiVersion = n->name().retInt();
		break;
	default:
		break;
	}
}

void GenBoap::produceIntS(Node* n){
	BIter		i;
	BString		s;
	BList<Node*>*	nl;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileIntS.writeLine(BString("namespace ") + omodule + " {\n");
		ofileIntS.indentMore();
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntS(n->nodes()[i]);
		}
		ofileIntS.indentLess();
		ofileIntS.writeLine("}\n");
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		// Server
		ofileIntS.writeLine(BString("class ") + ointerface + "Service : public BoapServiceObject {\n");
		ofileIntS.writeLine("public:\n");
		ofileIntS.indentMore();
		ofileIntS.writeLine(BString("\t") + ointerface + "Service(BoapServer& server, BString name);\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntS(n->nodes()[i]);
		}
		ofileIntS.indentLess();
		ofileIntS.writeLine("};\n");
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntS(n->nodes()[i]);
		}
		break;
	case Node::TSTRUCT:
		break;
	case Node::TFUNC:
		s = BString("BError do") + n->name() + "(BoapServerConnection* conn, BoapPacket& rx, BoapPacket& tx);\n";
		ofileIntS.writeLine(s);
		
		s = "virtual ";
		s = s + getTypeName(n->node(0)) + " ";
		s = s + n->name() + "(";
		nl = &n->node(1)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			if(i != nl->begin())
				s = s + ", ";
			if(nl->get(i)->node(0)->name() == "in"){
				s = s + getTypeName(nl->get(i)->node(1)) + " ";
			}
			else if(nl->get(i)->node(0)->name() == "inref"){
				s = s + "const " + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			else {
				s = s + getTypeName(nl->get(i)->node(1)) + "& ";
			}

			s = s + nl->get(i)->node(2)->name();
		}
		s = s + ") = 0;\n";
		ofileIntS.writeLine(s);
		break;
	default:
		break;
	}
}

void GenBoap::produceIntT(Node* n){
	BIter		i;
	BString		s;
	BList<Node*>*	nl;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileIntT.writeLine(BString("using namespace ") + omodule + ";\n\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntT(n->nodes()[i]);
		}
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		// Server
		ofileIntT.writeLine(BString("class ") + ointerface + "Server : public " + omodule + "::" + ointerface + "Service {\n");
		ofileIntT.writeLine("public:\n");
		ofileIntT.indentMore();
		ofileIntT.writeLine(BString("\t") + ointerface + "Server(BoapServer& server, BString name);\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntT(n->nodes()[i]);
		}
		ofileIntT.indentLess();
		ofileIntT.writeLine("};\n\n");
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceIntT(n->nodes()[i]);
		}
		break;
	case Node::TSTRUCT:
		break;
	case Node::TFUNC:
		s = "";
		s = s + getTypeName(n->node(0)) + " ";
		s = s + n->name() + "(";
		nl = &n->node(1)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			if(i != nl->begin())
				s = s + ", ";
			if(nl->get(i)->node(0)->name() == "in"){
				s = s + getTypeName(nl->get(i)->node(1)) + " ";
			}
			else if(nl->get(i)->node(0)->name() == "inref"){
				s = s + "const " + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			else {
				s = s + getTypeName(nl->get(i)->node(1)) + "& ";
			}

			s = s + nl->get(i)->node(2)->name();
		}
		s = s + ");\n";
		ofileIntT.writeLine(s);
		break;
	default:
		break;
	}
}

void GenBoap::produceImpT(Node* n){
	BString		s;
	BIter		i;
	BList<Node*>*	nl;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileImpT.writeLine(BString("using namespace ") + omodule + ";\n\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpT(n->nodes()[i]);
		}
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		ofileImpT.writeLine(ointerface + "Server::" + ointerface + "Server(BoapServer& server, BString name) : " + ointerface + "Service(server, name){\n");
		ofileImpT.writeLine("}\n\n");		
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpT(n->nodes()[i]);
		}
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpT(n->nodes()[i]);
		}
		break;
	case Node::TFUNC:
		s = "";
		s = s + getTypeName(n->node(0)) + " ";
		s = s + ointerface + "Server::" + n->name() + "(";
		nl = &n->node(1)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			if(i != nl->begin())
				s = s + ", ";
			if(nl->get(i)->node(0)->name() == "in"){
				s = s + getTypeName(nl->get(i)->node(1)) + " ";
			}
			else if(nl->get(i)->node(0)->name() == "inref"){
				s = s + "const " + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			else {
				s = s + getTypeName(nl->get(i)->node(1)) + "& ";
			}
				
			s = s + nl->get(i)->node(2)->name();
		}
		s = s + "){\n";
		ofileImpT.writeLine(s);
		ofileImpT.indentMore();
		if(getTypeName(n->node(0)) == "BError"){
			s = getTypeName(n->node(0)) + "\terr;\n\n";
			ofileImpT.writeLine(s);
			s = "return err;\n";
			ofileImpT.writeLine(s);
		}
		else {
			s = getTypeName(n->node(0)) + "\tret;\n\n";
			ofileImpT.writeLine(s);
			s = "return ret;\n";
			ofileImpT.writeLine(s);
		}
		ofileImpT.indentLess();
		ofileImpT.writeLine("}\n\n");
		break;
	default:
		break;
	}
}

void GenBoap::pushPopVar(FileIndent& file, int push, BString func, Node* type, BString name){
	BIter		i;
	BList<Node*>*	nl;
	Type*		t;
	Type*		dt;
	BString		s;
	BString		swapType;
	
//	printf("GenBoap::pushPopVar: Func(%s) Type(%s) Name(%s)\n", func.retStr(), type->name().retStr(), name.retStr());
	if(t = gtypelist.search(type->name())){
//		printf("DoType: %p Derived(%p)\n", type, t->derived());
		if(dt = t->derived()){
			nl = &dt->node()->nodes();
			for(nl->start(i); !nl->isEnd(i); nl->next(i)){
				pushPopVar(file, push, func, nl->get(i)->node(0), name + "." + nl->get(i)->node(1)->name());
			}
		}
		nl = &t->node()->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			pushPopVar(file, push, func, nl->get(i)->node(0), name + "." + nl->get(i)->node(1)->name());
		}
	}
	else if(type->nodeType() == Node::TTYPELIST){
		if(push){
			file.writeLine("{\n");
			file.indentMore();
			file.writeLine(BString("BIter i") + opushPopDepth + ";\n");
			file.writeLine(func + "(" + name + ".number());\n");
			s = BString("for(i") + opushPopDepth + " = " + name + ".begin(); !" + name + ".isEnd(i" + opushPopDepth + "); " + name + ".next(i" + opushPopDepth + ")){\n";
			file.writeLine(s);
			file.indentMore();
			pushPopVar(file, push, func, type->node(0), name + "[i" + opushPopDepth++ + "]");
			opushPopDepth--;
			file.indentLess();
			file.writeLine("}\n");
			file.indentLess();
			file.writeLine("}\n");
		}
		else {
			file.writeLine("{\n");
			file.indentMore();
			file.writeLine(BString("Int32 n") + opushPopDepth + ";\n");
			s = getTypeName(type->node(0)) + " v" + opushPopDepth + ";\n";
			file.writeLine(s);
			file.writeLine(name + ".clear();\n");
			file.writeLine(func + "(n" + opushPopDepth + ");\n");
			file.writeLine(BString("while(n") + opushPopDepth + "--){\n");
			file.indentMore();
			pushPopVar(file, push, func, type->node(0), BString("v") + opushPopDepth++);
			opushPopDepth--;
			file.writeLine(name + ".append(v" + opushPopDepth + ");\n");
			file.indentLess();
			file.writeLine("}\n");
			file.indentLess();
			file.writeLine("}\n");
		}
	}
	else if(type->nodeType() == Node::TTYPEARRAY){
		// Check if raw data copy can be used

#ifdef ZAP
		printf("GenBoap::Checking For Raw Type: %s\n", getTypeName(type->node(0)).retStr());
		printf("GenBoap::IsRawType: %d\n", isRawType(type->node(0)));
		printf("\n");
#endif		

		if(isRawType(type->node(0))){
#ifdef ZAP
			printf("Push raw array of type: %s (%s)\n", getTypeName(type->node(0)).retStr(), getTypeSwapList(type->node(0)).retStr());
#endif
			swapType = getTypeSwapList(type->node(0));

			if(push){
				file.writeLine("{\n");
				file.indentMore();

				file.writeLine(func + "(" + name + ".size());\n");
				file.writeLine(func + "(" + name + ".size() * sizeof(" + getTypeName(type->node(0)) + "), " + name + ".data(), \"" + swapType + "\");\n");

				file.indentLess();
				file.writeLine("}\n");
			}
			else {
				file.writeLine("{\n");
				file.indentMore();

				file.writeLine(BString("UInt32 n") + opushPopDepth + ";\n");
				file.writeLine(func + "(n" + opushPopDepth + ");\n");
				file.writeLine(name + ".resize(n" + opushPopDepth + ");\n");
				file.writeLine(func + "(n" + opushPopDepth + " * sizeof(" + getTypeName(type->node(0)) + "), " + name + ".data(), \"" + swapType + "\");\n");

				file.indentLess();
				file.writeLine("}\n");
			}
		}
		else {
			if(push){
				file.writeLine("{\n");
				file.indentMore();
				file.writeLine(BString("UInt32 i") + opushPopDepth + ";\n");
				file.writeLine(func + "(" + name + ".size());\n");
				s = BString("for(i") + opushPopDepth + " = 0; i" + opushPopDepth + " < " + name + ".size(); i" + opushPopDepth + "++){\n";
				file.writeLine(s);
				file.indentMore();
				pushPopVar(file, push, func, type->node(0), name + "[i" + opushPopDepth++ + "]");
				opushPopDepth--;
				file.indentLess();
				file.writeLine("}\n");
				file.indentLess();
				file.writeLine("}\n");
			}
			else {
				file.writeLine("{\n");
				file.indentMore();
				file.writeLine(BString("UInt32 n") + opushPopDepth + ";\n");
				s = getTypeName(type->node(0)) + " v" + opushPopDepth + ";\n";
				file.writeLine(s);
				file.writeLine(func + "(n" + opushPopDepth + ");\n");
				file.writeLine(name + ".resize(n" + opushPopDepth + ");\n");
				file.writeLine(BString("for(UInt32 i = 0; i < n") + opushPopDepth + "; i++){\n");
				file.indentMore();
				pushPopVar(file, push, func, type->node(0), BString("v") + opushPopDepth++);
				opushPopDepth--;
				file.writeLine(name + "[i] = v" + opushPopDepth + ";\n");
				file.indentLess();
				file.writeLine("}\n");
				file.indentLess();
				file.writeLine("}\n");
			}
		}
	}
	else {
		file.writeLine(func + "(" + name + ");\n");
	}
}

void GenBoap::produceFuncC(Node* n){
	BIter		i;
	BString		s;
	BList<Node*>*	nl;
	BString		retType;
	
	retType = getTypeName(n->node(0));
	
	ofileImpC.writeLine("BError\terr;\n");
	ofileImpC.writeLine(retType + "\tret;\n");
	ofileImpC.writeLine("BoapPacketHead\ttxhead;\n");
	ofileImpC.writeLine("BoapPacketHead\trxhead;\n");
	ofileImpC.writeLine("\n");
	ofileImpC.writeLine("olock.lock();\n");
	ofileImpC.writeLine(BString("if(err = connectService(oname)){\n"));
	ofileImpC.indentMore();
	ofileImpC.writeLine("olock.unlock();\n");
	ofileImpC.writeLine(BString("return err;\n"));
	ofileImpC.indentLess();
	ofileImpC.writeLine("}\n");
	
	ofileImpC.writeLine("\n");
	ofileImpC.writeLine(BString("txhead.type = BoapMagic | BoapTypeRpc;\n"));
	ofileImpC.writeLine(BString("txhead.service = oservice;\n"));
	ofileImpC.writeLine(BString("txhead.cmd = ") + ofuncNum + ";\n");
	ofileImpC.writeLine("otx.pushHead(txhead);\n");
	
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		if(nl->get(i)->node(0)->name() == "in")
			pushPopVar(ofileImpC, 1, "otx.push", nl->get(i)->node(1), nl->get(i)->node(2)->name());
	}

	ofileImpC.writeLine("if(err = performCall(otx, orx)){\n");
	ofileImpC.indentMore();
	ofileImpC.writeLine("olock.unlock();\n");
	if(retType == "BError")
		ofileImpC.writeLine("return err;\n");
	else
		ofileImpC.writeLine("throw err;\n");
	ofileImpC.indentLess();
	ofileImpC.writeLine("}\n");
	
	ofileImpC.writeLine("orx.popHead(rxhead);\n");
	ofileImpC.writeLine("orx.pop(ret);\n");
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		if(nl->get(i)->node(0)->name() == "out")
			pushPopVar(ofileImpC, 0, "orx.pop", nl->get(i)->node(1), nl->get(i)->node(2)->name());
	}
	ofileImpC.writeLine("olock.unlock();\n");
	ofileImpC.writeLine("return ret;\n");
}

void GenBoap::produceImpC(Node* n){
	BString		s;
	BIter		i;
	BList<Node*>*	nl;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileImpC.writeLine(BString("namespace ") + omodule + " {\n");
		ofileImpC.indentMore();
		
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpC(n->nodes()[i]);
		}
		ofileImpC.indentLess();
		ofileImpC.writeLine("}\n");
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		ofuncNum = 16;
		ofileImpC.writeLine(ointerface + "::" + ointerface + "(BString name) : BoapClientObject(name){\n");
		ofileImpC.indentMore();
		ofileImpC.writeLine(BString("oapiVersion = ") + oapiVersion + ";\n");
		ofileImpC.indentLess();
		ofileImpC.writeLine("}\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpC(n->nodes()[i]);
		}
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpC(n->nodes()[i]);
		}
		break;
	case Node::TFUNC:
		s = s + getTypeName(n->node(0)) + " ";
		s = s + ointerface + "::" + n->name() + "(";
		nl = &n->node(1)->nodes();
		for(nl->start(i); !nl->isEnd(i); nl->next(i)){
			if(i != nl->begin())
				s = s + ", ";
			if(nl->get(i)->node(0)->name() == "in"){
				s = s + getTypeName(nl->get(i)->node(1)) + " ";
			}
			else if(nl->get(i)->node(0)->name() == "inref"){
				s = s + "const " + getTypeName(nl->get(i)->node(1)) + "& ";
			}
			else {
				s = s + getTypeName(nl->get(i)->node(1)) + "& ";
			}

			s = s + nl->get(i)->node(2)->name();
		}
		s = s + "){\n";
		ofileImpC.writeLine(s);
		ofileImpC.indentMore();
		produceFuncC(n);
		ofileImpC.indentLess();
		ofileImpC.writeLine("}\n\n");
		ofuncNum++;
		break;
	case Node::TAPIVERSION:
		oapiVersion = n->name().retInt();
		break;
	default:
		break;
	}
}

void GenBoap::produceFuncS(Node* n){
	BIter		i;
	BString		s;
	BList<Node*>*	nl;
	BString		retType;
	
	retType = getTypeName(n->node(0));
	
	ofileImpS.writeLine("BError\terr;\n");
	ofileImpS.writeLine("BoapPacketHead\trxhead;\n");
	ofileImpS.writeLine("BoapPacketHead\ttxhead;\n");
	ofileImpS.writeLine(retType + "\tret;\n");
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		s = getTypeName(nl->get(i)->node(1)) + "\t";
		s = s + nl->get(i)->node(2)->name() + ";\n";
		ofileImpS.writeLine(s);
	}
	ofileImpS.writeLine("\n");
	ofileImpS.writeLine("rx.popHead(rxhead);\n");
	
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		if(nl->get(i)->node(0)->name() == "in")
			pushPopVar(ofileImpS, 0, "rx.pop", nl->get(i)->node(1), nl->get(i)->node(2)->name());
	}

	s = BString("ret = ") + n->name() + "(";
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		if(i != nl->begin())
			s = s + ", ";
		s = s + nl->get(i)->node(2)->name();
	}
	s = s + ");\n";
	ofileImpS.writeLine(s);
	
	ofileImpS.writeLine("txhead.type = BoapMagic | BoapTypeRpcReply;\n");
	ofileImpS.writeLine("txhead.service = rxhead.service;\n");
	ofileImpS.writeLine("txhead.cmd = rxhead.cmd;\n");
	ofileImpS.writeLine("tx.pushHead(txhead);\n");
	ofileImpS.writeLine("tx.push(ret);\n");
	
	nl = &n->node(1)->nodes();
	for(nl->start(i); !nl->isEnd(i); nl->next(i)){
		if(nl->get(i)->node(0)->name() == "out")
			pushPopVar(ofileImpS, 1, "tx.push", nl->get(i)->node(1), nl->get(i)->node(2)->name());
	}

	ofileImpS.writeLine("return err;\n");
}

void GenBoap::produceFuncAdd(Node* n){
	BString		s;
	BIter		i;

	switch(n->nodeType()){
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceFuncAdd(n->nodes()[i]);
		}
		break;
	case Node::TFUNC:
		s = s + "ofuncList.append(BoapFuncEntry(" + ofuncNum + ", ";
		s = s + "(BoapFunc)&" + ointerface + "Service::do" + n->name() + "));\n";
		ofileImpS.writeLine(s);
		ofuncNum++;
		break;
	default:
		break;
	}
}

void GenBoap::produceImpS(Node* n){
	BString		s;
	BIter		i;

	switch(n->nodeType()){
	case Node::TMODULE:
		omodule = n->name();
		ofileImpS.writeLine(BString("namespace ") + omodule + " {\n");
		ofileImpS.indentMore();
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpS(n->nodes()[i]);
		}
		ofileImpS.indentLess();
		ofileImpS.writeLine("}\n");
		break;
	case Node::TINTERFACE:
		ointerface = n->name();
		ofuncNum = 16;
		ofileImpS.writeLine(ointerface + "Service::" + ointerface + "Service(BoapServer& server, BString name) : BoapServiceObject(server, name){\n");
		ofileImpS.indentMore();
		ofileImpS.writeLine(BString("oapiVersion = ") + oapiVersion + ";\n");
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceFuncAdd(n->nodes()[i]);
		}
		ofileImpS.indentLess();
		ofileImpS.writeLine("}\n");		
		ofuncNum = 16;
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpS(n->nodes()[i]);
		}
		break;
	case Node::TLIST:
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			produceImpS(n->nodes()[i]);
		}
		break;
	case Node::TFUNC:
		s = "BError ";
		s = s + ointerface + "Service::do" + n->name();
		s = s + "(BoapServerConnection* conn, BoapPacket& rx, BoapPacket& tx){\n";
		ofileImpS.writeLine(s);
		ofileImpS.indentMore();
		produceFuncS(n);
		ofileImpS.indentLess();
		ofileImpS.writeLine("}\n\n");
		ofuncNum++;
		break;
	case Node::TAPIVERSION:
		oapiVersion = n->name().retInt();
		break;
	default:
		break;
	}
}

BError GenBoap::produceHeaderIntC(){
	BError	err;
	BString	fileName = ofileName + "C.h";
	BString	fileNameUpper = ofileName + "C_H";

	fileNameUpper.toUpper();

	ofileIntC.printf("/*******************************************************************************\n");
	ofileIntC.printf(" *\t%s\tProduced by Bidl\n", fileName.retStr());
	ofileIntC.printf(" *******************************************************************************\n");
	ofileIntC.printf(" */\n");
	ofileIntC.printf("\n");
	ofileIntC.printf("#ifndef %s\n", fileNameUpper.retStr());
	ofileIntC.printf("#define %s 1\n\n", fileNameUpper.retStr());

	ofileIntC.printf("#include <stdlib.h>\n");
	ofileIntC.printf("#include <stdint.h>\n");
	ofileIntC.printf("#include <Boap.h>\n");
	ofileIntC.printf("#include <BString.h>\n");
	ofileIntC.printf("#include <BList.h>\n");
	ofileIntC.printf("#include <BArray.h>\n");
#ifdef ZAP1
	ofileIntC.printf("#include <BObjDate.h>\n");
	ofileIntC.printf("#include <BObjData.h>\n");
#endif
#if !DODATA
	ofileIntC.printf("#include <%s>\n\n", (ofileName + "D.h").retStr());
#endif
	ofileIntC.printf("\n");
	return err;
}

BError GenBoap::produceHeaderIntS(){
	BError	err;
	BString	fileName = ofileName + "S.h";
	BString	fileNameUpper = ofileName + "S_H";

	fileNameUpper.toUpper();

	ofileIntS.printf("/*******************************************************************************\n");
	ofileIntS.printf(" *\t%s\tProduced by Bidl\n", fileName.retStr());
	ofileIntS.printf(" *******************************************************************************\n");
	ofileIntS.printf(" */\n");
	ofileIntS.printf("\n");
	ofileIntS.printf("#ifndef %s\n", fileNameUpper.retStr());
	ofileIntS.printf("#define %s 1\n\n", fileNameUpper.retStr());

	ofileIntS.printf("#include <stdint.h>\n");
	ofileIntS.printf("#include <Boap.h>\n");
	ofileIntS.printf("#include <BString.h>\n\n");
	ofileIntS.printf("#include <%sC.h>\n", ofileName.retStr());
	ofileIntS.printf("\n");
	return err;
}

BError GenBoap::produceHeaderIntT(){
	BError	err;
	BString	fileName = ofileName + "T.h";
	BString	fileNameUpper = ofileName + "T_H";

	fileNameUpper.toUpper();

	ofileIntT.printf("/*******************************************************************************\n");
	ofileIntT.printf(" *\t%s\tProduced by Bidl\n", fileName.retStr());
	ofileIntT.printf(" *******************************************************************************\n");
	ofileIntT.printf(" */\n");
	ofileIntT.printf("\n");
	ofileIntT.printf("#ifndef %s\n", fileNameUpper.retStr());
	ofileIntT.printf("#define %s 1\n\n", fileNameUpper.retStr());

	ofileIntT.printf("#include <BString.h>\n");
	ofileIntT.printf("#include <BList.h>\n");
	ofileIntT.printf("#include <BArray.h>\n");
	ofileIntT.printf("#include <%s>\n", (ofileName + "S.h").retStr());
	ofileIntT.printf("\n");
	return err;
}

BError GenBoap::produceHeaderImpT(){
	BError	err;
	BString	fileName = ofileName + "T.cc";
	BString	fileNameUpper = ofileName + "T_H";

	fileNameUpper.toUpper();

	ofileImpT.printf("/*******************************************************************************\n");
	ofileImpT.printf(" *\t%s\tProduced by Bidl\n", fileName.retStr());
	ofileImpT.printf(" *******************************************************************************\n");
	ofileImpT.printf(" */\n");
	ofileImpT.printf("\n");

	ofileImpT.printf("#include <stdlib.h>\n");
	ofileImpT.printf("#include <stdint.h>\n");
	ofileImpT.printf("#include <%s>\n", (ofileName + "T.h").retStr());
	ofileImpT.printf("\n");
	return err;
}

BError GenBoap::produceTrailerInt(){
	BError	err;
	
	ofileIntC.printf("#endif\n");
	ofileIntS.printf("#endif\n");
	ofileIntT.printf("#endif\n");
	return err;
}

BError GenBoap::produceHeaderImpC(){
	BError	err;

	ofileImpC.printf("/*******************************************************************************\n");
	ofileImpC.printf(" *\t%s\tProduced by Bidl\n", (ofileName + ".cc").retStr());
	ofileImpC.printf(" *******************************************************************************\n");
	ofileImpC.printf(" */\n");
	ofileImpC.printf("\n");
	ofileImpC.printf("#include <%s>\n", (ofileName + "C.h").retStr());
	ofileImpC.printf("\n");
	return err;
}

BError GenBoap::produceHeaderImpS(){
	BError	err;

	ofileImpS.printf("/*******************************************************************************\n");
	ofileImpS.printf(" *\t%s\tProduced by Bidl\n", (ofileName + ".cc").retStr());
	ofileImpS.printf(" *******************************************************************************\n");
	ofileImpS.printf(" */\n");
	ofileImpS.printf("\n");
	ofileImpS.printf("#include <%s>\n", (ofileName + "C.h").retStr());
	ofileImpS.printf("#include <%s>\n", (ofileName + "S.h").retStr());
	ofileImpS.printf("\n");
	return err;
}

BString GenBoap::getTypeSwapList(Node* n){
	BString	typeName;
	Type*	t;
	BIter	i;
	BString	typeList;

	typeName = n->name();
//	printf("isRawType: %d %s\n", n->nodeType(), typeName.retStr());

	if(n->nodeType() == Node::TTYPEARRAY){
		return "";
	}
	else if(n->nodeType() == Node::TTYPE){
		if(typeName == "Int8")		return "1";
		else if(typeName == "UInt8")	return "1";
		else if(typeName == "Int16")	return "2";
		else if(typeName == "UInt16")	return "2";
		else if(typeName == "Int32")	return "4";
		else if(typeName == "UInt32")	return "4";
		else if(typeName == "Bool")	return "4";
		else if(typeName == "String")	return "";
		else if(typeName == "Error")	return "";
		else if(typeName == "Date")	return "";
		else if(typeName == "DateTime")	return "";
		else if(typeName == "Id")	return "";
		else if(typeName == "ObjData")	return "";
		else {
			if(t = gtypelist.search(typeName)){
				if(t->node()){
					return  getTypeSwapList(t->node());
				}
			}
			else
				return "";
		}
	}
	else if(n->nodes().number()){
		for(n->nodes().start(i); !n->nodes().isEnd(i); n->nodes().next(i)){
			typeList += getTypeSwapList(n->nodes()[i]);
		}

		return typeList;
	}
	return "";
}



GenBoap::GenBoap(){
	ofuncNum = 0;
	opushPopDepth = 0;
	oapiVersion = 0;
	
	setUseBObjects(0);
}

GenBoap::~GenBoap(){
}

BError GenBoap::produce(Node* n, BString fileName){
	BError	err;
	
//	dprintf("GenBoap::produce: %x\n", n);
	ofileName = fileName;
	ofileIntC.open(fileName + "C.h", "w");
	ofileIntS.open(fileName + "S.h", "w");
	ofileImpC.open(fileName + "C.cc", "w");
	ofileImpS.open(fileName + "S.cc", "w");
	ofileIntT.open(fileName + "T.h", "w");
	ofileImpT.open(fileName + "T.cc", "w");
	
	// File Headers
	produceHeaderIntC();
	produceHeaderIntS();
	produceHeaderImpC();
	produceHeaderImpS();
	produceHeaderIntT();
	produceHeaderImpT();
	
	// Generate code
	produceIntC(n);
	produceIntS(n);
	produceImpC(n);
	produceImpS(n);
	
	// Generate Base 
	produceIntT(n);
	produceImpT(n);

	// Generate trailers
	produceTrailerInt();
	ofileImpS.close();
	ofileImpC.close();
	ofileIntS.close();
	ofileIntC.close();
	ofileIntT.close();
	ofileImpT.close();
	return err;
}