JavaPatternMatching/src/de/dhbwstuttgart/core/MyCompiler.java

// ino.module.MyCompiler.8569.package 
package de.dhbwstuttgart.core;
// ino.end


// ino.module.MyCompiler.8569.import 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;

import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.logger.Logger;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.parser.JavaParser;
import de.dhbwstuttgart.parser.Scanner;
import de.dhbwstuttgart.parser.JavaParser.yyException;
import de.dhbwstuttgart.syntaxtree.Class;
import de.dhbwstuttgart.syntaxtree.ClassBody;
import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.ImportDeclarations;
import de.dhbwstuttgart.syntaxtree.Method;
import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.misc.DeclId;
import de.dhbwstuttgart.syntaxtree.misc.UsedId;
import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar;
import de.dhbwstuttgart.syntaxtree.type.IMatchable;
import de.dhbwstuttgart.syntaxtree.type.ITypeContainer;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.ByteCodeResult;
import de.dhbwstuttgart.typeinference.FunNInterface;
import de.dhbwstuttgart.typeinference.FunVoidNInterface;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.ResultSet;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.ParserError;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;



// ino.class.MyCompiler.21258.declaration 
public class MyCompiler implements MyCompilerAPI
// ino.end
// ino.class.MyCompiler.21258.body
{
    // ino.attribute.NO_LINENUMBER.21262.decldescription type=line
    // PL: Der Zusammenhang zwischen paralist und vParaOrg muesste
    // noch geklaert werden 05-01-07
    // ino.end

    // ino.attribute.NO_LINENUMBER.21262.declaration 
    public static final int NO_LINENUMBER = -1;
    // ino.end
    
    // ino.attribute.codegenlog.21265.decldescription type=line
    // Logger
    // ino.end
    // ino.attribute.codegenlog.21265.declaration 
    //protected static Logger codegenlog = Logger.getLogger("codegen");
    // ino.end
    // ino.attribute.inferencelog.21268.declaration 
    protected static Logger inferencelog = Logger.getLogger(MyCompiler.class.getName());
    // ino.end
    // ino.attribute.parserlog.21271.declaration 
    //protected static Logger parserlog = Logger.getLogger("parser");
    // ino.end
    
    // ino.attribute.OutputDir.21274.declaration 
    protected String OutputDir = "";
    // ino.end
    
    
    // ino.attribute.m_AbstractSyntaxTree.21280.decldescription type=javadoc
    /**
     * Der abstrake Syntaxbaum
     * <br/>Autor: J�rg B�uerle
     */
    // ino.end
    // ino.attribute.m_AbstractSyntaxTree.21280.declaration 
    private Menge<SourceFile> m_AbstractSyntaxTree = new Menge<SourceFile>();
    // ino.end
    
    // ino.method.MyCompiler.21283.defdescription type=javadoc
    /**
     * Author: J�rg B�uerle<br/>
     * Der private Konstruktor. Es soll von au�en kein Compiler angelegt werden
     * k�nnen, sondern nur eine API zur Verf�gung gestellt werden.
     * @param logger Konfiguration für Debug Ausgabe TODO
     */
    // ino.end
    // ino.method.MyCompiler.21283.definition 
    private MyCompiler()
    // ino.end
    // ino.method.MyCompiler.21283.body 
    {
        this.init();
    }
    // ino.end
    
    // ino.method.getAPI.21286.defdescription type=javadoc
    /**
     * Author: Jörg Bäuerle<br/>
     * Stellt eine neue Instanz der CompilerAPI zur Verf�gung.
     * Diese Methode sollte von der IDE aus aufgerufen werden,
     * um eine Quellcode-Datei zu kompilieren.
     * @return Die Compiler-API
     */
    // ino.end
    // ino.method.getAPI.21286.definition 
    public static MyCompilerAPI getAPI(LoggerConfiguration loggerConfig)
    // ino.end
    // ino.method.getAPI.21286.body 
    {
    	Logger.setStandardConfiguration(loggerConfig);
        return new MyCompiler();
    }
    // ino.end
    
    public Menge<Pair> testPair = null;
    
    // ino.method.wandleGeneric2RefType.21289.defdescription type=javadoc
    /**
     * Author: Thomas Ott<br/>
     * Ersetzt in der Superklassenparameterliste einer Klasse, diejenigen
     * <code>GenericTypeVars</code>, zu denen es eine Klasse gibt, die gleich hei�t.
     * Beim Parsen werden n�mlich vom Jay nur GenericTypeVars erzeugt und keine
     * RefTypes. Dies wird durch diese Methode nachgeholt.<br/>
     * Bsp.: class JoergsTolleKlasse<A> extends MartinsSuperklasse<Integer, B>
     * <br/>Wie man an diesem Beispiel sieht, kann nur eine Superklasse instantiierte
     * Typvariablen zwischen den eckigen Klammern stehen haben, nicht jedoch die       
     * abgeleitete Klasse.
     * 
     * @param className Klassenname der aktuell betrachteten Klasse
     * @param Parameter Parameter der Superklasse
     * @param KlassenVektor
     
    // ino.end
    // ino.method.wandleGeneric2RefType.21289.definition 
    public static void wandleGeneric2RefType(Menge<Type> Parameter, Menge<Class> KlassenVektor )
    // ino.end
    // ino.method.wandleGeneric2RefType.21289.body 
    {
        //wandleGeneric2RefType SOLLTE NICHT NUR FUER LISTEN
        //VON TYPEN FUNKTIONIEREN PL 05-01-19
        // otth: GenericTypeVar in Superklassenparameterlisten in RefTypes mit Parameterlsite = NULL umwandeln,
        //       falls: f�r GenericTypeVar existiert eine gleichnamige Klasse
	   	if(Parameter == null) return;
    	
            for( int i = 0; i < Parameter.size();  i++)
            {
                Type TempParameter = Parameter.elementAt(i);
                inferencelog.debug("Nr. des Parameters: " + i);
        
                // an dieser Stelle: Parametername
                if ( TempParameter instanceof GenericTypeVar)
                {
                    inferencelog.debug("Generic, WANDLE: " + TempParameter.getName());
                    // existiert f�r GenericTypeVar eine deklarierte Klasse
                    for( int k = 0; k < KlassenVektor.size();  k++)
                    {
                        if( KlassenVektor.elementAt(k).getSimpleName().equals(TempParameter.getSimpleName()) )
                        {
                            // Klasse existiert, darf aber keine Parameterliste in der Definition haben
                            if( KlassenVektor.elementAt(k).get_ParaList().size() == 0 )
                            {
                                RefType RNeu = new RefType( TempParameter.getName().toString(), null,TempParameter.getOffset());
                                inferencelog.debug( "Vorher: " + Parameter );
                                // i-te Stelle ersetzen
                                Parameter.set( i, RNeu );
                                inferencelog.debug( "GenericTypeVar " + TempParameter.getName() + " umwandeln..." );                                
                                inferencelog.debug( "Nachher: " + Parameter );
                            }
                            else
                            {
                                //parserlog.error( "SEMANTIK-CHECK-FEHLER: Parameter " + TempParameter.getName() + " muss weitere Parameter besitzen (laut Klassendefinition)" );
                                //FIXME Throw exception instead of simple exit
                                System.exit( 1 );
                            }
                        }
                        else {
                           inferencelog.debug("Ist echter Generic, wird nicht ersetzt!");
                        }
                    } // end for
                }  // end if
                else 
                {
                    inferencelog.debug("Nicht Generic, WANDLE nicht: " + TempParameter.getName());
                    // RefType --> u.U. rekursiv weiterwandeln
                    if(TempParameter instanceof RefType)
                    {
	                    RefType R = (RefType)TempParameter;
	                    if( R.get_ParaList() != null )
	                        wandleGeneric2RefType( R.get_ParaList(), KlassenVektor );
                    }
                    else if(TempParameter instanceof ITypeContainer)
                    {
                    	Type T = ((ITypeContainer)TempParameter).getContainedType();
                    	if(T instanceof RefType)
                    	{
                    		RefType R = (RefType)T;
     	                    if( R.get_ParaList() != null )
     	                        wandleGeneric2RefType( R.get_ParaList(), KlassenVektor );
                    	}
                    }
                    else
                    { 
                        inferencelog.error("Internal Error"); 
                        System.exit( 1 ); 
                    }
                }
            }    //end for
    }    //end wandleGeneric2RefType
    // ino.end
    */
    
    
    // ino.method.parse.21292.defdescription type=javadoc
    /**
     * Parst den Quellcode und baut den abstrakten Syntaxbaum auf. Danach wird
     * automatisch der von Thomas Ott implementierte Algorithmus                       
     * <code>NewTVar(jclass)</code> (siehe Algorithmus 5.17 TRProg, Martin Pl�micke)   
     * aufgerufen.
     * <br/>Author: J�rg B�uerle
     * @param reader
     * @throws IOException
     * @throws JavaParser.yyException
     */
    // ino.end
    // ino.method.parse.21292.definition 
    private void parse_backup(Reader reader)
    throws IOException, JavaParser.yyException
    // ino.end
    // ino.method.parse.21292.body 
    {
    	/*
        parserlog.info("#########################################");
        parserlog.info("# Parsen - START                        #");
        parserlog.info("#########################################\n");
    
        //////////////////////////////////////
        // Alte Daten l�schen:
        //////////////////////////////////////
        m_AbstractSyntaxTree = null;
    
        //////////////////////////////////////
        // Scanner und Parser erzeugen:
        //////////////////////////////////////
        Scanner scanner = new Scanner(reader);
        JavaParser parser = new JavaParser();
        
        //////////////////////////////////////
        // Parsen ==> Ergebnis: srcFile = Abstrakter Syntaxbaum
        //////////////////////////////////////
        SourceFile  srcFile = (SourceFile) parser.yyparse( scanner );
        this.testPair = parser.testPair;
        
        parserlog.info( "Parsen war erfolgreich!\n");
    
    //PL 05-07-31 verschoben nach SourceFile.java in Methode typeReconstruction
        // otth: TypePlaceholders in Superklassenparameterlisten in RefTypes mit Parameterlsite = NULL umwandeln,
        // falls: f�r TypePlaceholder existiert eine gleichnamige Klasse
        // Superklasse suchen
        //for( int i = 0; i < srcFile.KlassenVektor.size(); i++ )
        //{
    //Class tempKlasse = (Class)srcFile.KlassenVektor.elementAt( i );
    
        //PL 05-07-30 ausgetauscht um alle Typedeklarationen zu wandeln
            // if( tempKlasse.superclassid != null && tempKlasse.get_ParaList() != null )
        // {
        //     // aktuelle Klasse hat Superklasse und Parameter
        //     Menge Parameter = tempKlasse.superclassid.get_ParaList();
        //     this.wandleGeneric2RefType(Parameter, srcFile.KlassenVektor );
            // }
        //wandleGeneric2RefType(tempKlasse.getContainedTypes(), srcFile.KlassenVektor );
    
        //}
    
        // otth: echte Konstruktoren von Methodendeklarationen ohne Typen unterscheiden
        if ( srcFile != null )
        {
            Class     tempKlasse    = null;
            ClassBody tempKlassBody = null;
            Menge<mycompiler.myclass.Field>    tempMengeFieldDecl;
            mycompiler.myclass.Field tempFieldDecl = null;
            String    strKlasse;
    
            for( int i = 0; i < srcFile.KlassenVektor.size(); i++ )
            {
                
                // Unterscheidung zwischen Class und Interfaces
                if (srcFile.KlassenVektor.elementAt(i) instanceof Class) {
                    tempKlasse = (Class)srcFile.KlassenVektor.elementAt( i );
                    tempKlassBody = tempKlasse.get_ClassBody();
                } else {
                    tempKlasse = null;
                    tempKlassBody = null;
                }
                    
                if ( tempKlassBody != null )
                {
                    strKlasse = tempKlasse.getName();
                    parserlog.debug("T->Felddeklarationen f�r die Klasse:" + strKlasse);
                    parserlog.debug(  "------------------------------------");
    
                    // Schleife �ber alle fielddeclarations
                    tempMengeFieldDecl = tempKlassBody.getFields();
                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
                    {
                    tempFieldDecl = tempMengeFieldDecl.elementAt(k);
                    if( tempFieldDecl instanceof Constructor )
                    {
                        //parserlog.debug("T->Konstruktor: " + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - ReturnType: " + tempFieldDecl.getTypeName());
    
                        // pr�fen, ob Construktorname == Klassenname - falls nein: Construktor in Methode umwandeln !!!
                        String strConstName = ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name(); // Konstruktorname
                        if ( !strConstName.equals( strKlasse ) )
                        {
                        // Element k durch neues ersetzen!
    
                        Method Methode     = new Method();
                        Method Konstruktor = (Constructor)tempFieldDecl;
    
                        // Elementweise vom Konstruktor in die Methode kopieren
                        Methode.set_Block( Konstruktor.get_Block() );
                        Methode.setParameterList( Konstruktor.getParameterList() );
                        Methode.set_ExceptionList( Konstruktor.get_ExceptionList() );
                        Methode.setReturnType( Konstruktor.getReturnType() );
                        Methode.setDeclIdMenge( Konstruktor.getDeclIdMenge() );
                        // types_in_parameterlist wird wohl erst sp�ter und intern gef�llt
    
                        // R�ckgabetyp = Objekt der Klasse 'TypePlaceholder'
    
                        // #JB# 31.03.2005
                        // ###########################################################
                        Methode.setReturnType(TypePlaceholder.fresh(Methode));
                        //Methode.setReturnType( new TypePlaceholder("###NEU###") );
                        // ###########################################################
    
                        // Element an der Position k durch neues ersetzen!
                        tempMengeFieldDecl.setElementAt( Methode, k );
                        }
                    }
                    if( tempFieldDecl instanceof Method && !(tempFieldDecl instanceof Constructor) )
                    {
                        //parserlog.debug("T->Methode:     " + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - ReturnType: " + tempFieldDecl.getTypeName());
                    }
                    
                    }
    
                    // Debugg-Infos
                    parserlog.debug("");
                    parserlog.debug("T->NEUE Felddeklarationen f�r die Klasse:" + strKlasse);
                    parserlog.debug(  "-----------------------------------------");
                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
                    {
                       tempFieldDecl = tempMengeFieldDecl.elementAt(k);
                       //parserlog.debug("T->" + ((DeclId)tempFieldDecl.get_Name().elementAt(0)).get_Name() + " - Typ: " + tempFieldDecl + " - ReturnType: " + tempFieldDecl.getTypeName());
                    }
    
                    // otth: TypePlaceholders durchnummerieren mit A, B, ...
                    parserlog.debug("");
                    parserlog.debug("");
                    parserlog.debug("Suche TypePlaceholders in den FieldDecls:");
                    parserlog.debug(    "------------------------------------------");
    
                    ParameterList   tempParameterList;
                    Menge<FormalParameter>          tempVFktPara;
                    FormalParameter tempFP;
                    Method          tempMethod;
                    Type            tempReturn;
                    Type            tempType;
                    for( int k = 0; k < tempMengeFieldDecl.size(); k++ )
                    {
                        tempFieldDecl = tempMengeFieldDecl.elementAt(k);
                        tempMethod    = null;
    
                        if( tempFieldDecl instanceof Method )
                        {
                            tempMethod = (Method)tempFieldDecl;
                            tempReturn = tempMethod.getReturnType();
    
                            // Funktionen ohne definierten R�ckgabetyp suchen!!!
                            if( tempReturn instanceof TypePlaceholder )
                            {
                                // Methode mit nicht-definiertem R�ckgabetyp gefunden!
    
                                // #JB# 31.03.2005
                                // ###########################################################
                                // Wird bereits �ber fresh() gemacht!!
                                //tempReturn.setName( TypePlaceholder.makeNewName() );
                                // ###########################################################
                                parserlog.debug("");
                                parserlog.debug("Methode ohne Rueckgabetyp: " + tempMethod.get_Method_Name() + " --> " + tempReturn.getName());
                            }
                            else
                            {
                                parserlog.debug("");
                                parserlog.debug("Methode mit Rueckgabetyp / Konstruktor:  " + tempMethod.get_Method_Name());
                            }
    
                            // Methoden-Funktionsparameter durchsuchen
                            tempParameterList = tempMethod.getParameterList();
                            if ( tempParameterList != null )
                            {
                                tempVFktPara = tempParameterList.sc_get_Formalparalist();
                                for( int l = 0; l < tempVFktPara.size(); l++ )
                                {
                                    tempFP   = tempVFktPara.elementAt(l);
                                    tempType = tempFP.getType();
                                    if( tempType instanceof TypePlaceholder )
                                    {
                                        if( tempType != null )
                                        {
                                            // neuer Name berechnen
    
                                            // #JB# 31.03.2005
                                            // ###########################################################
                                            // Wird bereits �ber fresh() gemacht!!
                                            //tempType.setName( TypePlaceholder.makeNewName() );
                                            // ###########################################################
                                        }
                                    }
                                    parserlog.debug("");
                                    parserlog.debug("    Parameter: " + tempFP.get_Name() + " --> " + tempType.getName());
                                }
                            }
                            else
                            {
                                parserlog.debug("");
                                parserlog.debug("    Methode hat keine Parameter!");
                            }
                        }
                    }
                }    //end if
            }    //end for
        }    //end if
        m_AbstractSyntaxTree = srcFile;
    
        parserlog.info("#########################################");
        parserlog.info("# Parsen - ENDE                         #");
        parserlog.info("#########################################\n");
        */
    }   // end Methode parse()
    // ino.end
    
/////////////////////////////////////////////////////////////////////////////////////////////////   
//   Implementierte API-Methoden:
/////////////////////////////////////////////////////////////////////////////////////////////////
    // ino.method.init.21295.defdescription type=javadoc
    /**
     * Author: J�rg B�uerle<br/>
     * Initialisiert den Compiler
     */
    // ino.end
    // ino.method.init.21295.definition 
    public void init()
    // ino.end
    // ino.method.init.21295.body 
    {
        TypePlaceholder.deleteRegistry();  
        
        // Log4J fuer die Ausgabe vorbereiten
        //DOMConfigurator.configure("log4j.xml");
    }
    // ino.end

    // ino.method.parse.21298.defdescription type=javadoc
    /**
     * Author: J�rg B�uerle<br/>
     * Ruft die Parse-Methode.
     * @param file Die Quellcode-Datei
     * @throws FileNotFoundException Wenn die Quellcode-Datei nicht existiert.
     * @throws IOException Wenn was schief l�uft.
     * @throws JavaParser.yyException Wenn ein Fehler beim Parsen auftritt.
     */
    // ino.end
    // ino.method.parse.21298.definition 
    public SourceFile parse(File file)
    throws FileNotFoundException, IOException, JavaParser.yyException
    // ino.end
    // ino.method.parse.21298.body 
    {
        FileReader fr = new FileReader(file);
        SourceFile ret = this.parse2SyntaxTree(fr);
        this.m_AbstractSyntaxTree.add(ret);
        fr.close();
        return ret;
    }
    // ino.end
   
    // ino.method.typeReconstruction.21304.defdescription type=javadoc
    /**
     * Author: J�rg B�uerle<br/>
     * Ruft den Typrekonstruktionsalgorithmus auf.
     * @return Die Menge aller m�glichen Typkombinationen
     * @throws NullPointerException Wenn noch kein abstrakter Syntaxbaum vorhanden     
     * ist. @throws CTypeReconstructionException Wenn ein Fehler bei der               
     * Typrekonstruktion auftritt. 
     */
    // ino.end
    // ino.method.typeReconstruction.21304.definition 
    public Menge<TypeinferenceResultSet> typeReconstruction()
    throws NullPointerException, CTypeReconstructionException
    // ino.end
    // ino.method.typeReconstruction.21304.body 
    {
        if(m_AbstractSyntaxTree==null){
            throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
        }
        inferencelog.info("##########################################", Section.TYPEINFERENCE);
        inferencelog.info("# TypeReconstruction-Algorithmus - START #", Section.TYPEINFERENCE);
        inferencelog.info("##########################################\n", Section.TYPEINFERENCE);
        
        TypeAssumptions globalAssumptions = makeFunNAssumptions();
        Menge<TypeinferenceResultSet> result = new Menge<TypeinferenceResultSet>();
        for(SourceFile srcFile : m_AbstractSyntaxTree){
        	result.addAll(srcFile.typeReconstruction(globalAssumptions));
            
        }
        
        inferencelog.info("#########################################", Section.TYPEINFERENCE);
        inferencelog.info("# TypeReconstruction-Algorithmus - ENDE #", Section.TYPEINFERENCE);
        inferencelog.info("#########################################\n", Section.TYPEINFERENCE);
        
        return result;
    }
    // ino.end

    /**
     * Erstellt die FunN-Assumptions
     * Fun0-FunN (momentan für N = 6)
     * @return
     */
	private TypeAssumptions makeFunNAssumptions(){
		TypeAssumptions ret = new TypeAssumptions();
		
		//Basic Assumptions für die FunN Interfaces:
		//TODO: Hier mehr als Fun1-Fun5 implementieren
		for(int i = 0; i<6; i++){
			FunNInterface funN = new FunNInterface(i);
			ret.add(funN.getPublicFieldAssumptions());
		}
		for(int i = 0; i<6; i++){
			FunVoidNInterface funN = new FunVoidNInterface(i);
			ret.add(funN.getPublicFieldAssumptions());
		}
		
		
		return ret;
	}
    
    /**
     * Author: J�rg B�uerle<br/>
     * Generiert den Bytecode und das Class-File f�r den Syntaxbaum.
     * @throws NullPointerException Wenn noch kein abstrakter Syntaxbaum vorhanden     
     * ist. 
     
    @Override
    public Menge<ClassFile> codeGeneration(ResultSet result)
    throws NullPointerException, JVMCodeException
    {
        if(m_AbstractSyntaxTree==null){
            throw new NullPointerException("Es wurde noch kein Abstrakter Syntaxbaum erstellt!");
        }
        codegenlog.info("Beginn der Codegenerierung ...");
    
        Menge<ClassFile> ret = new Menge<ClassFile>();
        
        for(SourceFile sf : m_AbstractSyntaxTree){
        	ret.addAll(sf.codegen(result));
        }
    
        codegenlog.info("Codegenerierung beendet!");
		return ret;
    }*/
	

    // ino.method.main.21313.defdescription type=javadoc
    /**
     * Die Main-Funktion, �ber die der Compiler auch per Konsole gestartet
     * werden kann.
     * @param args Klassendatei
     */
    // ino.end
    // ino.method.main.21313.definition 
    public static void main(String[] args)
    // ino.end
    // ino.method.main.21313.body 
    {
        MyCompilerAPI compiler = MyCompiler.getAPI(new LoggerConfiguration());
        
        // Hier koennten ggf. Aenderungen der Ausgabeeinstellungen
        // (Debuginfos) vorgenommen werden -> LOG4J
    
        try {
        	compiler.parse(new File(args[0]));
        } catch (FileNotFoundException e) {
            System.err.println("Die Datei \""+args[0]+"\" konnte nicht gefunden werden.");
            System.exit(0);
        } catch (IOException e) {
            System.err.println("Fehler beim Parsen:");
            System.err.println(e);
            System.exit(0);
        } catch (yyException e) {
            System.err.println("Fehler beim Parsen:");
            System.err.println(e);
            System.exit(0);
        }
    
            /////////////////////////
            // Semantik-Check:
            /////////////////////////
    //          try {
    //                compiler.semanticCheck();
    //            } catch (NullPointerException e) {
    //                System.out.println("Fehler beim Aufrufen des Semantik-Checks:");
    //                System.out.println(e);
    //              System.exit(0);
    //            } catch (SCException e) {
    //                e.fehlerausgabe();
    //              System.exit(0);
    //            }
    
            /////////////////////////
            // Code-Generierung:
            /////////////////////////
            //compiler.codeGeneration();
        }
    // ino.end

    // ino.method.setOutputDir.21316.definition 
    public void setOutputDir(String dir)
    // ino.end
    // ino.method.setOutputDir.21316.body 
    {
        char c = dir.charAt(dir.length()-1);
        if (c != '/' & c != '\\') dir = dir + "/";
        OutputDir = dir;
        
        // Verzeichnis(se) ggf. anlegen
        File f = new File(dir);
        f.mkdirs();
    }
    // ino.end

    // ino.method.getOutputDir.21319.definition 
    public String getOutputDir()
    // ino.end
    // ino.method.getOutputDir.21319.body 
    {
        return OutputDir;
    }
    // ino.end
/*
    // ino.method.getFullyQualifiedNameFromClassname.21322.definition 
    public static String getFullyQualifiedNameFromClassname(String typ, ImportDeclarations declarations)
    // ino.end
    // ino.method.getFullyQualifiedNameFromClassname.21322.body 
    {
        String ret=null;
        // Es ist kein FullyQualifiedName => In den Imports die Klasse suchen
        for(int j=0;j<declarations.size();j++){
            UsedId impDecl=declarations.elementAt(j);
            if(impDecl.getSimpleName().equals(typ)){
                ret=(impDecl.getQualifiedName().toString());
                break;                          
            }
    
        }       
        return ret;
    }
    // ino.end
    */
    // ino.method.makeRefTypesFullyQualified.21325.defdescription type=javadoc
    /**
     * @author HOTI
     * Macht alle Referenzen auf Objekte zu fully qualified Names
     * p.ex Menge x;   => de.dhbwstuttgart.typeinference.Menge x;
     * @param containedTypes    Alle Typen, die die Klasse beinhaltet
     * @param name  Alle Klassen, die es in den BasicAssumptions und im                
     * AbstractSyntaxTree gibt @param declarations Alle Import-Declarations
     
    // ino.end
    // ino.method.makeRefTypesFullyQualified.21325.definition 
    public static void makeRefTypesFullyQualified(Menge<Type> containedTypes, ImportDeclarations declarations)
    // ino.end
    // ino.method.makeRefTypesFullyQualified.21325.body 
    {
        // HOTI 8.5.06 Anhand der ContainedTypes alle Variablen aendern
        for( int i = 0; i < containedTypes.size();  i++)
        {
            Type tempParameter = (Type)(containedTypes.elementAt(i));
            // Nat�rlich nur RefTypes updaten
            if(tempParameter instanceof RefType){
                RefType typ=(RefType)tempParameter;
                UsedId fullyQualifiedName=UsedId.createFromQualifiedName(typ.getTypeName(),typ.getOffset());
                // Kein FullyQualifiedName
                if(fullyQualifiedName.name.size()==1){
                    String newType=getFullyQualifiedNameFromClassname(typ.getSimpleName(),declarations); 
                    if(newType!=null){
                        typ.setName(newType);
                    }
    
                }
                if(typ.get_ParaList()!=null){
                    makeRefTypesFullyQualified(typ.get_ParaList(),declarations);
                }
            }
        }
    }
    // ino.end
    */
    /**
     * @author Arne Lüdtke
     * Ersetzt alle GTVs durch TPHs mit gleichem Namen. Arbeitet Rekursiv.
     * ACHTUNG: BACKDOOR CREATE!!! Nur für Testzwecke verwenden.
     * @param T - Typ, bei welchem die GTVs ersetzt werden sollen.
     */
    public static Type makeGenericTypeVars2TypePlaceHolders(Type T)
    {
    	if(T instanceof RefType)
    	{
    		RefType refT = (RefType)T;
    		if(refT.get_ParaList() != null)
    		{
    			Menge<Type> paras = refT.get_ParaList();
    			for(int i = 0; i<paras.size();i++)
    			{
    				Type tt = paras.elementAt(i);
    				if(tt instanceof GenericTypeVar)
    				{
    					GenericTypeVar gtv = (GenericTypeVar)tt;
    					paras.set(i,TypePlaceholder.backdoorCreate(gtv.getName().toString()));
    				}
    				else
    				{
    					makeGenericTypeVars2TypePlaceHolders(tt);
    				}
    			}
    		}
    	}
    	else if(T instanceof IMatchable)
    	{
    		Type TT = ((IMatchable)T).getMatchType();
    		makeGenericTypeVars2TypePlaceHolders(TT);
    	}
    	return T;
    }

    /**
     * Parst den Inhalt einer Datei zu einem Syntaxbaum.
     */
    private SourceFile parse2SyntaxTree(Reader fileContent) throws ParserError{
    
    	//StringReader reader = new StringReader(fileContent);
        //////////////////////////////////////
        // Scanner und Parser erzeugen:
        //////////////////////////////////////
        Scanner scanner = new Scanner(fileContent);
        JavaParser parser = new JavaParser();
        
        //////////////////////////////////////
        // Parsen ==> Ergebnis: srcFile
        //////////////////////////////////////
        SourceFile srcFile = null;
		try {
			srcFile = (SourceFile) parser.yyparse( scanner );
		} catch (IOException | yyException e) {
			e.printStackTrace();
			if(e instanceof yyException)throw new ParserError((yyException)e);
		}
		//////////////////////////////////////
		// Postprocessing:
		//////////////////////////////////////
		srcFile.parserPostProcessing(null); //Muss mit null aufgerufen werden.
		//Fertig:
    	return srcFile;
    }
    
    /**
     * Diese Funktion nimmt einen Menge von Dateinamen. Alle diese Dateien werden zu einem SyntaxBaum geparst.
     */
    public void parse(Menge<String> filenames) throws ParserError {
		
		for(String filename : filenames){
				StringBuffer fileData = new StringBuffer();
		        BufferedReader reader;
				try {
					reader = new BufferedReader(
					        new FileReader(filename));
				} catch (FileNotFoundException e) {
					throw new DebugException("Die Datei "+ filename+" konnte nicht gelesen werden.");
				}
		        char[] buf = new char[1024];
		        int numRead=0;
		        try {
					while((numRead=reader.read(buf)) != -1){
					    String readData = String.valueOf(buf, 0, numRead);
					    fileData.append(readData);
					}
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}

		        StringReader srcreader = new StringReader(fileData.toString());
		        //Den aus der Datei ausgelesenen Quellcode zu einem Syntaxbaum parsen:
		        this.m_AbstractSyntaxTree.add(parse2SyntaxTree(srcreader)); // Alle Dateien nacheinander hintereinander anhängen...
				
		}
		/*
		String gesamterSrc = "";
		//Hier werden alle übergebenen Dateinamen abgearbeitet:
		for(String filename : filenames){
			try {
			StringBuffer fileData = new StringBuffer();
	        BufferedReader reader = new BufferedReader(
	                new FileReader(filename));
	        char[] buf = new char[1024];
	        int numRead=0;
	        while((numRead=reader.read(buf)) != -1){
	            String readData = String.valueOf(buf, 0, numRead);
	            fileData.append(readData);
	        }
	        reader.close();
	        gesamterSrc += fileData.toString() + "\n"; // Alle Dateien nacheinander hintereinander anhängen...
			} catch (Exception e) {
				e.printStackTrace();
				throw new TypinferenzException("Die übergebenen Dateien konnten nicht zum Parsen eingelesen werden.");
			}
		}
		
		try {
			// und anschließend zum Parsen übergeben.
			this.parse(gesamterSrc.toString());
		} catch (Exception e) {
			e.printStackTrace();
			//throw new TypinferenzException("Fehler beim Parsen");
		}
		
	*/
	}

	@Override
	public SourceFile parse(String sourceCode) {
		SourceFile ret = this.parse2SyntaxTree(new StringReader(sourceCode));
		this.m_AbstractSyntaxTree.add(ret);
		return ret;
	}

	@Override
	public Menge<Menge<ByteCodeResult>> generateBytecode(TypeinferenceResultSet typeinferenceResult) {
		//SourceFile parsedFile = this.m_AbstractSyntaxTree.firstElement();
		//Class parsedClass = parsedFile.KlassenVektor.firstElement();
		Menge<Menge<ByteCodeResult>> ret = new Menge<>();
		for(SourceFile sf : this.m_AbstractSyntaxTree){
			ret.addAll(sf.generateBytecode(typeinferenceResult));
		}
		return ret;
	}
}
// ino.end