Esempio n. 1
0
 public ExpresionData()
 {
     literal       = null;
     first         = null;
     operatorValue = null;
     second        = null;
     N             = false;
     I             = false;
     X             = false;
     B             = false;
     P             = false;
     E             = false;
 }
Esempio n. 2
0
        public static bool ParseNewStyleLiteral(string operand, out LiteralTable.LiteralValue literalValue, out string comment, string callingModule = "")
        {
            operand       = operand.Trim();
            callingModule = callingModule == "" ? "Parse New Style Literal" : callingModule;
            literalValue  = new LiteralTable.LiteralValue();
            comment       = "";
            if (operand[0] != '=')
            {
                Chronicler.LogError("New style literals must begin with '='", callingModule);
                return(false);
            }
            operand = operand.Substring(1, operand.Length - 1).Trim();
            bool rtnVal = ParseOldStyleLiteral(operand, out literalValue, out comment, callingModule);

            literalValue.isOldStyleLiteral = false;
            return(rtnVal);
        }
Esempio n. 3
0
        public static bool ParseOldStyleLiteral(string operand, out LiteralTable.LiteralValue literalValue, out string comment, string callingModule = "")
        {
            Regex literalRegex = new Regex(@"(^[\t ]*(?<literalCharID>[Cc])[\t ]*(?<literalValueString>'.*')[\t ]*(?<comment>;.*){0,1}$)|(^[\t ]*(?<literalCharIDx>[Xx])[\t ]*(?<literalValueStringx>'[a-fA-F0-9]*')[\t ]*(?<commentx>;.*){0,1}$)");
            Match match        = literalRegex.Match(operand);

            literalValue = new LiteralTable.LiteralValue();
            comment      = "";

            if (match.Success)//if we succeed, format it
            {
                literalValue.isOldStyleLiteral = true;
                if (match.Groups["literalCharID"].Value != "")
                {
                    literalValue.label = match.Groups["literalCharID"].Value + match.Groups["literalValueString"].Value;
                    comment            = match.Groups["comment"].Value;

                    StringBuilder sb = new StringBuilder(literalValue.label);
                    sb[0] = 'C';
                    literalValue.label = sb.ToString();

                    char[] tmpArr = literalValue.label.Substring(2, literalValue.label.Length - 3).ToCharArray();
                    literalValue.hexValue = Globals.CharArrToHexStr(tmpArr);
                    literalValue.dataType = LiteralTable.LiteralValue.DataType.CHAR;
                }
                else
                {
                    literalValue.label = match.Groups["literalCharIDx"].Value + match.Groups["literalValueStringx"].Value;
                    comment            = match.Groups["commentx"].Value;

                    literalValue.label    = literalValue.label.ToUpper();
                    literalValue.hexValue = literalValue.label.Substring(2, literalValue.label.Length - 3);
                    literalValue.hexValue = (literalValue.hexValue.Length % 2 == 1 ? "0" : "") + literalValue.hexValue;
                    literalValue.dataType = LiteralTable.LiteralValue.DataType.HEX;
                }

                return(true);
            }

            //if we fail try to figure out how and provide detailed feedback

            StringBuilder operandMutaion = new StringBuilder(operand.Trim());

            callingModule = callingModule == "" ? "Parse Old Style Literal" : callingModule;
            if (operandMutaion.Length == 0)
            {
                Chronicler.LogError("No literal value was given", callingModule);
            }
            operandMutaion[0] = char.ToUpper(operandMutaion[0]);
            bool isChar = false;

            if (operandMutaion[0] != 'C' && operandMutaion[0] == 'X')
            {
                Chronicler.LogError("The charachter '" + operandMutaion[0] + "' is not a valid literal identifier.  Valid identifiers are 'XxCc'.", callingModule);
                return(false);
            }
            else if (operandMutaion[0] == 'C')
            {
                isChar = true;
            }

            //remove whitespace
            while (operandMutaion.Length > 2 && char.IsWhiteSpace(operandMutaion[1]))
            {
                operandMutaion = operandMutaion.Remove(1, 1);
            }

            if (operandMutaion[1] != '\'')
            {
                Chronicler.LogError("Was expecting ''', but found '" + operandMutaion[1] + "'", callingModule);
                return(false);
            }

            int lastApos = -1;

            for (int i = 2; i < operandMutaion.Length; i++)
            {
                if (operandMutaion[i] == '\'')
                {
                    lastApos = i;
                }
            }

            if (lastApos == -1)
            {
                Chronicler.LogError("Was unable to find closing '''", callingModule);
                return(false);
            }
            else
            {
                string subStr = operandMutaion.ToString().Substring(2, lastApos - 2);
                if (!isChar)
                {
                    char?errorChar;
                    if (!validateHex(subStr, out errorChar) && errorChar != '\'')
                    {
                        Chronicler.LogError("Invalid Hex char detected in hex literal: " + errorChar.Value, callingModule);
                        return(false);
                    }
                    else
                    {
                        lastApos = -1;
                        for (int i = 2; i < operandMutaion.Length && lastApos == -1; i++)
                        {
                            if (operandMutaion[i] == '\'')
                            {
                                lastApos = i;
                            }
                        }
                    }
                }

                int lastComma = operandMutaion.Length;
                for (int i = lastApos; i < operandMutaion.Length && lastComma == operandMutaion.Length; i++)
                {
                    if (operandMutaion[i] == ';')
                    {
                        lastComma = i;
                    }
                }

                subStr = operandMutaion.ToString().Substring(lastApos, lastComma - lastApos);
                Chronicler.LogError("Parsing literal failed; was their garbage after the literal before the comment?  Found:(" + subStr + ")", callingModule);
                return(false);
            }
        }
        ////*******************************************************************************************
        ////***  FUNCTION ParseExpresionFile
        ////*** ***************************************************************************************
        ////***  DESCRIPTION  :  Parses the Expresion File
        ////***  INPUT ARGS   :  SymbolTable symbolTable, LiteralTable literalTable, string filePath
        ////***  OUTPUT ARGS :  N/A
        ////***  IN/OUT ARGS   :  N/A
        ////***  RETURN :  N/A
        ////*******************************************************************************************
        //public static void ParseExpresionFile(SymbolTable symbolTable, LiteralTable literalTable, string filePath)
        //{
        //    try
        //    {
        //        using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
        //        {

        //            try
        //            {
        //                using (StreamReader streamReader = new StreamReader(fileStream))
        //                {
        //                    int LineNumber = 1;
        //                    Chronicler.WriteLine("EXPRESION\tVALUE\tRELOCATABLE\tN-Bit\tI-Bit\tX-Bit");
        //                    while (!streamReader.EndOfStream)
        //                    {
        //                        //get the line and trim whitespace
        //                        string currentLine = streamReader.ReadLine().Trim();
        //                        if (ResolveF3F4Expresion(symbolTable, literalTable, currentLine, currentLine, out Globals.Symbol? symbol))
        //                        {
        //                            if (symbol != null)
        //                            {
        //                                StringBuilder sb = new StringBuilder("");
        //                                for (int x = 0; x < (16 - currentLine.Length); x++)
        //                                {
        //                                    sb.Append(" ");
        //                                }
        //                                Chronicler.Write(currentLine + sb.ToString());
        //                                Chronicler.Write(symbol.Value.value.ToString());
        //                                Chronicler.Write("\t" + ((symbol.Value.RFlag) ? "RELOCATABLE" : "ABSOLUTE"));
        //                                Chronicler.NewLine();
        //                            }
        //                        }
        //                        else
        //                        {
        //                            Chronicler.LogError("Line: \"" + LineNumber + "\" Skipping: \"" + currentLine + "\"", "Expresion File Parsing");
        //                        }
        //                        LineNumber++;
        //                    }
        //                    Chronicler.LogInfo("DONE loading symbols!");
        //                }
        //            }
        //            catch (IOException e)
        //            {
        //                Chronicler.WriteLine(e.Message);
        //                Chronicler.LogError("failed to open File: " + filePath);
        //            }
        //        }
        //    }
        //    catch (IOException e)
        //    {
        //        Chronicler.WriteLine(e.Message);
        //        Chronicler.LogError("failed to open File: " + filePath);
        //    }
        //}

        //*******************************************************************************************
        //***  FUNCTION ResolveF3F4Expresion
        //*** ***************************************************************************************
        //***  DESCRIPTION  :  Resolves an expresion and adds a literal or gets a symbol
        //***  INPUT ARGS   :  SymbolTable symbolTable, LiteralTable literalTable,
        //***                   string expresion, string currentLine
        //***  OUTPUT ARGS :  out Globals.Symbol? symbol
        //***  IN/OUT ARGS   :  N/A
        //***  RETURN :  bool rtnVal
        //*******************************************************************************************
        public static bool ResolveF3F4Expresion(Globals.DataStructures dataStructures, string expresionString, string currentLine, out Globals.ExpresionData expresionData, string callingModule = "ExpresionHandler")
        {
            expresionData = new Globals.ExpresionData();
            bool  rtnVal     = true;
            Regex testXValue = new Regex(@"(^[^=][^,;]*(?<x>,x|X){0,1}.*$)|(^[\t ]*=.*$)");
            bool  hasXValue  = testXValue.Match(expresionString).Groups["x"].Value != "";

            expresionString = expresionString.Trim();
            if (Parser.guessOperandType(expresionString) == Parser.OperandType.NEW_STYLE_LITERAL || Parser.guessOperandType(expresionString) == Parser.OperandType.OLD_STYLE_LITERAL)
            {
                Chronicler.LogInfo("Parsing as literal: " + expresionString);
                if (Parser.guessOperandType(expresionString) == Parser.OperandType.NEW_STYLE_LITERAL)
                {
                    LiteralTable.LiteralValue tmp = new LiteralTable.LiteralValue();
                    string comment = "";
                    Parser.ParseNewStyleLiteral(expresionString, out tmp, out comment, callingModule);
                    expresionData.literal = tmp;
                    dataStructures.literalTable.add(tmp);
                }
                else if (Parser.guessOperandType(expresionString) == Parser.OperandType.OLD_STYLE_LITERAL)
                {
                    LiteralTable.LiteralValue tmp = new LiteralTable.LiteralValue();
                    string comment = "";
                    Parser.ParseOldStyleLiteral(expresionString, out tmp, out comment, callingModule);
                    expresionData.literal = tmp;
                }
            }
            else if (expresionString.Length > 0 && expresionString[0] == '@')
            {
                expresionString = expresionString.Substring(1, expresionString.Length - 1);
                hasXValue       = testXValue.Match(expresionString).Groups["x"].Value != "";
                if (hasXValue != true)
                {
                    if (ParseTerms(dataStructures, expresionString, currentLine, out expresionData) != true)
                    {
                        rtnVal = false;
                    }
                    expresionData.N = true;
                    expresionData.I = false;
                }
                else
                {
                    rtnVal = false;
                    Chronicler.LogError("Can not apply both indirect adressing \n\tand x register indexing, skipping: \"" + currentLine + "\"", "Resovling Expresion");
                }
            }
            else if (expresionString.Length > 0 && expresionString[0] == '#')
            {
                expresionString = expresionString.Substring(1, expresionString.Length - 1);
                hasXValue       = testXValue.Match(expresionString).Groups["x"].Value != "";
                if (hasXValue != true)
                {
                    if (ParseTerms(dataStructures, expresionString, currentLine, out expresionData) != true)
                    {
                        rtnVal = false;
                    }
                    expresionData.N = false;
                    expresionData.I = false;
                }
                else
                {
                    rtnVal = false;
                    Chronicler.LogError("Can not apply both immediate adressing \n\tand x register indexing, skipping:\"" + currentLine + "\"", "Resovling Expresion");
                }
            }
            else if (hasXValue == true)
            {
                expresionString = testXValue.Replace(expresionString, "$2$4$5");
                if (ParseTerms(dataStructures, expresionString, currentLine, out expresionData) != true)
                {
                    rtnVal = false;
                }
                expresionData.N = true;
                expresionData.I = true;
                expresionData.X = true;
            }
            else
            {
                rtnVal = ParseTerms(dataStructures, expresionString, currentLine, out expresionData);
            }
            return(rtnVal);
        }