Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  InfoPrak2
Language: JAVA
Code:
package ToyStackEmulatorPkg;
import ToyStackComponentsPkg.Memory;
import java.io.*;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * ToyStackProgramReader liest ein LaWa-Programm ein
 * DIES IST EINE UNVOLLSTAENDIGE VORGABE,
 * DIE SIE (UND NUR SIE) ERGAENZEN SOLLEN!
 * 
 * Sie soll in das Paket ToyStackEmulatorPkg aus Versuch 1 eingefuegt werden 
 * @author Dimitri Krieger
 */
public class ToyStackProgramReader
{
    private int cc = 0, lc = 0;         // Spalten und Zeilen
    private String line;                // untersuchte Zeile
    private ToyStackEmulator toyStack;  // ToyStack-Emulator
    protected String filename;          // Dateiname
    private short pos = 0;              // die Position im Speicher, an der -
                              // der Befehl oder die Konstante eingefuegt wird
  // ResultCode als Boolsches Ergebnis
    enum ResultCode {
         known ,
         unknown,
         error,
         endOfProgram
    };
  
    // Hilfsfunktion zur Fehlerausgabe
    private void printErrorLine(String err)
    {
                System.err.println("Fehler beim Einlesen der Zeile " + lc
                               +", und Spalte "+cc +": " + err);
    }
  
    /**
     * dezimalkonstante
     * Scannt eine dezimale Konstante
     * @param val der Wert der Konstante
     * @return entsprechender Wert ResultCode
     */
    private ResultCode dezimalkonstante(int[] val)
    {
        
        String tok = line.substring(cc);
        StringTokenizer st = new StringTokenizer(tok);
        String token = st.nextToken();
        
        try {
            val[0] = Integer.parseInt(token);
        } catch (NumberFormatException e) {
            
            return (ResultCode.unknown);
        }
        
        return (ResultCode.known);
        
    }
    
    /**
     * hexalkonstante
     * Scannt eine hexadezimale Konstante
     * @param val der Wert der Konstante
     * @return entsprechender Wert ResultCode
     */
    private ResultCode hexalkonstante(int[] val)
    {
        int res=0, d;
        char ch;
        //ResultCode err;
        if (line.charAt(cc) != '0')
            return (ResultCode.unknown);
        cc++;
        if (line.charAt(cc) != 'x')
            return (ResultCode.unknown);
        cc++;
        ch = line.charAt(cc);
        while ((('0'<= ch)&&(ch<='9')) || (('a' <= ch)&&(ch <= 'f'))) {
            cc++;
            if (('0'<= ch)&&(ch<='9'))
              res = 16*res + (ch-'0');
            else
              res = 16*res + (ch-'a'+10);  
            ch = line.charAt(cc);
        }
        if (line.charAt(cc) != ' ')
            return (ResultCode.unknown);
        val[0] = res;
        return (ResultCode.known);
    }
    
    private ResultCode checkLineStart( char whatFirst )
    {
        
        ResultCode err = null;
        
        // Hier zu ergaenzen
        if( line.charAt( cc ) != whatFirst ) {
            
            System.err.println( "Die Zeile ist keine Befehlszeile!" );
            
            return ResultCode.unknown;
            
        }
        
        cc++;
        
        if( cc >= line.length() ) {
            
            System.err.println( "CC ausserhalb der Zeilenlänge!" );
            
            return ResultCode.error;
            
        }
        
        if( line.charAt( cc ) != ' ' ) {
            
            System.err.println( "Das zweite Zeichen ist kein Leerzeichen" );
            
            return ResultCode.error;
            
        }
        
        cc++;
        
        return ResultCode.known;
        
    }
    
    /**
     * befehlszeile()
     * Parsen einer Befehlszeile
     * Falls OK, wird Befehl in Speicher eingetragen
     * @return  Ergebnis des Parsers als ResultCode
     * 
     */
    private ResultCode befehlszeile()
    {
        
        ResultCode err = null;
        
        err = checkLineStart( '0' );
        
        if( err != ResultCode.known ) {
            
            return err;
            
        }
        
        int result[] = new int[ 1 ];
        
        err = hexalkonstante( result );
        
        
        
        if( err == ResultCode.known ) {
            
            System.out.println( "hexalkonstante: " + result[ 0 ] );
            
            Memory mem = toyStack.getMem();
            
            mem.put( pos, (short) result[ 0 ] );
            
        }
        
        pos++;
        
        return( err );
        
    }
  
    /**
     * konstantenzeile
     * Liest Konstante ein
     * falls ok, trägt Konstante in Speicher ein
     * @return  Ergebniscode des Parsens der Konstante
     */
    private ResultCode konstantenzeile()
    {
        ResultCode err = null;
        
        err = checkLineStart( '1' );
        
        if( err != ResultCode.known ) {
            
            return err;
            
        }
        
        int result[] = new int[ 1 ];
        
        err = dezimalkonstante( result );
        
        if( err == ResultCode.known ) {
            
            System.out.println( "dez.konstante: " + result[ 0 ] );
            
            Memory horst = toyStack.getMem();
            
            horst.put( pos, (short) result[ 0 ] );
            
        }
        
        pos++;
        
        return( err );
    }
  
    /**
     * variablenzeile
     * Liest Zeile, mit der ein Variablenbereich angelegt wird
     * falls ok, reserviert entsprechend viel Speicher
     * @return  Ergebniscode des Parsens der Variablendeklaration
     */
    private ResultCode variablenzeile() {
        // Hier zu ergaenzen
        ResultCode err = null;
        
        err = checkLineStart( '2' );
        
        if( err != ResultCode.known ) {
            
            return err;
            
        }
        
        int result[] = new int[ 1 ];
        
        err = dezimalkonstante( result );
        
        pos += result[ 0 ];
        
        return( err );
        
    }

    /**
     * ladeanweisung
     * Parst eine Ladeanweisung
     * falls ok, aendert pos
     * @return  Ergebniscode des Parsens der Konstante
     */
    private ResultCode ladeanweisung() {
        // Hier zu ergaenzen
        
        ResultCode err = null;
        
        err = checkLineStart( '3' );
        
        if( err != ResultCode.known ) {
            
            return err;
            
        }
        
        int result[] = new int[ 1 ];
        
        err = dezimalkonstante( result );
        
        pos = (short) result[ 0 ];
        
        return( err );        
    }
  
    /**
     * kommentarzeile
     * @return  ueberliest alles in einer Kommentarzeile
     */
    private ResultCode kommentarzeile() {        
        System.out.println( "Das war eine Kommentarzeile." );       
        return(ResultCode.known);     
    }
    
    /**
     * Zeile
     * Parst eine Zeile der Programmdatei
     * ruft dazu nacheinander die "spezialisierten" parse-
     * Funktionen auf, bis eine erfolgreich, ein
     * Fehler gefunden wurde oder alle nicht erfolgreich 
     * ausgefuehrt wurden
     * @return Ergebnis des Parsens
     */
    private ResultCode zeile()
    {
        
        ResultCode err = null;
        
        char erstesZeichen = line.charAt( 0 );
        
        // Unterscheidung der Zeilen
        
        switch( erstesZeichen ) {
            
            case '0':err = befehlszeile();break;
            case '1':err = konstantenzeile();break;
            case '2':err = variablenzeile();break;
            case '3':err = ladeanweisung();break;
            case '4':err = kommentarzeile();break;
            case '9':err = ResultCode.endOfProgram;break;
            default:err = ResultCode.error;break;
        }
        return( err );
    }
  
    /**
     * programRead
     * Die Hauptfunktion des ToyStackProgramReader
     * @return Ergebnis erfolgreich/nicht erfolgreich
     */
    public boolean programRead()
    {
        
        FileReader fileRead = null;
        BufferedReader bufRead;
        
        try {
            
            // Initialisierung fileRead
            fileRead = new FileReader( filename );
            
        } catch (FileNotFoundException ex) {
            
            Logger.getLogger(ToyStackProgramReader.class.getName()).log(Level.SEVERE, null, ex);
            
            System.out.println( "Datei error: " + ex.getMessage() );
            
            return false;
            // hier ergaenzen mit passender Reaktion auf Fehler FileNotFoundException
        }
        
         
        bufRead = new BufferedReader(fileRead);
        
        ResultCode err = null;
        
        do {
            
            cc = 0;
            
            lc++;
            
            try {
                line = bufRead.readLine();
                
                // Ergaenzen Sie hier den Aufruf zum Einlesen einer Zeile
                // in den String line mit passender Reaktion auf den Fehler
                // IOException und Reaktion auf Rueckgabe von null in line 
                // (end of file)
                // Ergaenzen Sie hier den Aufruf zum Parsen der Zeile
                // Rueckgabe des Resultats in err
            } catch (IOException ex) 
            {
                
                Logger.getLogger(ToyStackProgramReader.class.getName()).log(Level.SEVERE, null, ex);
                System.out.println( "file error: " + ex.getMessage() );
                return false;
                
            }
            
            if( line == null ) 
            {     
                break;    
            }
            
            err = zeile();
            
        } while ( err == ResultCode.known );
        if (err != ResultCode.endOfProgram) 
        {
            return false;
        }

        if( err != ResultCode.known && err != ResultCode.endOfProgram ) 
        {       
            printErrorLine( "  resultcode: " + err );       
        }       
        return true;
    }

    /**
     * Konstruktor 1
     * @param theToyStack   ToyStackEmulator
     */
    public ToyStackProgramReader(ToyStackEmulator theToyStack)
    {
        String programName;
        toyStack = theToyStack;
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Bitte geben sie den Dateinamen ein :");
        try {
            programName = in.readLine();
        } catch (IOException e) {
            return;
        }
        filename = programName;
        
        boolean ausgabe = programRead();
        
        System.err.println("ProgramRead Ergebnis: " + ausgabe);
                
    }
    /**
     * Konstruktor 2 mit Übergabe des Dateinamens
   *   wird für ToyStack mit GUI gebraucht
     * @param theToyStack   ToyStackEmulator
     * @param theProg       Programmname
     */
    public ToyStackProgramReader(ToyStackEmulator theToyStack, String theProg)
    {
        toyStack = theToyStack;
        filename = theProg;
    }
}     
Comments: