public void ExecuteMainMethodFromObjectFile(string path) { using (FileStream stream = new FileStream(path, FileMode.Open)) { ProcedureInstruction methods; try { methods = (ProcedureInstruction)formatter.Deserialize(stream); } catch (SerializationException) { GetRuntimeError(RuntimeMessagesError.ObjFile); return; // this statment is unreachable. Just for the compile Error } ProcedureInstruction main = IdentifierInstruction.FindIdentifer("Main", methods); if (main != null) { ExecuteListOfInstructions(main.Linst); } else { GetRuntimeError(RuntimeMessagesError.NoMain); } EndOfExecute?.Invoke(this, new WriteEventArgs(true, "End of Executing... Press Enter to Exit", true)); } }
/// <summary> /// Compile the primary file that has main function and the related included file with it. /// </summary> /// <param name="fileName">Represent the filename</param> public void CompileMainProgram(string fileName) { Warning.Clear(); locals.initializeForRecompile(); gFile = new TFile { Name = fileName }; currentFile = gFile; bool mainFile = true; while (currentFile != null) { locals.initializeForNewFile(); try { locals.CF = File.ReadAllLines(currentFile.Name); } catch (FileNotFoundException) // if the file that included is not found. { MakeSyntaxError(SyntaxMessagesError.FileNotFound); } catch (DirectoryNotFoundException) { MakeSyntaxError(SyntaxMessagesError.FileNotFound); } analyst.CompileCurrentFile(); if (mainFile) // if there is NO main is not in main File. { if (IdentifierInstruction.FindIdentifer("Main", gProc) == null) { MakeSyntaxError(string.Format(SyntaxMessagesError.NoMainMethod, currentFile.Name)); } } mainFile = false; currentFile = currentFile.Next; } // Check if we call function or procedure that not Defined ProcedureInstruction tempP = gProc; while (tempP != null) { if (!tempP.IsDefined) { throw new SyntaxErrorException(string.Format(SyntaxMessagesError.MethodNotDefined, tempP.Name), 0, 0, ""); //MakeSyntaxError(string.Format(SyntaxMessagesError.MethodNotDefined, tempP.Name)); } tempP = (ProcedureInstruction)tempP.Next; } string[] dirs = gFile.Name.Split('\\'); dir = dirs.Take(dirs.Length - 1).Select(str => str + "\\").Aggregate((one, two) => one + two) + dirs.Last().Split('.')[0] + ".obj"; using (FileStream writer = new FileStream(dir, FileMode.Create)) { formatter.Serialize(writer, gProc); } }
private object HandleCall() { UL = LexicalUnit(); if ((UL != TypeSymbol.U_VarProcedure) && (UL != TypeSymbol.U_UnKown)) { GetSyntaxError(WordMessagesError.NotFound, "Procedure Name"); } if (UL == TypeSymbol.U_UnKown) { IdentifierInstruction.AddIdentifier(G_curr_Str, ref Locals.gproc); // by default gProc.IsDefined = false; gProc.IsFunc = false; gProc.Linst = null; gProc.PIN = null; gProc.POut = null; gProc.LVar = null; G_curr_ID = gProc; } if (((ProcedureInstruction)G_curr_ID).IsFunc) { GetSyntaxError(SyntaxMessagesError.CallFunction); } ProcedureInstruction procAux = (ProcedureInstruction)G_curr_ID; UL = LexicalUnit(); CallInstruction callAux = ReadCall(procAux); if (UL != TypeSymbol.U_SemiColon) { GetSyntaxError(SyntaxMessagesError.SemiColon); } UL = LexicalUnit(); return(callAux); }
private TExpression ReadFact(ref TExpression last) { if (UL == TypeSymbol.U_Cst_Int || UL == TypeSymbol.U_Cst_Real || UL == TypeSymbol.U_Cst_Str || UL == TypeSymbol.U_True || UL == TypeSymbol.U_False) { TExpression expNew = new TExpression(); expNew.UL = UL; if (UL == TypeSymbol.U_Cst_Str) { expNew.ValStr = G_curr_Str; } else if (UL == TypeSymbol.U_Cst_Int || UL == TypeSymbol.U_Cst_Real) // the if statment i added after notce the true false. { expNew.ValNB = G_curr_Num; } // by default expNew.Next = null; expNew.Prev = null; last = expNew; UL = LexicalUnit(); return(expNew); } else if (UL == TypeSymbol.U_OpenParanthese) { UL = LexicalUnit(); TExpression expNew = ReadCondition(ref last); if (UL != TypeSymbol.U_ClosedParanthese) { GetSyntaxError(WordMessagesError.NotFound, ")"); } UL = LexicalUnit(); return(expNew); } else if (UL == TypeSymbol.U_Var || UL == TypeSymbol.U_VarDefine || UL == TypeSymbol.U_VarProcedure || UL == TypeSymbol.U_UnKown) { TExpression expNew = new TExpression(); // By Default expNew.Next = null; expNew.Prev = null; TVar varAux = null; ProcedureInstruction procAux = null; TypeSymbol ulAux; if (UL == TypeSymbol.U_VarDefine) // if the variable define { DefineInstruction defAux = (DefineInstruction)G_curr_ID; expNew.UL = defAux.UL; expNew.ValNB = defAux.ValNB; expNew.ValStr = defAux.ValStr; ulAux = defAux.UL; UL = LexicalUnit(); } else if (UL == TypeSymbol.U_UnKown) // if the variblae unknown procedure , unknown variable { string buffer = G_curr_Str; UL = LexicalUnit(); if (UL == TypeSymbol.U_OpenParanthese) // if the variblae unknown procedure { IdentifierInstruction.AddIdentifier(buffer, ref Locals.gproc); procAux = gProc; gProc.IsFunc = true; //gProc.IsDefined = false; //gProc.PIN = null; //gProc.POut = null; //gproc.LVar = null; //gProc.Linst = null; ulAux = TypeSymbol.U_VarProcedure; } else // if the variblae unknown procedure , unknownvariable { IdentifierInstruction.AddIdentifier(buffer, ref Locals.gvar); varAux = gVar; ulAux = TypeSymbol.U_Var; } } else // if the variable known { // this statment i am not sure about it ulAux = UL; if (ulAux == TypeSymbol.U_Var) // if the vairable known var { varAux = (TVar)G_curr_ID; } else // if the variable known procedure { procAux = (ProcedureInstruction)G_curr_ID; } UL = LexicalUnit(); } expNew.UL = ulAux; last = expNew; if (ulAux == TypeSymbol.U_VarProcedure) { expNew.ValCall = ReadCall(procAux); } else if (ulAux == TypeSymbol.U_Var) { expNew.ValVar = varAux; if (UL == TypeSymbol.U_OpenBracket) { UL = LexicalUnit(); expNew.Index = ReadExpression(); if (UL != TypeSymbol.U_ClosedBracket) { GetSyntaxError(WordMessagesError.NotFound, "]"); } UL = LexicalUnit(); } else { expNew.Index = null; } } return(expNew); } else if (new TypeSymbol[] { TypeSymbol.U_Sin, TypeSymbol.U_Cos, TypeSymbol.U_Tg, TypeSymbol.U_Ln, TypeSymbol.U_Log, TypeSymbol.U_Exp, TypeSymbol.U_Sqr, TypeSymbol.U_Sqrt, TypeSymbol.U_Length, TypeSymbol.U_IntToStr, TypeSymbol.U_StrToInt, TypeSymbol.U_IntToHex, }.Contains(UL)) { TExpression expNew = new TExpression(); expNew.UL = UL; UL = LexicalUnit(); if (UL != TypeSymbol.U_OpenParanthese) { GetSyntaxError(WordMessagesError.NotFound, "("); } UL = LexicalUnit(); TExpression exp0 = ReadExpression(ref last); last.Next = expNew; expNew.Prev = last; last = expNew; if (UL != TypeSymbol.U_ClosedParanthese) { GetSyntaxError(WordMessagesError.NotFound, ")"); } UL = LexicalUnit(); return(exp0); } else if (UL == TypeSymbol.U_Pluse || UL == TypeSymbol.U_Minus || UL == TypeSymbol.U_Not || UL == TypeSymbol.U_Complement) { TExpression expNew = new TExpression(); if (UL == TypeSymbol.U_Pluse) { expNew.UL = TypeSymbol.U_UnaryPluse; } else if (UL == TypeSymbol.U_Minus) { expNew.UL = TypeSymbol.U_UnaryMinuse; } else if (UL == TypeSymbol.U_Not) { expNew.UL = TypeSymbol.U_Not; } else { expNew.UL = TypeSymbol.U_Complement; } UL = LexicalUnit(); TExpression exp0 = ReadFact(ref last); last.Next = expNew; expNew.Prev = last; last = expNew; // this statment i added to solve the problem that unary pluse and unary minus. return(exp0); } else { GetSyntaxError(SyntaxMessagesError.InvalidToken, UL.ToString()); } // this statment will never execute // just for elminate compile time error. return(null); }
private CallInstruction ReadCall(ProcedureInstruction procAux) { CallInstruction callAux = new CallInstruction { P = procAux }; // Code before Modify //callAux.P = (TProcedure)lexer.CurrID; //if (LexicalUnit() != TypeSymbol.U_OpenParanthese) //{ // GetSyntaxError(WordMessagesError.NotFound, "("); //} // Code after Modify // callAux.P = procAux; if (UL != TypeSymbol.U_OpenParanthese) { GetSyntaxError(WordMessagesError.NotFound, "("); } UL = LexicalUnit(); // By Default callAux.Pin = null; callAux.Pout = null; if (UL == TypeSymbol.U_Input) { UL = LexicalUnit(); TExpression last = null; while (true) { TExpression last1 = null; TExpression exp1 = ReadExpression(ref last1); if (callAux.Pin == null) { callAux.Pin = exp1; } else { last.Next = exp1; exp1.Prev = last; } last = last1; if (UL == TypeSymbol.U_ClosedParanthese || UL == TypeSymbol.U_Output) { break; } if (UL != TypeSymbol.U_Comma) { GetSyntaxError(WordMessagesError.NotFound, "\",\""); } UL = LexicalUnit(); } // end while } if (UL == TypeSymbol.U_Output) // this section must be Repated again ( it is not finished ) { UL = LexicalUnit(); while (true) { if (UL == TypeSymbol.U_UnKown) { IdentifierInstruction.AddIdentifier(G_curr_Str, ref Locals.gvar); G_curr_ID = gVar; } else if (UL != TypeSymbol.U_Var) { GetSyntaxError(WordMessagesError.NotFound, "Variable"); } TListVar newlvar = new TListVar(); newlvar.V = (TVar)G_curr_ID; newlvar.Next = callAux.Pout; callAux.Pout = newlvar; UL = LexicalUnit(); if (UL == TypeSymbol.U_ClosedParanthese) { break; } if (UL != TypeSymbol.U_Comma) { GetSyntaxError(WordMessagesError.NotFound, "\",\""); } UL = LexicalUnit(); } } if (UL != TypeSymbol.U_ClosedParanthese) { GetSyntaxError(WordMessagesError.NotFound, ")"); } UL = LexicalUnit(); return(callAux); }