/*******************************************************************************
*** INSERT FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in a node and a string array. Goes and ***
*** tests each element in the array using the CheckIfValid functions created ***
*** below. If all are valid, each element is added to the node and inserted ***
*** into the Symbol Table. ***
********************************************************************************
*** INPUT ARGS: Node root, string[] v ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: Node root ***
********************************************************************************/
public Node_Sym insert(Node_Sym root, string sym, string val, bool r)
{
PassTwo p2 = new PassTwo();
if (root == null)
{
bool MFlag = false;
bool IFlag = true;
root = new Node_Sym();
root.symbol = p2.TrimOp(sym);
root.value = val;
root.rflag = r;
root.iflag = IFlag;
root.mflag = MFlag;
}
else
{
if (sym == root.symbol)
{
Console.WriteLine(ERR_MSG_3, sym);
root.mflag = true;
return(root);
}
else if (sym.CompareTo(root.symbol) < 0)
{
root.left = insert(root.left, sym, val, r);
}
else
{
root.right = insert(root.right, sym, val, r);
}
}
return(root);
}
/*******************************************************************************
*** INSERT FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in a symbol table and a string. Runs a ***
*** function that return an error message if an invalid expression. If null ***
*** then the Expression node is created and populated and returned. ***
********************************************************************************
*** INPUT ARGS: Node_Sym table, string ex ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: Node_Exp newNode ***
********************************************************************************/
public Node_Exp insert(Node_Sym table, string ex)
{
Node_Exp Expression = new Node_Exp();
Expression.expression = ex;
if (ex[0] != '=')
{
Expression.ERR_MSG = IfExpressionValid(table, ex);
if (Expression.ERR_MSG == null)
{
Expression.relocatable = retRel(table, ex);
Expression.value = retVal(table, ex);
if (ex[0] == '@')
{
Expression.N_bit = true;
}
else if (ex[0] == '#')
{
Expression.I_bit = true;
}
else if (ex[ex.Length - 2] == ',' && ex[ex.Length - 1] == 'X')
{
Expression.X_bit = true;
}
else
{
Expression.N_bit = true; Expression.I_bit = true;
}
}
else
{
Console.WriteLine(Expression.ERR_MSG);
}
}
else
{
Expression.N_bit = true;
Expression.I_bit = true;
Expression.X_bit = false;
}
return(Expression);
}
/*******************************************************************************
*** INSERT FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in a node. It views the symbol table in ***
*** order from left to right. ***
********************************************************************************
*** INPUT ARGS: Node root ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: null ***
********************************************************************************/
public Node_Sym view(Node_Sym root)
{
PassTwo p2 = new PassTwo();
if (root == null)
{
return(null);
}
else
{
view(root.left);
if (root.symbol != null)
{
Console.WriteLine("{0,-10} {1,-10} {2,-10} {3,-10} {4,-10}", p2.TrimOp(root.symbol), root.value, (root.rflag == true) ? 1 : 0, (root.mflag == true) ? 1 : 0, (root.iflag == true) ? 1 : 0);
}
view(root.right);
}
return(null);
}
/*******************************************************************************
*** SEARCH FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in a node and a string. It checks to ***
*** see if the passed in string is a valid symbol. It then tests to see if ***
*** the passed in value exists in the symbol table. If not an error message ***
*** is displayed informing the user. ***
********************************************************************************
*** INPUT ARGS: Node root, string v ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: Node root ***
********************************************************************************/
public Node_Sym search(Node_Sym root, string v)
{
PassTwo p2 = new PassTwo();
v = p2.TrimOp(v.ToUpper());
if (root == null)
{
return(null);
}
else if (v.CompareTo(root.symbol) < 0)
{
return(search(root.left, v));
}
else if (v.CompareTo(root.symbol) > 0)
{
return(search(root.right, v));
}
return(root);
}
/*******************************************************************************
*** setNIXBPE function ***
********************************************************************************
*** DESCRIPTION: This function takes in line and outputs the bits ***
********************************************************************************
*** INPUT ARGS: Node_Sym table, string opt, string opd, bool b ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: NIXBPE bit ***
********************************************************************************/
public NIXBPE setNIXBPE(Node_Sym table, string opt, string opd, bool b)
{
NIXBPE bit = new NIXBPE();
Expressions ex = new Expressions();
if (opt[0] == '+')
{
bit.e = true;
}
else if (b == true)
{
bit.b = true;
}
else
{
bit.p = true;
}
bit.n = ex.insert(table, opd).N_bit;
bit.i = ex.insert(table, opd).I_bit;
bit.x = ex.insert(table, opd).X_bit;
return(bit);
}
/*******************************************************************************
*** PASSDUO function ***
********************************************************************************
*** DESCRIPTION: This Pass 2 funciton takes in information from the .tmp ***
*** file and outputs the Object Code for each line that applies, and then ***
*** creates the object program to the assembly code that was given intially. ***
********************************************************************************
*** INPUT ARGS: List<Node_Op> ops, Node_Sym table, Node_Lit lit, string file ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: Node_P2 p2 ***
********************************************************************************/
public Node_P2 PassDuo(List <Node_Op> ops, Node_Sym table, Node_Lit lit, string file)
{
Node_P2 p2 = new Node_P2();
Node_Op op = new Node_Op();
NIXBPE nixbpe = new NIXBPE();
Node_Sym sym = new Node_Sym();
Node_Exp ex = new Node_Exp();
Registers reg = new Registers();
Literal_Table litTab = new Literal_Table();
Expressions Exp = new Expressions();
OpCodes opCode = new OpCodes();
Symbol_Table syTab = new Symbol_Table();
List <string> codes = new List <string>();
List <string> mrec = new List <string>();
string[] Prog = File.ReadAllLines(file);
int lnum;
string counter;
string label = null;
string operation;
string operand = null;
string rrec = null;
string drec = null;
string prog_len = "00000";
string prog_start = "00000";
string prog_name = "00000";
string Obj_Code = null;
string[] splitLine;
string tmpStr;
string tmpFmt = null;
bool Base_bit = false;
string Base_Label = null;
foreach (string line in Prog)
{
splitLine = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (splitLine.Length != 1)
{
//SETS LINE NUMBER
if (Int32.TryParse(splitLine[0], out lnum))
{
}
;
//SETS LOAD COUNTER
counter = splitLine[1];
//SETS LABEL
if (splitLine.Length == 5)
{
label = splitLine[2].ToUpper();
splitLine = splitLine.Where(w => w != splitLine[0]).ToArray();
}
else
{
tmpStr = splitLine[2];
if (tmpStr[0] != '+' && opCode.search(ops, tmpStr) == null)
{
label = tmpStr.ToUpper();
splitLine = splitLine.Where(w => w != splitLine[2]).ToArray();
}
}
//SETS OPERATION
operation = splitLine[2].ToUpper();
//SETS OPERAND
if (splitLine.Length > 3)
{
operand = splitLine[3];
}
if (label == Base_Label && int.Parse(counter, System.Globalization.NumberStyles.HexNumber) > int.Parse("7FF", System.Globalization.NumberStyles.HexNumber))
{
syTab.search(table, label).value = SubHex(counter, "7FF").TrimStart('0').PadLeft(5, '0');
}
else
{
if (operation == "START")
{
prog_start = splitLine[3]; //FOR THE HEADER
prog_name = label; //FOR THE HEADER
}
else if (operation != "END")
{
//FORMAT 4 CHECK
if (operation[0] != '+')
{
op = opCode.search(ops, operation);
}
else
{
tmpStr = operation.TrimStart('+');
op = opCode.search(ops, tmpStr);
tmpFmt = "4";
}
if (op == null)
{
if (operation == "BASE")
{
Base_Label = operand;
}
else if (operation == "BYTE")
{
if (operand[0] == 'X')
{
Obj_Code = operand.TrimStart('X', '\'').TrimEnd('\'').PadLeft(6, '0');
}
else
{
Obj_Code = BitConverter.ToString(Encoding.Default.GetBytes(operand.TrimStart('\'', 'C', 'c').TrimEnd('\''))).Replace("-", "").PadLeft(6, '0');
}
}
else if (operation == "EQU")
{
}
else if (operation == "EXTDEF")
{
foreach (string n in operand.Split(','))
{
drec = drec + "^" + n + "^" + syTab.search(table, TrimOp(n)).value;
}
}
else if (operation == "EXTREF")
{
foreach (string n in operand.Split(','))
{
rrec = rrec + "^" + n;
}
}
else if (operation == "RESB")
{
}
else if (operation == "RESW")
{
}
else if (operation == "WORD")
{
Obj_Code = int.Parse(operand, System.Globalization.NumberStyles.HexNumber).ToString("X").PadLeft(6, '0');
if (operand.Contains('+') || operand.Contains('-'))
{
mrec.Add("M^" + AddHex(counter.PadLeft(6, '0'), "1") + "^06^");
}
}
}
else if (tmpFmt != null)
{
nixbpe = setNIXBPE(table, operation, operand, Base_bit);
if (operand[0] == '#')
{
Obj_Code = ObjPtOne(op.code, nixbpe) + counter;
}
else if (operand[0] == '@')
{
Obj_Code = ObjPtOne(op.code, nixbpe) + Exp.insert(table, operand).value;
}
else
{
Obj_Code = ObjPtOne(op.code, nixbpe) + Exp.insert(table, operand).value;
}
mrec.Add("M^" + AddHex(counter, "1").PadLeft(6, '0') + "^05^+" + operand.TrimStart('@', '#').TrimEnd(',', 'X'));
}
else
{
if (op.format == "1")
{
Obj_Code = op.code;
}
else if (op.format == "2")
{
Obj_Code = op.code + fmt2(operand);
}
else if (op.format == "3")
{
nixbpe = setNIXBPE(table, operation, operand, Base_bit);
if (nixbpe.n == true && nixbpe.i == false && nixbpe.x == false) //IF INDIRECT '@'
{
Obj_Code = ObjPtOne(op.code, nixbpe) + SubHex(Exp.insert(table, operand).value, getNext(op, counter)).TrimStart('0').PadLeft(3, '0');
}
else if (nixbpe.n == false && nixbpe.i == true && nixbpe.x == false) //IF IMMEDIATE '#'
{
Obj_Code = ObjPtOne(op.code, nixbpe) + Exp.insert(table, operand).value.TrimStart('0').PadLeft(3, '0');
}
else if (nixbpe.n == false && nixbpe.i == false && nixbpe.x == true) //IF INDEXED ',X'
{
Obj_Code = ObjPtOne(op.code, nixbpe) + SubHex(Exp.insert(table, operand).value, getNext(op, counter)).TrimStart('0').PadLeft(3, '0');
}
else
{
if (operand[0] == '=')
{
Obj_Code = ObjPtOne(op.code, nixbpe) + SubHex(litTab.search(lit, operand).address, getNext(op, counter)).TrimStart('0').PadLeft(3, '0');
}
else
{
Obj_Code = ObjPtOne(op.code, nixbpe) + SubHex(Exp.insert(table, operand).value, getNext(op, counter)).TrimStart('0').PadLeft(3, '0');
}
}
}
}
}
}
if (operation == "*")
{
Obj_Code = litTab.search(lit, operand).value;
}
}
else
{
prog_len = splitLine[0];
}
//ADD THE OBJ CODE TO THE P2 NODE
if (splitLine.Length != 1)
{
p2.prog.Add(line + string.Format("{0,-10}", Obj_Code));
}
if (Obj_Code != null)
{
codes.Add(Obj_Code);
}
//SET VARIABLES BACK TO NULL
tmpFmt = null;
tmpStr = null;
label = null;
Obj_Code = null;
}
p2.obj_prog.Add("H^" + prog_name + "^" + prog_start.PadLeft(5, '0') + "^" + prog_len.PadLeft(5, '0'));
if (drec != null)
{
p2.obj_prog.Add("D" + drec);
}
if (rrec != null)
{
p2.obj_prog.Add("R" + rrec);
}
p2.obj_prog = T_Records(p2.obj_prog, codes);
foreach (string m in mrec)
{
p2.obj_prog.Add(m);
}
p2.obj_prog.Add("E^" + prog_start.PadLeft(6, '0'));
return(p2);
}
/*******************************************************************************
*** IFEXPRESSIONVALID FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in the symbol table and test the ***
*** expression to make sure that it is a valid expression ***
********************************************************************************
*** INPUT ARGS: Node_Sym table, string ex ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: string ERR_MSG ***
********************************************************************************/
public string IfExpressionValid(Node_Sym table, string ex)
{
PassTwo p2 = new PassTwo();
Symbol_Table SymTab = new Symbol_Table();
Literal_Table litTab = new Literal_Table();
if (ex[0] == '@')
{
//Cant have Indirect and Indexing Addressing
if (ex[ex.Length - 2] == ',' && ex[ex.Length - 1] == 'X')
{
return(ERR_MSG_7);
}
}
//Trim expression from valid characters
ex = ex.TrimStart('#', '@');
ex = ex.TrimEnd(',', 'X');
if (ex.Contains('+'))
{
if (!int.TryParse(ex, out int n))
{
string[] newExp = ex.Split('+');
//Cannot have more than one operator
if (newExp.Length > 2)
{
return(ERR_MSG_8);
}
//newExp[0] = p2.TrimOp(newExp[0]);
//newExp[1] = p2.TrimOp(newExp[1]);
//If both arn't symbols, then they have to both be numbers
if (SymTab.search(table, newExp[0]) == null && SymTab.search(table, newExp[1]) == null)
{
if (!int.TryParse(newExp[0], out int val1))
{
return(string.Format(ERR_MSG_2, ex));
}
if (!int.TryParse(newExp[1], out int val2))
{
return(string.Format(ERR_MSG_2, ex));
}
}
//If one is a symbol, then the other has to a number
else if (SymTab.search(table, newExp[0]) != null && SymTab.search(table, newExp[1]) == null)
{
if (!int.TryParse(newExp[1], out int val1))
{
return(string.Format(ERR_MSG_2, ex));
}
}
//If one is a symbol, then the other has to a number
else if (SymTab.search(table, newExp[0]) == null && SymTab.search(table, newExp[1]) != null)
{
if (!int.TryParse(newExp[0], out int val1))
{
return(string.Format(ERR_MSG_2, ex));
}
}
//If they are both symbols, they cannot both be relative
else
{
if (!SymTab.search(table, newExp[0]).rflag&& !SymTab.search(table, newExp[1]).rflag)
{
return(ERR_MSG_5);
}
}
}
}
else if (ex.Contains('-'))
{
//Check if just a negative number
if (!int.TryParse(ex, out int n))
{
string[] newExp = ex.Split('-');
//Cannot contain more than one operand
if (newExp.Length > 2)
{
return(ERR_MSG_8);
}
//If both are not symbols, they both must be numbers
if (SymTab.search(table, newExp[0]) == null && SymTab.search(table, newExp[1]) == null)
{
if (!int.TryParse(newExp[0], out int val1))
{
return(string.Format(ERR_MSG_2, ex));
}
if (!int.TryParse(newExp[1], out int val2))
{
return(string.Format(ERR_MSG_2, ex));
}
}
//If one is a symbol, the other must be a number
else if (SymTab.search(table, newExp[0]) != null && SymTab.search(table, newExp[1]) == null)
{
if (!int.TryParse(newExp[1], out int val2))
{
return(string.Format(ERR_MSG_2, ex));
}
}
//If one is a symbol, the other must be a number
else if (SymTab.search(table, newExp[0]) == null && SymTab.search(table, newExp[1]) != null)
{
if (!int.TryParse(newExp[1], out int val2))
{
return(string.Format(ERR_MSG_2, ex));
}
else if (SymTab.search(table, newExp[1]).rflag)
{
return(ERR_MSG_6);
}
}
//If both are found, then both should have rflags, and you cannot sub a rel with abs
else if (SymTab.search(table, newExp[0]) != null && SymTab.search(table, newExp[1]) != null)
{
if (!SymTab.search(table, newExp[0]).rflag&& SymTab.search(table, newExp[1]).rflag)
{
return(ERR_MSG_6);
}
}
}
}
//If there is no expression, see if a symbol, if not a symbol, then a number
else if (SymTab.search(table, ex) == null)
{
foreach (char x in ex)
{
if (!Char.IsDigit(x))
{
return(string.Format(ERR_MSG_4, ex));
}
}
}
return(null);
}
/*******************************************************************************
*** RETREL FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in the symbol table, and finds the ***
*** relocatable based on the expression passed in ***
********************************************************************************
*** INPUT ARGS: Node_Sym table, string ex ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: int value ***
********************************************************************************/
private bool retRel(Node_Sym table, string ex)
{
Symbol_Table SymTab = new Symbol_Table();
string[] newEx = new string[] { };
//Trim the expression
ex = ex.TrimStart('@', '#');
ex = ex.TrimEnd(',', 'x', 'X');
//If it an addition expression
if (ex.Contains('+'))
{
newEx = ex.Split('+');
//If Absolute + Absolute
if (SymTab.search(table, newEx[0]) == null && SymTab.search(table, newEx[1]) == null)
{
return(false);
}
//If Absolute + ?
else if (SymTab.search(table, newEx[0]) == null && SymTab.search(table, newEx[1]) != null)
{
if (!SymTab.search(table, newEx[1]).rflag)
{
return(false);
}
else
{
return(true);
}
}
//If ? + Absolute
else if (SymTab.search(table, newEx[0]) != null && SymTab.search(table, newEx[1]) == null)
{
if (!SymTab.search(table, newEx[0]).rflag)
{
return(false);
}
else
{
return(true);
}
}
//If ? + ?
else
{
//If Absolute + ?
if (SymTab.search(table, newEx[0]).rflag)
{
if (!SymTab.search(table, newEx[0]).rflag)
{
return(false);
}
else
{
return(true);
}
}
//If Relative + ?
else
{
if (!SymTab.search(table, newEx[0]).rflag)
{
return(true);
}
//Else should be error
}
}
}
else if (ex.Contains('-'))
{
newEx = ex.Split('-');
//If Absolute - Absolute
if (SymTab.search(table, newEx[0]) == null && SymTab.search(table, newEx[1]) == null)
{
return(false);
}
//If Absolute - ?
else if (SymTab.search(table, newEx[0]) == null && SymTab.search(table, newEx[1]) != null)
{
if (!SymTab.search(table, newEx[1]).rflag)
{
return(false);
}
}
//If ? - Absolute
else if (SymTab.search(table, newEx[0]) != null && SymTab.search(table, newEx[1]) == null)
{
if (!SymTab.search(table, newEx[0]).rflag)
{
return(false);
}
else
{
return(true);
}
}
//If ? - ?
else
{
//If Absolute - ?
if (!SymTab.search(table, newEx[0]).rflag)
{
if (!SymTab.search(table, newEx[1]).rflag)
{
return(false);
}
else
{
return(true);
}
}
//If Relative - ?
else
{
if (SymTab.search(table, newEx[0]).rflag)
{
return(false);
}
}
}
}
else
{
//If its a number, Absolute, if a symbol, it is the rflag
if (SymTab.search(table, ex) == null)
{
return(false);
}
else
{
return(SymTab.search(table, ex).rflag);
}
}
return(true);
}
/*******************************************************************************
*** RETVAL FUNCTION ***
********************************************************************************
*** DESCRIPTION: This function takes in the symbol table, and finds the ***
*** value based on the expression passed in ***
********************************************************************************
*** INPUT ARGS: Node_Sym table, string ex ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: int value ***
********************************************************************************/
private string retVal(Node_Sym table, string ex)
{
Symbol_Table SymTab = new Symbol_Table();
//If and addition expression
ex = ex.TrimStart('@', '#');
ex = ex.TrimEnd(',', 'x', 'X');
if (ex.Contains('+'))
{
if (!int.TryParse(ex, out int n))
{
//Splits the Expression into two
string[] newEx = ex.Split('+');
//Bools that return false if the string is not a number, and returns true with a value if string is a number
bool isNum1 = int.TryParse(newEx[0], out int val1);
bool isNum2 = int.TryParse(newEx[1], out int val2);
//if both are numbers, then add them
if (isNum1 && isNum2)
{
return(AddValue(newEx[0], newEx[1]));
}
//if num1 is a number and num2 isn't, then search and find value of symbol
else if (isNum1 && !isNum2)
{
return(AddValue(newEx[0], SymTab.search(table, newEx[1]).value));
}
//if num1 isn't a number but num2 is, then search and find the value of the symber
else if (!isNum1 && isNum2)
{
return(AddValue(newEx[1], SymTab.search(table, newEx[0]).value));
}
//if both are not numbers, search both and find values of both
else
{
return(AddValue(SymTab.search(table, newEx[0]).value, SymTab.search(table, newEx[1]).value));
}
}
else
{
return(ex);
}
}
//If a difference expression
else if (ex.Contains('-'))
{
//If then entire expression isn't a number
if (!int.TryParse(ex, out int n))
{
string[] newEx = ex.Split('-');
bool isNum1 = int.TryParse(newEx[0], out int val1);
bool isNum2 = int.TryParse(newEx[1], out int val2);
//if they are both number, find the difference
if (isNum1 && isNum2)
{
return(SubValue(newEx[0], newEx[1]));
}
//if one is a number and one isnt, search and find the difference
else if (isNum1 && !isNum2)
{
return(SubValue(newEx[0], SymTab.search(table, newEx[1]).value));
}
//if one is a number and one isnt, search and find the difference
else if (!isNum1 && isNum2)
{
return(SubValue(newEx[1], SymTab.search(table, newEx[0]).value));
}
// if neither are numbers, search and find the difference
else
{
return(SubValue(SymTab.search(table, newEx[0]).value, SymTab.search(table, newEx[1]).value));
}
}
else
{
return(ex);
}
}
else
{
if (SymTab.search(table, ex) != null)
{
return(SymTab.search(table, ex).value);
}
else
{
return(int.Parse(ex, System.Globalization.NumberStyles.HexNumber).ToString("X"));
}
}
}
/*******************************************************************************
*** PASSUNO function ***
********************************************************************************
*** DESCRIPTION: This Pass 1 funciton takes in information from the file ***
*** passed in. In the file contains assembly instructions and pass one ***
*** produces line numbers and load counters. Pass 1 also stores the labels ***
*** as symbols and also store literals in the literal table. ***
********************************************************************************
*** INPUT ARGS: string program, List<Node_Op> OpCodes ***
*** OUTPUT ARGS: N/A ***
*** IN/OUT ARGS: N/A ***
*** RETURN: Node_P1 p1 ***
********************************************************************************/
public Node_P1 PassUno(string program, List <Node_Op> OpCodes)
{
Node_P1 passOne = new Node_P1();
PassTwo p2 = new PassTwo();
List <string> theFile = new List <string>();
List <int> valLits = new List <int>();
OpCodes opCode = new OpCodes();
Symbol_Table SymTab = new Symbol_Table();
Expressions Exp = new Expressions();
Literal_Table LitTable = new Literal_Table();
Node_Lit lit = new Node_Lit();
Node_Sym table = new Node_Sym();
Node_Op op = new Node_Op();
Node_Exp ex = new Node_Exp();
List <string> Literals = new List <string>();
string[] Prog = File.ReadAllLines(program);
string[] splitLine;
string str_Count = null;
string tmpCounter = null;
string label = null;
string operation = null;
string operand = null;
int l = 0;
string Counter = "00000";
string EquCount = null;
string tmpStr;
int val;
int tmp;
bool r = true;
foreach (string line in Prog)
{
//HANDLE IF EMPTY LINE
if (line != null)
{
//COMMMENT HANDLING
if (line[0] != '.')
{
tmpStr = line;
//SPLITS THE LINE
splitLine = tmpStr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
//SETS LABEL
if (splitLine.Length >= 3)
{
label = splitLine[0].ToUpper();
splitLine = splitLine.Where(w => w != splitLine[0]).ToArray();
}
else
{
tmpStr = splitLine[0];
if (tmpStr[0] != '+' && opCode.search(OpCodes, tmpStr) == null && tmpStr != "BASE" && tmpStr != "BYTE" && tmpStr != "END" && tmpStr != "EQU" && tmpStr != "EXTDEF" && tmpStr != "EXTREF" && tmpStr != "RESB" && tmpStr != "RESW" && tmpStr != "START" && tmpStr != "WORD")
{
label = splitLine[0].ToUpper();
splitLine = splitLine.Where(w => w != splitLine[0]).ToArray();
}
}
//SETS OPERTATION
operation = splitLine[0].ToUpper();
//SETS OPERAND
if (splitLine.Length > 1)
{
operand = splitLine[1];
}
//SETS LINE NUMBER
l++;
if (operation != "EQU")
{
tmpCounter = Counter;
}
//IF START, THEN START; IF NOT END, THEN DO STUFF
if (operation == "START")
{
Counter = operand.PadLeft(5, '0');
str_Count = Counter;
}
else if (operation != "END")
{
//FORMAT 4 CHECK
if (operation[0] != '+')
{
op = opCode.search(OpCodes, operation);
}
else
{
tmpStr = operation.TrimStart('+');
op = opCode.search(OpCodes, tmpStr);
op.format = "4";
}
if (op == null)
{
if (operation == "WORD")
{
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + 3;
Counter = val.ToString("X").PadLeft(5, '0');
}
else if (operation == "RESW")
{
if (int.TryParse(operand, out tmp))
{
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + (tmp * 3);
Counter = val.ToString("X").PadLeft(5, '0');
}
}
else if (operation == "RESB")
{
if (int.TryParse(operand, out tmp))
{
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + tmp;
Counter = val.ToString("X").PadLeft(5, '0');
}
}
else if (operation == "BYTE")
{
tmpStr = operand;
if (tmpStr[0] == 'C')
{
tmpStr = tmpStr.TrimStart('C', '\'');
tmpStr = tmpStr.TrimEnd('\'');
tmp = tmpStr.Length;
}
else
{
tmpStr = tmpStr.TrimStart('X', '\'');
tmpStr = tmpStr.TrimEnd('\'');
tmp = tmpStr.Length / 2;
}
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + tmp;
Counter = val.ToString("X").PadLeft(5, '0');
}
else if (operation == "BASE")
{
}
else if (operation == "EQU")
{
if (operand == "*")
{
EquCount = Counter;
}
//IF OPERAND IS A DECIMAL VALUE
else if (int.TryParse(operand, out tmp))
{
EquCount = tmp.ToString("X").PadLeft(5, '0');
r = false;
}
//IF OPERAND IS AN EXPRESSION
else
{
ex = Exp.insert(table, operand);
if (int.TryParse(ex.value, out tmp))
{
EquCount = tmp.ToString("X").PadLeft(5, '0');
r = ex.relocatable;
}
}
}
else if (operation == "EXTDEF")
{
r = false;
}
else if (operation == "EXTREF")
{
r = false;
}
}
else
{
if (operation[0] != '+')
{
if (int.TryParse(op.format, out tmp))
{
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + tmp;
Counter = val.ToString("X").PadLeft(5, '0');
}
}
else
{
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + 4;
Counter = val.ToString("X").PadLeft(5, '0');
}
}
}
if (operand != null)
{
if (operand[0] == '=')
{
Literals.Add(operand);
}
}
if (EquCount == null)
{
theFile.Add(string.Format("{0,-4} {1,-10} {2,-10} {3,-10} {4,-15}", l, tmpCounter, label, operation, operand));
if (label != null)
{
table = SymTab.insert(table, label, tmpCounter, r);
}
}
else
{
theFile.Add(string.Format("{0,-4} {1,-10} {2,-10} {3,-10} {4,-15}", l, EquCount, label, operation, operand));
if (label != null)
{
table = SymTab.insert(table, label, EquCount, r);
}
}
EquCount = null;
r = true;
label = null;
operand = null;
}
}
}
if (Literals != null)
{
foreach (string oper in Literals)
{
l++;
tmpCounter = Counter;
lit = LitTable.insert(lit, oper, Counter);
val = int.Parse(Counter, System.Globalization.NumberStyles.HexNumber) + lit.length;
Counter = val.ToString("X").PadLeft(5, '0');
valLits.Add(lit.length);
theFile.Add(string.Format("{0,-4} {1,-10} {2,-10} {3,-10} {4,-15}", l, tmpCounter, "*", oper, ""));
}
}
passOne.length = p2.SubHex(Counter, str_Count);
theFile.Add(passOne.length);
passOne.table = table;
passOne.lit = lit;
passOne.prog = theFile;
return(passOne);
}