//[Personalities/Java - (c) Luis Blando.]
//[Personalities/Java behavior file #2 under construction, by Diego Rodrigo.]
//[thesis advisor : Daniel Gandara.]

//this behavior file contais the Main class.

//*********************************************************************
//[Main class definition]
//*********************************************************************

Main{
	(@
		//some useful constants & 1 FileInputStream to read from.
		//[it's better to use boolean instead of FAILED & OK]
		public final static String version="0.1.9";
		public final static int FAILED=-1;
		public final static int OK=0;

		private static FileInputStream fileInputStream;
		private static boolean verbose = false;
		private static boolean debug = false;

		private static final int NOINPUTFILE = -2;
		private static final int READ = -4;
		private static final int WRITE = -8;
		private static final int OTHER = -1;
		private static boolean error = false;
		private static String errmsg = "";
		private static long startingTime;
	@)

	//getHeader makes the common header for all files
	public static String getHeader(String fname)
	(@
		String tmp="/***************************************************************\n"
			+  "[ "+fname+" ]\n\n"
			+  "\tAutomatically generated by Personalities/Java compiler.\n"
			+  "***************************************************************/\n";
		return tmp;
	@)

	private static String writePackage(String Package)
	(@
		if (!Package.equals(""))
			return "package " + Package + ";\n\n";
		else
			return "";
	@)

	private static String writeImports(Vector Imports)
	(@
		String tmp = "";
		for (int i=0; i< Imports.size(); i++)
			tmp+= "import " + (String)Imports.elementAt(i) + ";\n";
		return tmp;
	@)

	/***the next 2 methods are for personality interfaces***/
	//makeDiDecl writes the downstream interface declaration.
	public static String makeDiDecl(Vector diList)
	(@
		String tmp = "//[downstream interface declaration begins.]\n";
		int length = diList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityDownStreamDecl diD = (PersonalityDownStreamDecl)diList.elementAt(i);
			PReturnType prt = diD.get_preturntype();
			prt.universal_trv0( pv );
			tmp+= "\t" + sw + "\t";
			PMethodDeclarator pmd = diD.get_pmethoddeclarator();
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			pmd.universal_trv0( pv );
			tmp+= sw + ";\n";
		}
		tmp += "//[downstream interface declaration ends.]\n";
		return tmp;
	@)

	//makeUiDecl writes the upstream interface declaration.
	//it writes the signature of every public method in a personality.
	public static String makeUiDecl(Vector meList)
	(@
		String tmp = "//[upstream interface declaration begins.]\n";
		String aux = "";
		int length = meList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityMethodDecl pmD = (PersonalityMethodDecl)meList.elementAt(i);
			MethodDeclaration meD = pmD.get_methoddeclaration();
			MethodModifiers meM = meD.get_methodmodifiers();
			ResultType reT = meD.get_resulttype();
			MethodDeclarator meDr = meD.get_methoddeclarator();
			meM.universal_trv0( pv );
			aux += sw;
			//only public methods are part of the ui.
			if (aux.indexOf("private") == -1
				&& aux.indexOf("native") == -1
				&& aux.indexOf("static") == -1
				&& aux.indexOf("synchronized") == -1
				&& aux.indexOf("final") == -1
				&& aux.indexOf("protected") == -1
				&& aux.indexOf("abstract") == -1 )
			{
				tmp += "//PersonalityMethodDecl("+i+")\n";
				tmp += "\t" + sw + " \t";
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				reT.universal_trv0( pv );
				tmp += sw + " " ;
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				meDr.universal_trv0( pv );
				tmp += sw + ";\n";
			}
		}
		tmp+= "//[upstream interface declaration ends.]\n";
		return tmp;
	@)

	/***the next 5 methods are for personality$Ego classes***/
	//makeMethodBody should write the body of every upstream(=public)
	//and private(& protected) method.
	//[not working yet!!!]
	public static String makeMethodBody(Vector meList, Vector diList, String personality)
	(@
		String tmp = "//[methods body begins.]\n";
		String aux;
		int length = meList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityMethodDecl pmD = (PersonalityMethodDecl)meList.elementAt(i);
			MethodDeclaration meD = pmD.get_methoddeclaration();
			MethodModifiers meM = meD.get_methodmodifiers();
			ResultType reT = meD.get_resulttype();
			MethodDeclarator meDr = meD.get_methoddeclarator();
			AnyBlock anB = meD.get_anyblock();
			meM.universal_trv0( pv );
			aux = "";
			aux += sw;
			//only public methods are part of the ui.
			if (aux.indexOf("private") == -1
				&& aux.indexOf("native") == -1
				&& aux.indexOf("static") == -1
				&& aux.indexOf("synchronized") == -1
				&& aux.indexOf("final") == -1
				&& aux.indexOf("protected") == -1
				&& aux.indexOf("abstract") == -1 )
			{
				tmp += "//PersonalityMethodDecl("+i+") UI = public\n";
				tmp += "\t" + sw + " \t";
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				reT.universal_trv0( pv );
				tmp += sw + " " ;
				//all this mess is to add 'host' to the parameter list.
				tmp+= meDr.get_identifier();
				tmp+= "(" + personality + " host";
				FormalParameters foP = meDr.get_formalparameters();
				ParameterVisitor parV = new ParameterVisitor();
				foP.toParameters(parV);
				Vector parList = parV.getList();
				int j, length2 = parList.size();
				FormalParameter foPar;
				for(j=0; j<length2; j++)
				{
					sw = new StringWriter();
					pw = new PrintWriter( sw );
					pv = new PrintVisitor( pw );
					foPar = (FormalParameter)parList.elementAt(j);
					foPar.universal_trv0( pv );
					tmp+= ", " + sw;
				}
				tmp+= ")";
				//parameter list done.
				//look for square brackets...
				SquareBrackets sqB = meDr.get_squarebrackets();
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				sqB.universal_trv0( pv );
				tmp += sw;
				//get the throws clause, if exists.
				NameList NL = meD.get_throwsclause();
				if(NL!=null)
				{
					sw = new StringWriter();
					pw = new PrintWriter( sw );
					pv = new PrintVisitor( pw );
					NL.universal_trv0( pv );
					tmp += " throws " + sw ;
				}
				tmp+= "\n";
				if (debug)
				{
					tmp+= "/******************************\n"
						+ "\tDEBUG INFO STARTS\n";
					sw = new StringWriter();
					pw = new PrintWriter( sw );
					pv = new PrintVisitor( pw );
					anB.universal_trv0( pv );
					tmp+= sw;
					tmp+= "\n\tDEBUG INFO ENDS\n"
						+ "******************************/\n";
				}
				//next, we send a visitor to the block, to
				//add "host." before any DI method call.
				HostDotVisitor HDV = new HostDotVisitor(diList);
				anB.toPrimaryExpressions(HDV);
				//the original code has been changed, so, if we
				//send a print visitor, it'll print the new code,
				//with "host." before the DI method calls :-)
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				anB.universal_trv0( pv );
				tmp += sw + "\n";
			}
			//if it's protected or private, just write it...
			else if (aux.indexOf("protected") != -1
				|| aux.indexOf("private") != -1 )
			{
				tmp += "//PersonalityMethodDecl("+i+") -private or protected-\n";
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				pmD.universal_trv0( pv );
				tmp += sw + "\n" ;
			}
		}
		tmp += "//[methods body ends.]\n";
		return tmp;
	@)

	//makeInitializerBody should writes Initializers.
	public static String makeInitializerBody(Vector inList)
	(@
		String tmp = "//initializers below\n";
		int length = inList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityInitializerDecl inD = (PersonalityInitializerDecl)inList.elementAt(i);
			inD.universal_trv0( pv );
			tmp+= "//PersonalityInitializerDecl("+i+")\n";
			tmp+= sw + "\n";
		}

		return tmp;
	@)

	//makeNestedClassBody writes NestedClasses.
	public static String makeNestedClassBody(Vector ncList)
	(@
		String tmp = "//nested classes below\n";
		int length = ncList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityNestedClassDecl ncD = (PersonalityNestedClassDecl)ncList.elementAt(i);
			ncD.universal_trv0( pv );
			tmp+= "//PersonalityNestedClassDecl("+i+")\n";
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//makeConstructorBody writes constructors.
	//[i think it's ready...]
	public static String makeConstructorBody(Vector coList)
	(@
		String tmp = "//constructor below\n";
		int length = coList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw;
			PrintWriter pw;
			PrintVisitor pv;
			PersonalityConstructorDecl pcoD = (PersonalityConstructorDecl)coList.elementAt(i);
			ConstructorDeclaration coD = pcoD.get_constructordeclaration();
			tmp+= "//PersonalityConstructorDecl("+i+")\n";
			tmp+= "public ";
			tmp+= coD.get_identifier() + "$Ego";
			FormalParameters foP = coD.get_formalparameters();
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			foP.universal_trv0( pv );
			tmp+= sw;
			NameList NL = coD.get_throwsclause();
			if (NL != null)
			{
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				NL.universal_trv0(pv);
				tmp+= " throws " + sw;
			}
			tmp+= "\n";
			tmp+= "{\n";
			ExplicitConstructorInvocation eci = coD.get_explicitconstructorinvocation();
			if (eci != null)
			{
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				eci.universal_trv0(pv);
				tmp+= sw + "\n";
			}
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			BlockStatements blS = coD.get_blockstatements();
			blS.universal_trv0( pv );
			tmp+= sw + "\n";
			tmp+= "}\n";
		}
		return tmp;
	@)

	//makeFieldBody writes Fields.
	public static String makeFieldBody(Vector fiList)
	(@
		String tmp = "//fields below\n";
		int length = fiList.size();
		for (int i=0; i<length; i++)
		{
			StringWriter sw = new StringWriter();
			PrintWriter pw = new PrintWriter( sw );
			PrintVisitor pv = new PrintVisitor( pw );
			PersonalityFieldDecl fiD = (PersonalityFieldDecl)fiList.elementAt(i);
			fiD.universal_trv0( pv );
			tmp += "//PersonalityFieldDecl("+i+")\n";
			tmp += sw + "\n";
		}
		return tmp;
	@)

	/***the next 9 methods are for plain, ordinary classes***/
	//getExtends writes the extends clause , if exists
	public static String getExtends(UnmodifiedClassDeclaration cd)
	(@
		String tmp = cd.getExtended();
		if (tmp != "")
			tmp = " extends " + tmp + " ";
		return tmp;
	@)

	//getImplements writes the implements clause, if needed
	//[original implements clause is not currently written!!!]
	public static String getImplements(UnmodifiedClassDeclaration cd)
	(@
		Vector v = cd.getPersonified();
		String tmp = "";
		int i, length = v.size();
		for(i=0; i<length; i++)
		{
			if (i==0)
				tmp+= " implements ";
			else
				tmp+= ", ";
			tmp+= (String) v.elementAt(i);
		}
		v = cd.getImplemented();
		int length2 = v.size();
		for(i=0; i<length2; i++)
		{
			if (i==0 && length==0)
				tmp+= " implements ";
			else
				tmp+= ", ";
			tmp+= (String)v.elementAt(i);
		}
		return tmp;
	@)

	//writes initializers.
	public static String makeClassInitializer(Vector inList)
	(@
		int i, length = inList.size();
		String tmp = "//initializers: " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		for (i=0; i<length; i++)
		{
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			((Initializer)inList.elementAt(i)).universal_trv0(pv);
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//writes constructors.
	public static String makeClassConstructor(Vector coList)
	(@
		int i, length = coList.size();
		String tmp = "//constructors: " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		for (i=0; i<length; i++)
		{
			ConstructorDeclaration coD = (ConstructorDeclaration)coList.elementAt(i);
			ConstructorModifier coM = coD.get_constructormodifier();
			if (coM != null)
			{
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				coM.universal_trv0(pv);
				tmp+= sw;
			}
			else
				tmp+= "public";
			Identifier id = coD.get_identifier();
			tmp+= " "+ id;
			FormalParameters foP = coD.get_formalparameters();
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			foP.universal_trv0(pv);
			tmp+= sw;
			NameList thC = coD.get_throwsclause();
			if (thC != null)
			{
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				thC.universal_trv0(pv);
				tmp+= " throws " + sw;
			}
			tmp+= "\n{\n";
			ExplicitConstructorInvocation exC = coD.get_explicitconstructorinvocation();
			if (exC != null)
			{
				sw = new StringWriter();
				pw = new PrintWriter( sw );
				pv = new PrintVisitor( pw );
				exC.universal_trv0(pv);
				tmp+= sw;
			}
			BlockStatements blS = coD.get_blockstatements();
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			blS.universal_trv0(pv);
			tmp+= sw + "\n}\n";
		}
		return tmp;
	@)

	//writes nested classes.
	public static String makeClassNC(Vector ncList)
	(@
		int i, length = ncList.size();
		String tmp = "//nested class: " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		for (i=0; i<length; i++)
		{
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			((CBD_NestedClassDeclaration)ncList.elementAt(i)).universal_trv0(pv);
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//writes nested interfaces.
	public static String makeClassNI(Vector niList)
	(@
		int i, length = niList.size();
		String tmp = "//nested init : " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		for (i=0; i<length; i++)
		{
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			((CBD_NestedInterfaceDeclaration)niList.elementAt(i)).universal_trv0(pv);
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//writes methods (ordinary class methods).
	//[it has to assure that DIs are public.]
	//[is it right???]
	public static String makeClassMethod(Vector meList, Vector personalities, Vector DepVec)
	(@
		int i, length;
		length = meList.size();
		String tmp = "//methods     : " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		CBD_MethodDeclaration _meD;

		Vector actualPers = new Vector();
		DepLeaf dl;
		for (i=0; i< personalities.size(); i++)
		{
			String personality = (String)personalities.elementAt(i);
			for (int j=0; j< DepVec.size(); j++)
			{
				dl = (DepLeaf)DepVec.elementAt(j);
				if ( personality.equals(dl.getIdent())
					&& dl.getType().equals("personality") )
				{
					actualPers.addElement(dl);
				}
			}
		}
		MethodDeclaration meD;
		MethodModifiers meM;
		MethodDeclarator meDr;
		Identifier id;
		String meName;
		boolean out;

		for(i=0; i<length; i++)
		{
			out = false;
			_meD = (CBD_MethodDeclaration)meList.elementAt(i);
			meD = _meD.get_methoddeclaration();
			meDr = meD.get_methoddeclarator();
			id = meDr.get_identifier();
			meName = id.toString();
			for(int j=0; j<actualPers.size(); j++)
			{
				dl = (DepLeaf)actualPers.elementAt(j);
				PersonalityDeclaration PD = (PersonalityDeclaration)dl.getObject();
				PersonalityFieldsVisitor PFV = new PersonalityFieldsVisitor();
				PD.toEveryField(PFV);
				Vector diList = PFV.getDiList();
				for (int k=0; k<diList.size(); k++)
				{
					PersonalityDownStreamDecl DI = (PersonalityDownStreamDecl)diList.elementAt(k);
					String diName = DI.getDiName();
					if ( diName.equals(meName) )
					{
						//System.out.println("Eureka : "+diName);
						meM = meD.get_methodmodifiers();
						sw = new StringWriter();
						pw = new PrintWriter( sw );
						pv = new PrintVisitor( pw );
						meM.universal_trv0(pv);
						String mm = "" + sw;
						if ( mm.indexOf("public") == -1 )
							tmp+= "public ";
						out = true;
						break;
					}
				}
				if (out)
					break;
			}
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			meD.universal_trv0(pv);
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//writes fields.
	public static String makeClassField(Vector fiList)
	(@
		int i, length = fiList.size();
		String tmp = "//fields      : " + length +"\n";
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		for (i=0; i<length; i++)
		{
			sw = new StringWriter();
			pw = new PrintWriter( sw );
			pv = new PrintVisitor( pw );
			((CBD_FieldDeclaration)fiList.elementAt(i)).universal_trv0(pv);
			tmp+= sw + "\n";
		}
		return tmp;
	@)

	//this method writes UI methods, from a list of personalities.
	public static String makeClassUI(Vector personalities, Vector DepVec)
	(@
		int i, j , k, length, dlength, ulength;
		length = personalities.size();
		dlength = DepVec.size();
		DepLeaf dl;
		Vector uiList;
		StringWriter sw;
		PrintWriter pw;
		PrintVisitor pv;
		String tmp = "//UI methods for " + length + " personalities\n";
		for (i=0; i<length; i++)
		{
			String personality = (String)personalities.elementAt(i);
			tmp+= "//for personality " + personality + " :\n";
			String instance;
			char c = personality.charAt(0);
			int l = personality.length();
			String C;
			if (c <= 'Z')
				C = String.valueOf(c).toLowerCase();
			else
				C = String.valueOf(c).toUpperCase();
			instance = "$" + C + personality.substring(1,l);
			tmp+= personality + "$Ego " + instance +
				" = new " + personality + "$Ego();\n";
			for (j=0; j<dlength; j++)
			{
				dl = (DepLeaf) DepVec.elementAt(j);
				if (debug)
				{
					System.out.println(dl.getIdent() + " :: " + personality);
					System.out.println(dl.getType() + " :: " );
				}
				if ( dl.getIdent().equals(personality)
					&& dl.getType().equals("personality") )
				{
					//it would be nice to have the list of UIs
					//loaded with the personality ...
					//uiList = dl.getList();
					PersonalityFieldsVisitor PFV = new PersonalityFieldsVisitor();
					PersonalityDeclaration PD = (PersonalityDeclaration)dl.getObject();
					PD.toEveryField(PFV);
					uiList = PFV.getMeList();
					ulength = uiList.size();
					PersonalityMethodDecl PMD;
					MethodDeclaration meD;
					MethodModifiers meM;
					for (k=0; k<ulength; k++)
					{	
						String aux = "";
						PMD = (PersonalityMethodDecl)uiList.elementAt(k);
						meD = PMD.get_methoddeclaration();
						meM = meD.get_methodmodifiers();
						ResultType reT = meD.get_resulttype();
						MethodDeclarator meDr = meD.get_methoddeclarator();
						sw = new StringWriter();
						pw = new PrintWriter( sw );
						pv = new PrintVisitor( pw );
						meM.universal_trv0(pv);
						aux+= sw;
						if (aux.indexOf("private") == -1
							&& aux.indexOf("native") == -1
							&& aux.indexOf("static") == -1
							&& aux.indexOf("synchronized") == -1
							&& aux.indexOf("final") == -1
							&& aux.indexOf("protected") == -1
							&& aux.indexOf("abstract") == -1 )
						{
							tmp+= "public ";
							sw = new StringWriter();
							pw = new PrintWriter( sw );
							pv = new PrintVisitor( pw );
							reT.universal_trv0( pv );
							tmp += sw + " " ;
							sw = new StringWriter();
							pw = new PrintWriter( sw );
							pv = new PrintVisitor( pw );
							meDr.universal_trv0( pv );
							tmp += sw + "\n" ;
							tmp+= "{\n";
							tmp+= "\t" + instance + "." + meDr.get_identifier();
							tmp+= "(" + " this";
							FormalParameters foP = meDr.get_formalparameters();
							ParameterVisitor parV = new ParameterVisitor();
							foP.toParameters(parV);
							Vector parList = parV.getList();
							int kk, llength = parList.size();
							FormalParameter foPar;
							for(kk=0; kk<llength; kk++)
							{
								sw = new StringWriter();
								pw = new PrintWriter( sw );
								pv = new PrintVisitor( pw );
								foPar = (FormalParameter)parList.elementAt(kk);
								VariableDeclaratorId vdId = foPar.get_variabledeclaratorid();
								//what about square brackets ???
								vdId.universal_trv0( pv );
								tmp+= ", " + sw;
							}
							tmp+= ");\n";
							tmp+= "}\n";
						}
						
					}
					break;
				}
			}
		}
		return tmp;
	@)

	//writeFile _writes_ contents into the file fname (obvious ?)
	//returns OK if it's all right, and FAILED if something went wrong.
	//[is it too C-ish?]
	private static int writeFile(String fname, String contents)
	(@
		contents=getHeader(fname)+contents;
		if (verbose)
			System.out.println("saving " + fname + "...");
		File file;
		try{
			file = new File(fname);
		}
		catch (Exception e){
			return FAILED;
		}
		FileOutputStream fOS;
		PrintWriter pW;
		try{
			fOS=new FileOutputStream(file);
			pW=new PrintWriter(fOS);
			pW.println(contents);
			pW.flush();
			pW.close();
		}
		catch(Exception e){
			return FAILED;
		}
		return OK;
	@)

	//openFile _opens_ the file fname, and creates fileInputStream.
	//returns OK if it's all right, and FAILED if something went wrong.
	//[is it too C-ish?]
	private static int openFile(String fname)
	(@
		File file;
		try{
			file=new File(fname);
		}
		catch(Exception e){
			return FAILED;
		}
		try{
			fileInputStream=new FileInputStream(file);
		}
		catch(Exception e){
			return FAILED;
		}
		return OK;
	@)

	private static boolean searchVector(Vector v, String type, String name)
	(@
		DepLeaf df;
		int i, length = v.size();
		for (i=0; i<length; i++)
		{
			df = (DepLeaf)v.elementAt(i);
			if (df.getType().equals(type) && df.getIdent().equals(name))
				return true;
		}
		return false;
	@)

	private static void setError(int type, String msg)
	(@
		error = true;
		switch (type){
			case READ:
				errmsg=new String("Error, cannot open file: "+msg);
				break;
			case WRITE:
				errmsg=new String("Error, cannot write file: "+msg);
				break;
			case NOINPUTFILE:
				errmsg=new String("Error, no input file.\n" +
					"\tUse :\n" +
					"\t\tjava Main [-verbose] [-debug] <inputFile.pj>");
			default:
				errmsg=msg;
		}
	@)

	private static void abort()
	(@
		System.out.println(errmsg);
		System.out.println("Exiting...");
		System.exit(1);
	@)

	//the show starts here.
	//the main function is quite large, so it has more comments inside ...
	public static void main(String args[])	throws Exception
	(@
		startingTime = System.currentTimeMillis();
		//write some info stuff.
		System.out.println("Personalities/Java compiler v"+version);

		//open & read the source files.
		String fname = "";
		Vector fnames = new Vector();
		String option = "";
		if (args.length>0)
		{
			for (int i=0; i<args.length; i++)
			{
				if (args[i].charAt(0) == '-')
				{
					option = args[i].substring(1,args[i].length());
					if (option.toLowerCase().equals("verbose"))
						verbose = true;
					else if (option.toLowerCase().equals("debug"))
						debug = true;
					else
						System.out.println("Unknown option: " + option);
				}
				else
					fnames.addElement(args[i]);
			}
		}
		else
		{
			setError(NOINPUTFILE, " ");
			abort();
		}
		if (fnames.size() == 0)
		{
			setError(NOINPUTFILE, " ");
			abort();
		}
		//start parsing the source files...
		try{
			CompilationUnit cu;
			ClassesVisitor cv=new ClassesVisitor(verbose);
			DepLeaf df;
			Vector DepVec = new Vector();
			for (int i=0; i<fnames.size(); i++)
			{
				fname = (String)fnames.elementAt(i);
				if ( openFile(fname) == FAILED )
				{
					setError(READ, fname+".java");
					abort();
				}
				cu=CompilationUnit.parse(fileInputStream);

				//traverse to classes, and get one if exists.
				//if not, traverse to personalities, and get one.
				cu.toClasses(cv);
				df=cv.getObject();
				if (df.getType().equals("noname"))
				{
					cu.toPersonalities(cv);
					df=cv.getObject();
				}
				//now, start building the dependency list
				DepVec.addElement(df);
			}
			//some temporary objects.
			CompilationUnit tempCU;
			PersonalityDeclaration pd=new PersonalityDeclaration();
			UnmodifiedClassDeclaration cd=new UnmodifiedClassDeclaration();

			//next, we populate the dependency list with the
			//names of 'parent' classes and/or personalities.
			//after that, we open & parse these files,
			//and continue the loop until no more classes or
			//personalities are left to be loaded.
			boolean allLoaded=false;
			int i=0;
			String oname;	//object name
			Vector vnames;	//vector of names
			//[TODO : check if the file to load is already loaded!!!]
			while (! allLoaded && !error){
				df=(DepLeaf)DepVec.elementAt(i);
				if (df.getType()=="personality")
				{
					pd=(PersonalityDeclaration)df.getObject();
					oname=new String(pd.getExtended());
					//does it extend any personality?
					if (!oname.equals(""))
					{
						if (!searchVector(DepVec, "personality", oname))
						{
							//System.out.println("!!!FOUND EXTENDED:"+oname);
							if (openFile(oname+".pj")!=FAILED)
							{
								tempCU=CompilationUnit.parse(fileInputStream);
								tempCU.toPersonalities(cv);
								pd=(PersonalityDeclaration) cv.getObject().getObject();
								df.markAsLoaded();
								df=new DepLeaf(pd.get_ident().toString(), pd, "personality");
								DepVec.addElement(df);
							}
							else
							{
								setError(READ, oname+".pj");
								break;
							}
						}
					}
					else
					{
						df.markAsLoaded();
					}
				}
				else	//TODO: mark depLeaf asLoaded !!!
				{
					cd=(UnmodifiedClassDeclaration)df.getObject();
					oname=new String(cd.getExtended());
					//does it extend any class?
					if (!oname.equals(""))
					{
						if (!searchVector(DepVec, "class", oname))
						{
							//System.out.println("!!!FOUND EXTENDED:"+oname);
							if (openFile(oname+".pj")!=FAILED)
							{
								UnmodifiedClassDeclaration newcd = new UnmodifiedClassDeclaration();
								tempCU=CompilationUnit.parse(fileInputStream);
								tempCU.toClasses(cv);
								newcd=(UnmodifiedClassDeclaration) cv.getObject().getObject();
								df.markAsLoaded();
								df=new DepLeaf(newcd.get_ident().toString(), newcd, "class");
								DepVec.addElement(df);
							}
							else
							{
								setError(READ, oname+".pj");
								break;
							}
						}
					}
					vnames = cd.getPersonified();
					int length = vnames.size();
					for (int j=0; j<length; j++)
					{
						oname = (String) vnames.elementAt(j);
						if (!searchVector(DepVec, "personality", oname))
						{
							//System.out.println("!!!FOUND PERSONIFIED:"+oname);
							if (openFile(oname+".pj")!=FAILED)
							{
								tempCU=CompilationUnit.parse(fileInputStream);
								tempCU.toPersonalities(cv);
								pd=(PersonalityDeclaration) cv.getObject().getObject();
								df=new DepLeaf(pd.get_ident().toString(), pd, "personality");
								DepVec.addElement(df);
							}
							else
							{
								setError(READ, oname+".pj");
								break;
							}
						}
					}
				}
				i++;
				
				if (i>=DepVec.size())
				{
					allLoaded=true;
				}
			}
			if (error)
			{
				abort();
			}
			//if everithing went right, we have all the files
			//loaded in DepVec & parsed.

			/**************************************************
			* this place is reserved for the semantic analysis*
			* implementation...				  *
			**************************************************/

			//now we should build three kind of files:
			//0:one interface for each personality declared
			//1:one class (Ego) for each personality declared
			//2:one class for each class declared

			String contents;
			Vector Imports;
			String Package;
			PersonalityFieldsVisitor pfv = new PersonalityFieldsVisitor();
			Vector diList, meList, inList, ncList, coList, fiList;
			ClassFieldsVisitor cfv = new ClassFieldsVisitor();
			Vector cinList, ccoList, cncList, cniList, cmeList, cfiList;
			for (i=0;i<DepVec.size();i++)
			{
				df=(DepLeaf)DepVec.elementAt(i);
				Imports = df.getImports();
				Package = df.getPackage();

				//is it a personality?
				if (df.getType() == "personality")
				{
					pd=(PersonalityDeclaration)df.getObject();
					pd.toEveryField(pfv);
					diList = pfv.getDiList();
					meList = pfv.getMeList();
					inList = pfv.getInList();
					ncList = pfv.getNcList();
					coList = pfv.getCoList();
					fiList = pfv.getFiList();
					oname=df.getIdent();
					contents = writePackage(Package) +
						writeImports(Imports) +
						"interface " + oname + "\n{\n" +
						makeUiDecl(meList) +
						makeDiDecl(diList) +
						"}";
					if(writeFile(oname + ".java", contents)==FAILED)
					{
						setError(WRITE, oname+".java");
						break;
					}
					//'till here we have the <personality> interface
					//now looking for the <personality>$Ego...
					contents = writePackage(Package) +
						writeImports(Imports) +
						"public class " + oname +"$Ego \n{\n" +
						makeInitializerBody(inList) +
						makeNestedClassBody(ncList) +
						makeConstructorBody(coList) +
						makeMethodBody(meList, diList, oname) +
						makeFieldBody(fiList) +
						"}";
					if(writeFile(oname+"$Ego.java", contents)==FAILED)
					{
						setError(WRITE, oname+"$Ego.java");
						break;
					}
					//<personality>$Ego done.
				}
				//it's a class.
				else
				{
					cd=(UnmodifiedClassDeclaration)df.getObject();
					cd.toEveryField(cfv);
					cinList = cfv.getInList();
					ccoList = cfv.getCoList();
					cncList = cfv.getNcList();
					cniList = cfv.getNiList();
					cmeList = cfv.getMeList();
					cfiList = cfv.getFiList();
					oname=df.getIdent();
					contents = writePackage(Package) +
						writeImports(Imports) +
						"public class " + oname +
						getExtends(cd) +
						getImplements(cd) +
						"\n{\n" +
						makeClassInitializer(cinList) +
						makeClassConstructor(ccoList) +
						makeClassNC(cncList) +
						makeClassNI(cniList) +
						//here we have to get DIs from personality names...
						makeClassMethod(cmeList, cd.getPersonified(), DepVec) +
						makeClassField(cfiList) +
						//how can we get to UIs from personality name ???
						makeClassUI(cd.getPersonified(), DepVec) +
						"}";
					if(writeFile(oname+".java", contents)==FAILED)
					{
						setError(WRITE, oname+".java");
						break;
					}
				}
			}
			if (error)
			{
				abort();
			}
			System.out.println("[done in " + (System.currentTimeMillis() - startingTime) + " milliseconds.]");
		}
		catch(ParseException e)
		{
			System.out.println("Error parsing... "+e.toString());
		}
	@)
}