Compiler.java

// Copyright © 2004-2006 University of Helsinki, Department of Computer Science

// Copyright © 2012 various contributors

// This software is released under GNU Lesser General Public License 2.1.

// The license text is at http://www.gnu.org/licenses/lgpl-2.1.html

package fi.helsinki.cs.titokone;

import fi.helsinki.cs.titokone.devices.DeviceNames;

import fi.helsinki.cs.ttk91.TTK91CompileException;

import java.util.Collections;

import java.util.*;

/**

 * This class knows everything about the relation between symbolic

 * code and binary code. It can transform a full source to binary or

 * one symbolic command to binary or vice versa. Empty out all compiler

 * commands and empty lines at the start

 * of round 2.

 */

public class Compiler {

    /**

     * This field contains the source code as a String array.

     */

    private String[] source;

    /**

     * This field holds the declared variables, labels and other

     * symbols. It acts as a pointer to the symbolTable Vector where

     * the actual data is stored.

     */

    private HashMap<String, Integer> symbols;

    /**

     * This field holds the invalid values to be introduced

     * (i.e. already used labels can't be re-used.

     */

    private HashMap<String, Integer> invalidLabels;

    /**

     * This field tells the next line to be checked.

     */

    private int nextLine;

    /**

     * This field holds all the valid symbols on a label.

     */

    /**

     * Maximum value of the EQU and DC.

     */

    /**

     * Minimum value of the EQU and DC.

     */

    /**

     * Maximum value of the Address.

     */

    /**

     * Minimum value of the Address.

     */

    /**

     * This field holds the value of Stdin if it was set with DEF command.

     */

    private String defStdin;

    /**

     * This field holds the value of Stdout if it was set with DEF command.

     */

    private String defStdout;

    /**

     * This field keeps track of whether we are in the first round of

     * compilation or the second. It is set by compile() and updated

     * by compileLine().

     */

    private boolean firstRound;

    /**

     * This field counts the number of actual command lines found

     * during the first round.

     */

    private int commandLineCount;

    /**

     * This array contains the code.  During the first round this

     * field holds the clean version of the code (stripped of

     * compiler commands like def, ds, dc etc.)

     */

    private Vector<String> code;

    /**

     * This field acts as a symboltable, it is a String array vector

     * where 1:st position holds the name of the symbol and the

     * second either it's value (label, equ) or the command (ds 10,

     * dc 10)

     */

    private Vector<String[]> symbolTable;

    /**

     * This array contains the data.

     */

    private String[] data;

    // Second Round

    /**

     * This field holds the Memoryline objects for the code. These

     * are passed to the Application constructor at the end of the

     * compile process, and are gathered during the second round from

     * first round commands in code-array

     */

    private MemoryLine[] codeMemoryLines;

    /**

     * This field holds the Memoryline objects for the data

     * area. Much like the code part, this is gathered during the

     * second round and passed to the Application when

     * getApplication() method is called.

     */

    private MemoryLine[] dataMemoryLines;

    /**

     * This value tells if all the lines are processed twice and

     * getApplication can be run.

     */

    private boolean compileFinished;

    /**

     * This field contains the CompileDebugger instance to inform of

     * any compilation happenings.

     */

    private CompileDebugger compileDebugger;

    /**

     * This field contains the SymbolicInterpreter instance to use as

     * part of the compilation.

     */

    private SymbolicInterpreter symbolicInterpreter;

    /*---------- Constructor ----------*/

    /**

     * This constructor sets up the class. It also initializes an

     * instance of CompileDebugger.

     */

    /**

     * This function initializes transforms a symbolic source code into an

     * application class. After this, call compileLine() to actually compile

     * the application one line at a time, and finally getApplication() to get

     * the finished application.

     *

     * @param source The symbolic source code to be compiled.

     */

    public void compile(String source) {

        }

    /**

     * This function goes through one line of the code. On the first

     * round, it gathers the symbols and their definitions to a

     * symbol table and conducts syntax-checking, on the second round

     * it transforms each command to its binary format. For the

     * transformations, the CompileConstants class is used. It calls

     * the private methods firstRoundProcess() and

     * secondRoundProcess() to do the actual work, if there is any to

     * do.  The transfer from first round of compilation to the

     * second is done automatically; during it,

     * initializeSecondRound() is called.

     *

     * @return A CompileInfo debug information object, describing

     *         what happened during the compilation of this line and whether

     *         this is the first or second round of compilation or null if

     *         there are no more lines left to process.

     * @throws TTK91CompileException If a) there is a syntax error

     *                               during the first round of checking (error code 101) or b) a

     *                               symbol is still undefined after the first round of compilation

     *                               is finished.

     */

    public CompileInfo compileLine() throws TTK91CompileException {

        CompileInfo info;

            } else {

            }

        } else {

            } else {

            }

        }

    }

    /**

     * This method returns the readily-compiled application if the

     * compilation is complete, or null otherwise.

     */

    public Application getApplication() throws IllegalStateException {

            }

            String[] tempSTLine;

            String symbolName;

            int symbolValue;

            }

            }

            }

        } else {

                    "finished " +

                    "yet.").toString());

        }

    }

    /**

     * This function transforms a binary command number to a MemoryLine

     * containing both the binary and the symbolic command corresponding

     * to it.

     *

     * @param binary The command to be translated as binary.

     * @return A MemoryLine instance containing both the information

     *         about the symbolic command and the binary version of it.

     */

    public MemoryLine getSymbolicAndBinary(int binary) {

    }

    /**

     * This function transforms a MemoryLine containing only the binary

     * command to a MemoryLine containing both the binary and the

     * symbolic command corresponding to it.

     *

     * @param binaryOnly A MemoryLine containing the binary only of the

     *                   command to be translated as binary. If the MemoryLine contains

     *                   both, the pre-set symbolic value is ignored.

     * @return A MemoryLine instance containing both the information

     *         about the symbolic command and the binary version of it.

     */

    public MemoryLine getSymbolicAndBinary(MemoryLine binaryOnly) {

                bi.binaryToString(binaryOnly.getBinary()));

    }

    /**

     * This function gathers new symbol information from the given line

     * and checks its syntax. If a data reservation is detected, the

     * dataAreaSize is incremented accordingly. If the line contains

     * an actual command, commandLineCount is incremented.

     *

     * @param line The line of code to process.

     * @return A CompileInfo object describing what was done, or null if

     *         the first round has been completed. This will be the sign for

     *         the compiler to prepare for the second round and start it.

     */

    private CompileInfo firstRoundProcess(String line) throws TTK91CompileException {

        String[] lineTemp;

        String[] commentParameters;

        /*

                    The method first tries to parse a compilercommand (equ, dc, ds, def) from the line. If

                    succesfull then Check whether name is valid and value correct.

                    */

        try {

            // compiler command

                // not a valid label

                        (lineTemp[0].equalsIgnoreCase("stdin") ||

                                lineTemp[0].equalsIgnoreCase("stdout"))

                )) {

                }

            }

                // not a valid label;

            } else {

                    try {

                                "DS.").toString();

                                "DS.").toString();

                    }

                }

                        try {

                                    "DC.").toString();

                                    "DC.").toString();

                        }

                    }

                }

                                symbolTableEntry.clone());

                    } else {

                    }

                    try {

                                "EQU.").toString();

                                "EQU.").toString();

                    }

                            commentParameters).toString();

                }

                                lineTemp[2];

                                symbolTableEntry.clone()

                        );

                    } else {

                                lineTemp[2];

                    }

                            lineTemp[0]).toString();

                }

                                lineTemp[2];

                                symbolTableEntry.clone());

                    } else {

                                lineTemp[2];

                    }

                            lineTemp[0]).toString();

                }

                            lineTemp[0].equals("stdout")) {

                        } else {

                        }

                                commentParameters).toString();

                    } else {

                                "operation.").toString();

                    }

                }

            }

            /*

                            This means that line is not a valid compiler command. Now we try to parse a valid ttk91-command

                            from it. ParseLine return line as an array with label in position 0, opcode in 1, first register in

                            2, addressingmode in 3, address in 4 and other register in position 5.

                            However that is not all there is to it. Once a label is introduced it becomes unusable and

                            cannot be defined twice, and address part must be within the limits.

                            Address can be either a variable or a number and that must be noticed also.

                            */

                // line empty;

            } else {

                    // label found

                        // not a valid label

                    } else {

                                    (code.size() - 1);

                                    symbolTableEntry.clone());

                        } else {

                                    (code.size() - 1);

                        }

                                code.size() - 1);

                    }

                }

                try {

                    }

                    // variable used

                                        Integer(symbolTable.size()));

                            } else {

                                // predefined word (halt etc) was used

                                        new Integer(symbolTable.size()));

                                        (Integer) invalidLabels.get(lineTemp[4]);

                            }

                        }

                    }

                            "{1}.",

                            commentParameters).toString();

                } else {

                                lineTemp[4]).toString();

                    } else {

                                    lineTemp[0]).toString();

                        }

                    }

                }

            }

    }

    /**

     * This method initializes the code and data area arrays for the

     * second round processing according to the dataAreaSize and

     * commandLineCount variables. It also resets the StringTokenizer

     * by calling tokenize(). Before entering the second round we

     * must clear all the empty lines like compiler-codes

     * (pseudo-codes) and lines with nothing but comments.

     */

    private CompileInfo initializeSecondRound() {

        // copy the code.

        }

        String[] lineTemp;

        // calculate the size of data-area

                "Initializing the second  round of compilation.").toString());

                } else {

                    }

                }

            }

        }

        // update variable values to symbolTable

                    // Allaolevat rivit puukotti Jari S. 12.11.2005, sillä

                    // taulukoiden symboliarvot olivat syvältä!

                    // Ei vakuuttavasti testattu ja muutos arvaus, joka

                    // tehty tuntematta luokan toimintaa juurikaan!

                    //++nextMemorySlot;

                    }

                } else {

                        } else {

                        }

                    }

                }

            }

        }

        // make new SymbolTable

        }

        // prepare for the second round.

    }

    /**

     * This function transforms any commands to binary and stores both

     * forms in the code array, or sets any initial data values in the

     * data array. It uses CompileConstants as its aid.

     *

     * @param line The line of code to process.

     * @return A CompileInfo object describing what was done, or

     *         null if the second round and thus the compilation has been

     *         completed.

     */

    private CompileInfo secondRoundProcess(String line) throws TTK91CompileException {

                "Second round of compilation.").toString());

        int lineAsBinary;

        String comment;

        String[] symbolTableEntry;

            try {

                }

        }

                lineTemp[2],

                lineTemp[3],

                address,

                lineTemp[5]);

    }

    /**

     * This method parses a String and tries to find a label, opCode

     * and all the other parts of a Command line.

     *

     * @param symbolicOpcode Symbolic form of an operation code.

     */

    public String[] parseLine(String symbolicOpcode) throws TTK91CompileException {

        String comment;                // for exception

        String[] parsedLine;

        }

        // replaces 0xa0 -> 0x20 - Lauri 2004-09-23

            }

        }

        /* label */

                        new Message("invalid label {0}.",

                                wordTemp).toString()).toString();

            }

        }

        /* opcode */

                        new Message("invalid opcode {0}.",

                                opcode).toString()).toString();

            }

        } else {

                    new Message("invalid opcode {0}.",

                            opcode).toString()).toString();

        }

        /*first register*/

            // first register might end with a ','. Not when push Sp etc.

                    lineAsArray[lineAsArrayIndex].length() - 1) == ',') {

                        lineAsArray[lineAsArrayIndex].substring(0,

                                lineAsArray[lineAsArrayIndex].length() - 1)

                ) != -1) {

                            lineAsArray[lineAsArrayIndex].length() - 1);

                }

            } else {

                        lineAsArray[lineAsArrayIndex]) != -1) {

                }

            }

        }

        // Now supports addressing mode LOAD/STORE R1, (R2),

        // which is equal to LOAD/STORE R1, 0(R2).

        // 5.10.2004, Tom Bertell

                    (opcode.equalsIgnoreCase("store") || opcode.equalsIgnoreCase("load"))) {

            }

        }

        /* addressingMode */

                    lineAsArray[lineAsArrayIndex].charAt(0) == '@') {

                }

            } else {

            }

        }

        /*address and second register*/

                        lineAsArray[lineAsArrayIndex].indexOf("(")) {

                            new Message("second register expected."

                            ).toString()).toString();

                } else {

                                0, lineAsArray[lineAsArrayIndex].indexOf("(")

                        );

                    } else {

                                addressingMode.length(),

                                lineAsArray[lineAsArrayIndex].indexOf("(")

                        );

                    }

                            lineAsArray[lineAsArrayIndex].indexOf("(") + 1,

                            lineAsArray[lineAsArrayIndex].indexOf(")")

                    );

                                new Message("invalid register {0}.",

                                        secondRegister).toString()).toString();

                    }

                }

            } else {

                } else {

                }

                            lineAsArray[lineAsArrayIndex].indexOf(")") == -1) {

                                new Message("second register expected."

                                ).toString()).toString();

                    }

                            lineAsArray[lineAsArrayIndex].indexOf("(")) {

                                new Message("second register expected."

                                ).toString()).toString();

                    } else {

                                lineAsArray[lineAsArrayIndex].indexOf("(") + 1,

                                lineAsArray[lineAsArrayIndex].indexOf(")")

                        );

                    }

                }

            }

        }

        }

                    new Message("end of line expected.").toString()).toString();

        }

            // original line [LL]

            //          if (opcode.charAt(0) == 'j' || opcode.charAt(0) == 'J') {

            // Modified to support "NOT". It's here because it takes only one param like command "JUMP" [LL]

                // Opcode matches jneg/jzer/jpos or the negations

                // jnneg/jnzer/jnpos. // or opcode is 'NOT' [LL]

                        "((neg)|(zer)|(pos))") ||

                        opcode.toLowerCase().equals("not")) {

                                new Message("first register expected."

                                ).toString()).toString();

                    }

                }

                // modified to support "NOT". With "NOT" only one reg is expected, no addresses [LL]