Пример #1
0
        ////************************************************************************
        ////***  FUNCTION SearchSymbol
        ////*** ********************************************************************
        ////***  DESCRIPTION  :  Takes a file path to parse and validate symbol
        ////***                   labels which are then search for in the BST and
        ////***                   the output is dumped to the console
        ////***  INPUT ARGS   :  string filePath
        ////***  OUTPUT ARGS :  N/A
        ////***  IN/OUT ARGS   :  N/A
        ////***  RETURN :  N/A
        ////************************************************************************
        //public void SearchSymbols(string filePath)
        //{
        //    FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan);
        //    StreamReader streamReader = new StreamReader(fileStream);

        //    while (!streamReader.EndOfStream)
        //    {
        //        //get the line and trim whitespace
        //        string currentLine = streamReader.ReadLine().CompactAndTrimWhitespaces();

        //        bool discardLine = false;
        //        if (currentLine == "")
        //        {
        //            Chronicler.LogError("blank line, skipping: \"" + currentLine + "\"" + "\n", "Adding Symbol");
        //            discardLine = true;
        //        }

        //        if (discardLine !=true && ValidateLabel(currentLine, currentLine, "Seeking Symbol"))
        //        {
        //            StringBuilder stringBuilder = new StringBuilder();
        //            for (int i = 0; i < currentLine.Length && i < 6; i++)
        //                stringBuilder.Append(currentLine[i]);

        //            if (SearchSymbol(stringBuilder.ToString(), out Globals.Symbol? temp))
        //            {
        //                Chronicler.Write("Found symbol: ");
        //                temp.Value.Print(Chronicler.OutputOptions.IGNORE);
        //            }
        //            else
        //            {
        //                Chronicler.WriteLine("Symbol(" + currentLine + ") not found");
        //            }
        //        }
        //    }
        //    streamReader.Dispose();
        //    fileStream.Dispose();
        //}

        //************************************************************************
        //***  FUNCTION Print
        //*** ********************************************************************
        //***  DESCRIPTION  :  prints the current contents of the symbol table
        //***  INPUT ARGS   :  N/A
        //***  OUTPUT ARGS :  N/A
        //***  IN/OUT ARGS   :  N/A
        //***  RETURN :  N/A
        //************************************************************************
        public void Print(Chronicler.OutputOptions outputOptions = Chronicler.OutputOptions.IGNORE)
        {
            Chronicler.WriteLine("Symbol\tRFlag\tValue \tMFlag \tIFlag", outputOptions);
            Chronicler.WriteLine("=====================================", outputOptions);
            foreach (KeyValuePair <string, Globals.Symbol> keyValuePair in SymbolTableBST)
            {
                keyValuePair.Value.Print(outputOptions);
            }
        }
Пример #2
0
 //************************************************************************
 //***  FUNCTION Print
 //*** ********************************************************************
 //***  DESCRIPTION  :  prints the current contents of the symbol
 //***  INPUT ARGS   :  N/A
 //***  OUTPUT ARGS :  N/A
 //***  IN/OUT ARGS   :  N/A
 //***  RETURN :  N/A
 //************************************************************************
 public void Print(Chronicler.OutputOptions outputOptions, StreamWriter streamWriter = null)
 {
     if (streamWriter == null)
     {
         Chronicler.WriteLine(label + "\t" + RFlag + "\t" + value.ToString("X6") + "\t" + MFlag + "\t" + IFlag, outputOptions);
     }
     else
     {
         streamWriter.WriteLine(label + "\t" + RFlag + "\t" + value.ToString("X6") + "\t" + MFlag + "\t" + IFlag, outputOptions);
     }
 }
Пример #3
0
        static void DumpIntermidiateFile(string filePath, List <ExpresionLine> expresionLines, Globals.DataStructures dataStructures)
        {
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(filePath + ".tmp"))
            {
                Chronicler.HoldOutput();
                int curLinNum = 0;
                foreach (ExpresionLine expLine in expresionLines)
                {
                    if (expLine != null && expLine.OriginalLine != null && expLine.OriginalLine != "")
                    {
                        curLinNum = expLine.lineNumber;

                        file.Write(curLinNum.ToString() + "\t");
                        if (expLine.CommentLine != true)
                        {
                            file.Write(expLine.locationCounter.ToString("X6") + "\t");
                        }
                        file.Write(expLine.OriginalLine);
                        file.Write("\n");

                        Chronicler.Write(curLinNum.ToString() + "\t");
                        if (expLine.CommentLine != true)
                        {
                            Chronicler.Write(expLine.locationCounter.ToString("X6") + "\t");
                        }
                        Chronicler.WriteLine(expLine.OriginalLine);
                    }
                }
                foreach (LiteralTable.LiteralValue lv in dataStructures.literalTable.literalTable)
                {
                    curLinNum++;
                    file.Write(curLinNum.ToString() + "\t");
                    file.Write(lv.address.ToString("X6") + "\t");
                    file.Write("*" + "\t");
                    file.Write(lv.label);
                    file.Write("\n");

                    Chronicler.Write(curLinNum.ToString() + "\t");
                    Chronicler.Write(lv.address.ToString("X6") + "\t");
                    Chronicler.Write("*" + "\t");
                    Chronicler.WriteLine(lv.label);
                }
            }
            Chronicler.HoldOutput();
            dataStructures.symbolTable.Print();
            Chronicler.HoldOutput();
            dataStructures.literalTable.PrintTable();
        }
Пример #4
0
        //*************************************************************************
        //***  FUNCTION Main
        //*** *********************************************************************
        //***  DESCRIPTION  :  This is the main program driver
        //***  INPUT ARGS   :  string[] args
        //***  OUTPUT ARGS :  N/A
        //***  IN/OUT ARGS   :  N/A
        //***  RETURN :  N/A
        //*************************************************************************
        static void Main(string[] args)
        {
            Chronicler.WriteLine("Loading symbols...");
            Globals.DataStructures dataStructures = new Globals.DataStructures();

            string filePath;

            if (args.Length == 0)
            {
                Chronicler.WriteLine("Please enter the search file name: ");
                filePath = Console.ReadLine();
            }
            else
            {
                filePath = args[0];
            }
            Chronicler.HoldOutput();
            Chronicler.NewLine();
            Chronicler.NewLine();
            PassOne.Execute(dataStructures, out System.Collections.Generic.List <PassOne.ExpresionLine> expresionLines, "../../../" + filePath);
            //symbolTable.SearchSymbols("../../../" + filePath);
            Chronicler.HoldOutput();
            PassTwo.Execute(dataStructures, expresionLines, "../../../" + filePath);
        }
Пример #5
0
        //************************************************************************
        //***  FUNCTION PrintTable
        //*** ********************************************************************
        //***  DESCRIPTION  :  prints the current contents of the literal table
        //***  INPUT ARGS   :  N/A
        //***  OUTPUT ARGS :  N/A
        //***  IN/OUT ARGS   :  N/A
        //***  RETURN :  N/A
        //************************************************************************
        public void PrintTable(Chronicler.OutputOptions outputOptions = Chronicler.OutputOptions.IGNORE)
        {
            Chronicler.WriteLine("NAME\t\tVALUE\t\tLENGTH\tADDRESS", outputOptions);
            Chronicler.WriteLine("===============================================", outputOptions);
            StringBuilder sb = new StringBuilder("");

            foreach (LiteralValue lv in literalTable)
            {
                sb.Clear();
                for (int x = 0; x < (16 - lv.label.Length); x++)
                {
                    sb.Append(" ");
                }
                Chronicler.Write(lv.label + sb.ToString(), outputOptions);
                sb.Clear();
                for (int x = 0; x < (16 - lv.hexValue.Length); x++)
                {
                    sb.Append(" ");
                }
                Chronicler.Write(lv.hexValue + sb.ToString(), outputOptions);
                Chronicler.Write(lv.Length.ToString(), outputOptions);
                Chronicler.WriteLine("\t" + lv.address.ToString("X6"), outputOptions);
            }
        }
Пример #6
0
        public static void Execute(Globals.DataStructures dataStructures, List <PassOne.ExpresionLine> expresionLines, string filePath)
        {
            Chronicler.Write("\nPassTwo\n");
            foreach (PassOne.ExpresionLine expresionLine in expresionLines)
            {
                //evaluate expresion
                if (expresionLine.DeferExpresionResolutiontoPass2 && (expresionLine.instructionFormat == 3 || expresionLine.instructionFormat == 4))
                {
                    if (ExpresionHandler.ResolveF3F4Expresion(dataStructures, expresionLine.operandFieldAndComment, expresionLine.operandFieldAndComment, out expresionLine.expresionData) != true)
                    {
                        expresionLine.validLine = false;
                    }
                }

                //convert expresion format
                if (expresionLine.Opcode == "" && expresionLine.IsEQU != true && (expresionLine.instructionFormat == 3 || expresionLine.instructionFormat == 4))//don't redo work
                {
                    switch (expresionLine.expresionData.ExpresionType)
                    {
                    case Globals.ExpresionData.Contents.SYMBOL:
                        int?value = null;
                        if (expresionLine.expresionData.second.HasValue)
                        {
                            if (expresionLine.expresionData.operatorValue != null && expresionLine.expresionData.operatorValue == Globals.ExpresionData.Arithmetic.SUBTRACT)
                            {
                                value = (expresionLine.expresionData.first.Value.value) - expresionLine.expresionData.second.Value.value;
                            }
                            if (expresionLine.expresionData.operatorValue != null && expresionLine.expresionData.operatorValue == Globals.ExpresionData.Arithmetic.ADD)
                            {
                                value = (expresionLine.expresionData.first.Value.value) + expresionLine.expresionData.second.Value.value;
                            }
                        }
                        if (value.HasValue && expresionLine.instructionFormat == 4)
                        {
                            expresionLine.Opcode = value.Value.ToString("X5");
                        }
                        else if (value.HasValue && expresionLine.instructionFormat == 3)
                        {
                            expresionLine.Opcode = value.Value.ToString("X3");
                        }
                        break;

                    case Globals.ExpresionData.Contents.ERROR:
                        Chronicler.WriteLine("This is wrong for some reason, you should look at it:\n" + expresionLine.OriginalLine, Chronicler.OutputOptions.ERR);
                        break;

                    case Globals.ExpresionData.Contents.LITERAL:
                        if (expresionLine.expresionData.literal.isOldStyleLiteral != true)
                        {
                            expresionLine.Opcode = expresionLine.locationCounter.ToString("X6");
                        }
                        break;

                    case Globals.ExpresionData.Contents.EMPTY:
                        //consider break
                        break;
                    }
                }

                if (expresionLine.operationData.HasValue && expresionLine.operationData.Value.format == 2)
                {
                    string[] tmp = expresionLine.operandFieldAndComment.Split(";", StringSplitOptions.RemoveEmptyEntries);
                    if (tmp.Length > 0)
                    {
                        expresionLine.operandFieldAndComment = tmp[0];
                    }
                    string[] subStrs = expresionLine.operandFieldAndComment.Split(",", StringSplitOptions.RemoveEmptyEntries);
                    if (subStrs.Length == 1)
                    {
                        int val;
                        if (dataStructures.opcodeTable.RegisterTable.TryGetValue(subStrs[0].Trim(), out val))
                        {
                            expresionLine.Opcode = val.ToString();
                        }
                        else
                        {
                            Chronicler.LogError("failed parsing F2: " + expresionLine.OriginalLine);
                        }
                    }
                    else if (subStrs.Length == 2)
                    {
                        int val;
                        if (dataStructures.opcodeTable.RegisterTable.TryGetValue(subStrs[0].Trim(), out val))
                        {
                            expresionLine.Opcode = val.ToString() + "0";
                        }
                        else
                        {
                            Chronicler.LogError("failed parsing F2: " + expresionLine.OriginalLine);
                        }
                        if (dataStructures.opcodeTable.RegisterTable.TryGetValue(subStrs[1].Trim(), out val))
                        {
                            expresionLine.Opcode += val.ToString();
                        }
                        else
                        {
                            Chronicler.LogError("failed parsing F2: " + expresionLine.OriginalLine);
                        }
                    }
                    else
                    {
                        Chronicler.LogError("failed parsing F2, incorect term count: " + expresionLine.OriginalLine);
                    }
                }

                if (expresionLine.operationData.HasValue)
                {
                    expresionLine.Opcode = expresionLine.operationData.Value.code.ToString("X") + expresionLine.Opcode;
                }
            }


            DumpObjFile(filePath, expresionLines, dataStructures);
        }
Пример #7
0
        static void DumpObjFile(string filePath, List <PassOne.ExpresionLine> expresionLines, Globals.DataStructures dataStructures)
        {
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(filePath + ".txt"))
            {
                Chronicler.HoldOutput();
                int curLinNum = 0;
                foreach (PassOne.ExpresionLine expLine in expresionLines)
                {
                    if (expLine != null && expLine.OriginalLine != null && expLine.OriginalLine != "")
                    {
                        curLinNum = expLine.lineNumber;

                        file.Write(curLinNum.ToString() + "\t");
                        if (expLine.CommentLine != true)
                        {
                            file.Write(expLine.locationCounter.ToString("X6") + "\t");
                        }
                        file.Write(expLine.OriginalLine + "\t");
                        file.Write(expLine.Opcode);
                        file.Write("\n");

                        Chronicler.Write(curLinNum.ToString() + "\t");
                        if (expLine.CommentLine != true)
                        {
                            Chronicler.Write(expLine.locationCounter.ToString("X6") + "\t");
                        }
                        Chronicler.Write(expLine.OriginalLine + "\t");
                        Chronicler.WriteLine(expLine.Opcode);
                    }
                }
                foreach (LiteralTable.LiteralValue lv in dataStructures.literalTable.literalTable)
                {
                    curLinNum++;
                    file.Write(curLinNum.ToString() + "\t");
                    file.Write(lv.address.ToString("X6") + "\t");
                    file.Write("*" + "\t");
                    file.Write(lv.label);
                    file.Write("\n");

                    Chronicler.Write(curLinNum.ToString() + "\t");
                    Chronicler.Write(lv.address.ToString("X6") + "\t");
                    Chronicler.Write("*" + "\t");
                    Chronicler.WriteLine(lv.label);
                }
            }
            Chronicler.HoldOutput();
            dataStructures.symbolTable.Print();
            Chronicler.HoldOutput();
            dataStructures.literalTable.PrintTable();
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(filePath + ".obj"))
            {
                Chronicler.HoldOutput();
                string buffer     = "";
                string prevOpCode = "start";
                int    sl         = 0;
                if (expresionLines.Count > 0)
                {
                    sl = expresionLines[0].locationCounter;
                }
                Chronicler.WriteLine("Object code:");
                foreach (PassOne.ExpresionLine expLine in expresionLines)
                {
                    if (expLine != null && expLine.OriginalLine != null && expLine.OriginalLine != "")
                    {
                        if ((buffer.Length + expLine.Opcode.Length) > 60 || (prevOpCode == "" && buffer != ""))
                        {
                            //dump buffer contents
                            file.Write("T" + sl.ToString("X5") + buffer.Length.ToString("X2") + buffer);
                            file.Write("\n");
                            Chronicler.WriteLine("T" + buffer);

                            sl = expLine.locationCounter;
                            //clear buffer
                            buffer = "";
                        }

                        prevOpCode = expLine.Opcode; //check continuity
                        buffer    += expLine.Opcode; //add curr line to buffer
                    }
                }
                if (buffer != "")
                {
                    //dump buffer contents
                    file.Write("T" + sl.ToString("X5") + buffer.Length.ToString("X2") + buffer);
                    file.Write("\n");
                    Chronicler.WriteLine("T" + buffer);

                    //clear buffer
                    buffer = "";
                }
                foreach (LiteralTable.LiteralValue lv in dataStructures.literalTable.literalTable)
                {
                    if (buffer != "" && (buffer.Length + lv.hexValue.Length) > 60)
                    {
                        //dump buffer contents
                        file.Write("T" + sl.ToString("X5") + buffer.Length.ToString("X2") + buffer);
                        file.Write("\n");
                        Chronicler.WriteLine("T" + buffer);

                        //clear buffer
                        buffer = "";
                    }
                    buffer += lv.hexValue;//add curr line to buffer
                }
                if (buffer != "")
                {
                    //dump buffer contents
                    file.Write("T" + sl.ToString("X5") + buffer.Length.ToString("X2") + buffer);
                    file.Write("\n");
                    Chronicler.WriteLine("T" + buffer);

                    //clear buffer
                    buffer = "";
                }
                dataStructures.symbolTable.PrintFile(file);
                dataStructures.symbolTable.Print();
            }
        }
Пример #8
0
        //*******************************************************************************************
        //***  FUNCTION ParseTerms
        //*** ***************************************************************************************
        //***  DESCRIPTION  :  parses an arithmatic operation str to a symbol, or add a literal
        //***  INPUT ARGS   :  SymbolTable symbolTable, LiteralTable literalTable,
        //***                   string expresion, string currentLine
        //***  OUTPUT ARGS :  out Globals.Symbol? result
        //***  IN/OUT ARGS   :  N/A
        //***  RETURN :  bool rtnVal
        //*******************************************************************************************
        static bool ParseTerms(Globals.DataStructures dataStructures, string expresionString, string currentLine, out Globals.ExpresionData expresionData)
        {
            bool rtnVal = true;

            expresionString = expresionString.Trim();
            expresionData   = new Globals.ExpresionData();

            Regex testForCommentOnlyLine = new Regex(@"^[\t ]*(;.*)$");
            Match commentOnlyLine        = testForCommentOnlyLine.Match(expresionString);

            if (commentOnlyLine.Success)
            {
                expresionData.comment = commentOnlyLine.Groups["$1"].Value;
                return(true);
            }

            string line = expresionString.Trim();

            if (rtnVal == true && (Regex.Match(line, @"^[\t ]{0,}(-{0,1}[\t ]{0,}[A-Za-z0-9]+).*$").Success != true))
            {
                rtnVal = false;
                Chronicler.LogError("Could not parse first(" + line + ") term in: " + currentLine, "parsing terms");
            }
            if (rtnVal == true && (Regex.Match(line, @"^[\t ]{0,}(-{0,1}[\t ]{0,}[A-Za-z0-9]+)[\t ]{0,}(([+-])[\t ]{0,}(-{0,1}[\t ]{0,}[A-Za-z0-9]+)){0,1}[\t ]{0,}(;.*){0,1}$").Success != true))
            {
                rtnVal = false;
                Chronicler.LogError("Couldn't parse second term in: " + currentLine, "parsing terms");
            }
            string first = "";
            string arithmaticOperator = "";
            string second             = "";

            if (rtnVal == true)
            {
                Match fullLine = (Regex.Match(line, @"^[\t ]{0,}(?<first>-{0,1}[\t ]{0,}[A-Za-z0-9]+)[\t ]{0,}(?<testTermCount>(?<operand>[+-])[\t ]{0,}(?<second>-{0,1}[\t ]{0,}[A-Za-z0-9]+)){0,1}[\t ]{0,}(;.*){0,1}$"));
                if (fullLine.Success != true)
                {
                    rtnVal = false;
                    Chronicler.WriteLine("Error parsing literal");
                }
                first = fullLine.Groups["first"].Value.Trim();
                arithmaticOperator = fullLine.Groups["operand"].Value.Trim();
                second             = fullLine.Groups["second"].Value.Trim();

                Regex stripWhiteSpace = new Regex(@"\s+");
                first = stripWhiteSpace.Replace(first, "");
                arithmaticOperator = stripWhiteSpace.Replace(arithmaticOperator, "");
                second             = stripWhiteSpace.Replace(second, "");
                if (second != "" && arithmaticOperator == "")
                {
                    rtnVal = false;
                }
            }
            if (rtnVal == true)
            {
                rtnVal = ParseTerm(dataStructures.symbolTable, first, out expresionData.first, currentLine);
                if (second != "")
                {
                    rtnVal = ParseTerm(dataStructures.symbolTable, second, out expresionData.second, currentLine);
                    if (expresionData.first.HasValue && expresionData.second.HasValue)
                    {
                        if (arithmaticOperator == "+")
                        {
                            expresionData.rflag         = Globals.Symbol.AddRFlags(expresionData.first.Value, expresionData.second.Value);
                            expresionData.operatorValue = Globals.ExpresionData.Arithmetic.ADD;
                        }
                        else if (arithmaticOperator == "-")
                        {
                            expresionData.rflag         = Globals.Symbol.SubtractRFlags(expresionData.first.Value, expresionData.second.Value);
                            expresionData.operatorValue = Globals.ExpresionData.Arithmetic.SUBTRACT;
                        }
                        else
                        {
                            rtnVal = false;
                            Chronicler.LogError("Invalid operator value for line: " + currentLine, "term arithmatic module");
                        }
                    }
                    else
                    {
                        Chronicler.LogError("Couldn't resolve symbols in artithmetic: " + currentLine, "term arithmatic module");
                    }
                    rtnVal = rtnVal == true?ParseTerm(dataStructures.symbolTable, second, out expresionData.second, currentLine) : false;
                }


                if (expresionData.first.HasValue && !expresionData.second.HasValue && second == "")
                {
                    expresionData.rflag = expresionData.first.Value.RFlag;
                }
            }
            return(rtnVal);
        }