/*
 * Varalloc.java -- variable allocation
 */

package varalloc;

import absyn.*;
import table.*;
import sym.*;
import absyn.*;
import sym.Sym;
import table.*;
import types.*;
import parse.*;

public class Varalloc {

	public static final int intByteSize = 4;
	public static final int boolByteSize = 4;
	public static final int refByteSize = 4;

	private Table globalTable;
	private boolean showVarAlloc;

	public Varalloc(Table t, boolean s) {
		globalTable = t;
		showVarAlloc = s;
	}

	public void allocVars(Absyn program) {
		/* compute access information for arguments of predefined procs */
		predefProcsEintragen();
		/* compute access information for arguments, parameters and local vars */
		offsetsEintragen(program);
		/* compute outgoing area sizes */
		outgoingSizesEintragen(program);
		/* show variable allocation if requested */
		if (showVarAlloc)
			showAllocation(program);
	}

	private void predefProcsEintragen() {

		// Alle Bibliotheks - Prozeduren
		ProcEntry readiPE = (ProcEntry) globalTable.lookup(Sym.newSym("readi"));
		ProcEntry clearAllPE = (ProcEntry) globalTable.lookup(Sym.newSym("clearAll"));
		ProcEntry timePE = (ProcEntry) globalTable.lookup(Sym.newSym("time"));
		ProcEntry mainPE = (ProcEntry) globalTable.lookup(Sym.newSym("main"));
		ProcEntry readcPE = (ProcEntry) globalTable.lookup(Sym.newSym("readc"));
		ProcEntry printcPE = (ProcEntry) globalTable.lookup(Sym
				.newSym("printc"));
		ProcEntry exitPE = (ProcEntry) globalTable.lookup(Sym.newSym("exit"));
		ProcEntry drawCirclePE = (ProcEntry) globalTable.lookup(Sym
				.newSym("drawCircle"));
		ProcEntry printiPE = (ProcEntry) globalTable.lookup(Sym
				.newSym("printi"));
		ProcEntry drawLinePE = (ProcEntry) globalTable.lookup(Sym
				.newSym("drawLine"));
		ProcEntry setPixelPE = (ProcEntry) globalTable.lookup(Sym
				.newSym("setPixel"));

		// Alle Parameter-Listen zu den Bibliotheks - Prozeduren
		ParamTypeList readiPTL = readiPE.paramTypes;
		ParamTypeList clearAllPTL = clearAllPE.paramTypes;
		ParamTypeList timePTL = timePE.paramTypes;
		ParamTypeList mainPTL = mainPE.paramTypes;
		ParamTypeList readcPTL = readcPE.paramTypes;
		ParamTypeList printcPTL = printcPE.paramTypes;
		ParamTypeList exitPTL = exitPE.paramTypes;
		ParamTypeList drawCirclePTL = drawCirclePE.paramTypes;
		ParamTypeList printiPTL = printiPE.paramTypes;
		ParamTypeList drawLinePTL = drawLinePE.paramTypes;
		ParamTypeList setPixelPTL = setPixelPE.paramTypes;

		// Eintragen der Offsets in die PTLs der Bibliotheksprozeduren

		readiPE.paramTypes = ptlOffsetsEintragen(readiPTL, -(readiPE.paramTypes.type.typeSize));
		timePE.paramTypes = ptlOffsetsEintragen(timePTL, -(timePE.paramTypes.type.typeSize));
		clearAllPE.paramTypes = ptlOffsetsEintragen(clearAllPTL, -(clearAllPE.paramTypes.type.typeSize));
		readcPE.paramTypes = ptlOffsetsEintragen(readcPTL, -(readcPE.paramTypes.type.typeSize));
		printcPE.paramTypes = ptlOffsetsEintragen(printcPTL, -(printcPE.paramTypes.type.typeSize));
		drawCirclePE.paramTypes = ptlOffsetsEintragen(drawCirclePTL, -(drawCirclePE.paramTypes.type.typeSize));
		printiPE.paramTypes = ptlOffsetsEintragen(printiPTL, -(printiPE.paramTypes.type.typeSize));
		drawLinePE.paramTypes = ptlOffsetsEintragen(drawLinePTL, -(drawLinePE.paramTypes.type.typeSize));
		setPixelPE.paramTypes = ptlOffsetsEintragen(setPixelPTL, -(drawCirclePE.paramTypes.type.typeSize));


		//Eintragen der Größe des eingehenden Bereichs für die Bib.-Procs
		readiPE.groeßeEingehenderBereich = berechnungEingehenderBereich(readiPE.paramTypes);
		timePE.groeßeEingehenderBereich = berechnungEingehenderBereich(timePE.paramTypes);
		clearAllPE.groeßeEingehenderBereich = berechnungEingehenderBereich(clearAllPE.paramTypes);
		readcPE.groeßeEingehenderBereich = berechnungEingehenderBereich(readcPE.paramTypes);
		printcPE.groeßeEingehenderBereich =	berechnungEingehenderBereich(printcPE.paramTypes);
		drawCirclePE.groeßeEingehenderBereich = berechnungEingehenderBereich(drawCirclePE.paramTypes);
		printiPE.groeßeEingehenderBereich = berechnungEingehenderBereich(printiPE.paramTypes);
		drawLinePE.groeßeEingehenderBereich =berechnungEingehenderBereich(drawLinePE.paramTypes);
		setPixelPE.groeßeEingehenderBereich = berechnungEingehenderBereich(setPixelPE.paramTypes);

		//System.out.println("\nSetpixel Params: " );
//		setPixelPE.paramTypes.show();
	}

	private ParamTypeList ptlOffsetsEintragen(ParamTypeList ptl, int os) {

		if (ptl.isEmpty == true)
		{
			return new ParamTypeList();
		}
		else
		{
			if (ptl.isRef)
			{
				os=os+4;
			}
			else
			{
				os = os + ptl.type.typeSize;
			}
			return new ParamTypeList(ptl, ptlOffsetsEintragen(ptl.next, os), os);
		}
	}


	private void offsetsEintragen(Absyn program) {
		DecList dl = (DecList) program;
		ProcEntry pe;
		ProcDec pDec;
		VarDec vDec;
		VarEntry vEnt;
		int os=0;

		while (dl.isEmpty == false )
		{
			if (dl.head instanceof ProcDec)
			{
				//Offsets der Parameter eintragen
				pDec = (ProcDec) dl.head;
				pe = (ProcEntry) globalTable.lookup(pDec.name);
				if(!pe.paramTypes.isEmpty)
				{
					pe.paramTypes = ptlOffsetsEintragen(pe.paramTypes, -pe.paramTypes.type.typeSize);
//					System.out.println(   pDec.name +   "  \n Parameter #1: " + pe.paramTypes.offsetSize +
//                            "\n Parameter #2: " + pe.paramTypes.next.offsetSize +
//                            "\n Parameter #3: " + pe.paramTypes.next.next.offsetSize);
				}

				//Offsets der lokalen Variablen eintragen.
				int counter;
				while (pDec.decls.isEmpty==false)
				{
					vDec = (VarDec) pDec.decls.head;
					vEnt = (VarEntry) pe.localTable.lookup(vDec.name);
					os = os + vEnt.type.typeSize;
					vEnt.offsetSize = os;
					pDec.decls = pDec.decls.tail;
				}
				//Groeße des LokVar Bereichs in os
				pe.groeßeLokVars=os;

				//Bestimmung der Groeße des eingehenden Bereichs.
				ParamTypeList tmpPTL = new ParamTypeList(pe.paramTypes);
				pe.groeßeEingehenderBereich = berechnungEingehenderBereich(tmpPTL);
			} //Eintragen der Offsets dieser Proc abgeschlossen

			os=0;
			dl=dl.tail;
		}
	}

	private int berechnungEingehenderBereich(ParamTypeList tmpPTL) {
		int zaehler=0;
		while (!tmpPTL.isEmpty)
		{
			zaehler++;
			tmpPTL = tmpPTL.next;
		}
		zaehler=zaehler*4;
		return zaehler;
	}

	private void outgoingSizesEintragen(Absyn program) {
		DecList dl = (DecList) program;
		ProcEntry pe;
		ProcDec pDec;
		VarDec vDec;
		VarEntry vEnt;

		while (dl.isEmpty == false )
		{
			if (dl.head instanceof ProcDec)
			{
				pDec = (ProcDec) dl.head;
				StmList stmList = pDec.body;
				Sym procName = pDec.name;
				int outSize=0;
				pe = (ProcEntry) globalTable.lookup(procName);

				while (stmList.isEmpty==false)
				{
					if (aufrufeZaehlen(stmList.head)>outSize)
					{
						outSize = aufrufeZaehlen(stmList.head);
					}
					stmList=stmList.tail;
				}
				pe.groeßeAusgehenderBereich=outSize;

			//	System.out.println(pDec.name.toString() + " outgoing : " + pe.groeßeAusgehenderBereich);
			    System.out.println(pDec.name.toString() + "   eingehend: "
			    	      + pe.groeßeEingehenderBereich + "   ausgehend: " + pe.groeßeAusgehenderBereich
			    	      + "    lokVars: " + pe.groeßeLokVars);
			}

			dl=dl.tail;
		}
	}

	private int aufrufeZaehlen(Stm stm) {
		if (stm instanceof CallStm)
		{
			CallStm cStm = (CallStm) stm;
			Sym procName = cStm.name;
			ProcEntry pEnt = (ProcEntry) globalTable.lookup(procName);
			pEnt.ruftAuf=true;
			return pEnt.groeßeEingehenderBereich;
		}
		else
		{
			return 0;
		}
	}

	private void showAllocation(Absyn program) {
		// TODO Auto-generated method stub

	}

}