/// Function - ChecksInSyntaxCheck /// <summary> /// this function take cares of the whole syntax check of the program. /// it uses the functions mentioned in the documentations before. /// it take cares scopes and no scopes with the parameter IsScope type bool. /// </summary> /// <param name="path"> the path of the file.</param> /// <param name="globalVariables"> variables that all file have.</param> /// <param name="threadNumber"> the number of the current thread running.</param> /// <param name="variables"> all of the variables that the scope knows.</param> /// <param name="sr"> buffer type MyStream.</param> /// <param name="codeLine"> code line type string.</param> /// <param name="IsScope"> bool type IsScope.</param> /// <param name="keywords"> keywords type Hashtable that conatins the code keywords.</param> /// <param name="blocksAndNames"> blocksAndNames type ArrayList that conatins the code variables in the scope.</param> /// <param name="parameters"> parameters type ArrayList conatins the function parameters.</param> /// <param name="functionLength"> scopeLength type int default is 0 if the code line is outside any scopes.</param> static void ChecksInSyntaxCheck(string path, MyStream sr, string codeLine, bool IsScope, Hashtable keywords, int threadNumber, ArrayList variables, ArrayList globalVariables, ArrayList blocksAndNames, ArrayList parameters = null, int functionLength = 0) { //adds the parameters of the function to the current ArrayList of variables. if (parameters != null) { blocksAndNames.Add(new ArrayList()); ((ArrayList)blocksAndNames[1]).AddRange(parameters); } if (StructPattern.IsMatch(codeLine)) { //Add struct keywords to the keywords Hashtable. AddStructNames(sr, codeLine, keywords); } if (codeLine.Trim(GeneralConsts.TAB_SPACE).IndexOf("{") != GeneralConsts.NOT_FOUND_STRING) { codeLine = sr.ReadLine(); } //how to convert to array list bool keywordCheck = true; bool DifferentTypesCheck = true; int pos = 0; int i; ArrayList keywordResults = new ArrayList(); for (i = 0; i < functionLength + 1; i++) { if (codeLine.Trim(GeneralConsts.TAB_SPACE) == GeneralConsts.EMPTY_STRING) { codeLine = sr.ReadLine(); } //take cares to all of those situations. if (StructPattern.IsMatch(codeLine) || TypedefOneLine.IsMatch(codeLine)) { keywordResults = AddStructNames(sr, codeLine, keywords); } if (VariableDecleration.IsMatch(codeLine) && !(codeLine.IndexOf("typedef") != GeneralConsts.NOT_FOUND_STRING)) { keywordCheck = VariableDeclarationHandler(ref codeLine, ref pos, keywords, threadNumber, variables, globalVariables, blocksAndNames, IsScope, sr); } else if (VariableEquation.IsMatch(codeLine)) { DifferentTypesCheck = VariableEquationHandler(sr, codeLine, blocksAndNames, threadNumber); } codeLine = codeLine.Trim(); //checks if any of the error bools is on. if (!keywordCheck) { string error = (codeLine + " keyword does not exist. row : " + sr.curRow); try { MainProgram.AddToLogString(path, sr.curRow.ToString()); } catch (Exception e) { MainProgram.AddToLogString(path, e.ToString()); } MainProgram.AddToLogString(path, error); Server.ConnectionServer.CloseConnection(threadNumber, error, GeneralConsts.ERROR); CompileError = true; } if (!DifferentTypesCheck) { string error = (codeLine + " types of both variables are different in row : " + sr.curRow); Server.ConnectionServer.CloseConnection(threadNumber, error, GeneralConsts.ERROR); CompileError = true; } pos = 0; //resets the error bools. keywordCheck = DifferentTypesCheck = true; if (codeLine.IndexOf("//") != GeneralConsts.NOT_FOUND_STRING || codeLine.IndexOf("/*") != GeneralConsts.NOT_FOUND_STRING) { //skips documentation if needed. i += skipDocumentation(sr, codeLine); } //adds a new ArrayList inside the keywordsAndNames ArrayList for the scope that has started. if (OpenBlockPattern.IsMatch(codeLine)) { blocksAndNames.Add(new ArrayList()); } if (CloseBlockPattern.IsMatch(codeLine)) { try { //close the last scope that just closed. blocksAndNames.RemoveAt(blocksAndNames.Count - 1); } catch (Exception e) { //bad scoping causes the function to remove from an ArrayList something while its already 0. Server.ConnectionServer.CloseConnection(threadNumber, "bad scoping in function in row " + sr.curRow, GeneralConsts.ERROR); CompileError = true; } } //if the code line is in a scope or if its not the last line in the scope continute to the next line. if (IsScope && i != functionLength) { codeLine = sr.ReadLine(); } } //if that was a scope it removes all the keywords of the scope. if (IsScope) { for (i = 0; i < keywordResults.Count; i++) { keywords.Remove(keywordResults[i]); } } }
//path to the code; /// Function - PreprocessorActions /// <summary> /// /// </summary> /// <param name="path"> The path for the C code.</param> /// <param name="threadNumber"> thread number is a parameter to make sure when the main file is in. /// number 0 means its the main file any other number means it is currently /// reads a file that is not the main. (Import).</param> /// <param name="keywords"> Hashtable to store the keywords.</param> /// <param name="includes"> Hashtable to store the includes.</param> /// <param name="defines"> Dictionary to store the defines . (key - new keyword, value - old Definition)</param> /// <param name="pathes"> Paths for all the places where the imports might be.</param> static void PreprocessorActions(string path, int threadNumber, Hashtable keywords, Hashtable includes, Dictionary <string, string> defines, string [] pathes) { bool endLoop = false; MyStream sr = null; //try to open the buffer. try { sr = new MyStream(path, System.Text.Encoding.UTF8); } catch (Exception e) { MainProgram.AddToLogString(path, String.Format("{0} Second exception caught.", e.ToString())); Server.ConnectionServer.CloseConnection(threadNumber, FILE_NOT_FOUND, GeneralConsts.ERROR); endLoop = true; } string codeLine; string firstNewVariableWord; string secondNewVariableWord; string[] newkeyWords; string newKeyword; string defineOriginalWord; while (!endLoop && (codeLine = sr.ReadLine()) != null) { if (DefineDecleration.IsMatch(codeLine)) { //getting both of the names in two variables. firstNewVariableWord = codeLine.Substring(codeLine.IndexOf(' '), codeLine.Length - codeLine.IndexOf(' ')); firstNewVariableWord = firstNewVariableWord.Trim(); firstNewVariableWord = firstNewVariableWord.Substring(firstNewVariableWord.IndexOf(GeneralConsts.SPACEBAR), firstNewVariableWord.Length - firstNewVariableWord.IndexOf(GeneralConsts.SPACEBAR)); firstNewVariableWord = firstNewVariableWord.Trim(CharsToTrim); //old definition. defineOriginalWord = firstNewVariableWord; if (firstNewVariableWord.IndexOf(GeneralConsts.SPACEBAR) != GeneralConsts.NOT_FOUND_STRING) { //checks if the definition exists. if (keywords.ContainsKey(CreateMD5(firstNewVariableWord))) { //new keyword //takes the part after the first space. newKeyword = Regex.Split(codeLine, GeneralConsts.SPACEBAR)[1]; newKeyword = newKeyword.Trim(); //make sure that the keyword isn't already existed. if (!keywords.ContainsKey(CreateMD5(newKeyword))) { //adds her if not keywords.Add(CreateMD5(newKeyword), newKeyword); //adds the new definition. defines.Add(newKeyword, defineOriginalWord); //types the dont mind the variable are being ingored. for an example static : so if //the type for example is static and i define a new static definition it will add it to //the ignoreVariablesType. if (ignoreVarialbesType.Contains(defineOriginalWord)) { ignoreVarialbesType.Add(newKeyword); } } } else { //splits when there are 2 types that you define for an example "unsinged int" //so what this section is doing is checking if both of the types exist. newkeyWords = Regex.Split(firstNewVariableWord, GeneralConsts.SPACEBAR); secondNewVariableWord = newkeyWords[1]; firstNewVariableWord = newkeyWords[0]; //checks both types. if (CheckIfStringInHash(keywords, firstNewVariableWord) && CheckIfStringInHash(keywords, secondNewVariableWord)) { newKeyword = Regex.Split(codeLine, GeneralConsts.SPACEBAR)[1]; newKeyword = newKeyword.Trim(); //creates the keywords if they dont exist. if (!keywords.ContainsKey(CreateMD5(newKeyword))) { keywords.Add(CreateMD5(newKeyword), newKeyword); defines.Add(newKeyword, defineOriginalWord); MainProgram.AddToLogString(path, "new Keywords :" + newkeyWords[0]); } } } } else { //if there is only one type in the old definition. if (CheckIfStringInHash(keywords, firstNewVariableWord)) { newKeyword = Regex.Split(codeLine, GeneralConsts.SPACEBAR)[1]; newKeyword = newKeyword.Trim(); if (!keywords.ContainsKey(CreateMD5(newKeyword))) { keywords.Add(CreateMD5(newKeyword), newKeyword); defines.Add(newKeyword, defineOriginalWord); MainProgram.AddToLogString(path, "new : " + newKeyword); } } } } //Handling almost the same patterns as the syntaxCheck function. if (StructPattern.IsMatch(codeLine) && threadNumber != 0) { AddStructNames(sr, codeLine, keywords); } else if (TypedefOneLine.IsMatch(codeLine) && threadNumber != 0) { AddStructNames(sr, codeLine, keywords); } //if the code line is an include it creates a thread and enters to the defines , structs and more to //the Hashtables and Dictionaries. else if (IncludeTrianglesPattern.IsMatch(codeLine) || IncludeRegularPattern.IsMatch(codeLine)) { string currentPath = GeneralConsts.EMPTY_STRING; string result; if (codeLine.IndexOf("<") != -1 && codeLine.IndexOf(">") != -1) { result = CutBetween2Strings(codeLine, "<", ">"); } else { result = CutBetween2Strings(codeLine, "\"", "\""); } MainProgram.AddToLogString(path, result); //only enters an include if it didnt already included him. if (!includes.Contains(CreateMD5(result))) { includes.Add(CreateMD5(result), result); Thread preprocessorThread; //if the include includes a path inside of it. if (result.IndexOf("\\") != -1) { //opens the thread (thread number +1). preprocessorThread = new Thread(() => PreprocessorActions(result, threadNumber + 1, keywords, includes, defines, pathes)); } //if it does not include an exact path. else { //runs on the pathes that the import files might be in. for (int i = 0; i < pathes.Length; i++) { //checks if the file exists in one of those folders. if (File.Exists(pathes[i] + "\\" + result)) { currentPath = pathes[i]; break; } } //creats a thread. preprocessorThread = new Thread(() => PreprocessorActions(currentPath + "\\" + result, threadNumber + 1, keywords, includes, defines, pathes)); } preprocessorThread.Start(); preprocessorThread.Join(GeneralConsts.TIMEOUT_JOIN); MainProgram.AddToLogString(path, "thread " + threadNumber + "stopped"); } } } if (sr != null) { sr.Close(); } }
/// Function - SyncServer /// <summary> /// Creation of the rest api server. /// </summary> /// <param name="filePath"> Path for the code file.</param> /// <param name="includes"> Hashtable for all of the includes in the code.</param> /// <param name="defines"> Dictionary that stores all of the defines in the code.</param> public SyncServer() { var listener = new HttpListener(); //add prefixes. listener.Prefixes.Add("http://localhost:8081/"); listener.Prefixes.Add("http://127.0.0.1:8081/"); //start listening. listener.Start(); while (ConnectionServer.GetCloseAllBool() == false) { try { //if gets connection. var context = listener.GetContext(); //Block until a connection comes in context.Response.StatusCode = 200; context.Response.SendChunked = true; context.Response.ContentType = "application/json"; string dataJson = GeneralConsts.EMPTY_STRING; Dictionary <string, Dictionary <string, object> > final_json = MainProgram.GetFinalJson(); string filePath = context.Request.QueryString["filePath"]; bool not_found_pattern = false; bool not_found = false; char[] trimChars = { '/', ' ' }; int totalTime = 0; string path = GeneralConsts.EMPTY_STRING; Regex r; //All GET commands. if (context.Request.HttpMethod == "GET") { if (context.Request.QueryString["pattern"] != null) { MainProgram.AddToLogString(filePath, context.Request.QueryString["pattern"]); MainProgram.AddToLogString(filePath, context.Request.QueryString["returnSize"]); r = new Regex(context.Request.QueryString["pattern"]); string returnSize = context.Request.QueryString["returnSize"]; string [] result = GeneralRestApiServerMethods.SearchPattern(r, returnSize, filePath); dataJson = JsonConvert.SerializeObject(result); MainProgram.AddToLogString(filePath, dataJson); } else if (context.Request.QueryString["readyPattern"] != null) { MainProgram.AddToLogString(filePath, context.Request.QueryString["readyPattern"]); MainProgram.AddToLogString(filePath, context.Request.QueryString["returnSize"]); if (GeneralRestApiServerMethods.TakePatternFromFile(context.Request.QueryString["readyPattern"]) == GeneralConsts.EMPTY_STRING) { not_found_pattern = true; } else { r = new Regex(GeneralRestApiServerMethods.TakePatternFromFile(context.Request.QueryString["readyPattern"])); string returnSize = context.Request.QueryString["returnSize"]; string[] result = GeneralRestApiServerMethods.SearchPattern(r, returnSize, filePath); dataJson = JsonConvert.SerializeObject(result); } } else { path = context.Request.RawUrl; path = path.Trim(trimChars); path = path.Split('?')[0]; MainProgram.AddToLogString(filePath, path); //switch case for get commands. switch (path) { case "functions": dataJson = JsonConvert.SerializeObject(final_json[filePath]["function"]); MainProgram.AddToLogString(filePath, dataJson); break; case "codeInfo": dataJson = JsonConvert.SerializeObject(final_json[filePath]["codeInfo"]); MainProgram.AddToLogString(filePath, dataJson); break; default: break; } } byte [] bytes; if (not_found) { bytes = Encoding.UTF8.GetBytes(NOT_FOUND_500); context.Response.StatusCode = 500; } else { if (dataJson.Length < 0) { bytes = Encoding.UTF8.GetBytes(NOT_FOUND_404); context.Response.StatusCode = 404; } else { bytes = Encoding.UTF8.GetBytes(dataJson); } } Stream OutputStream = context.Response.OutputStream; //sends the message back. OutputStream.Write(bytes, 0, bytes.Length); //Close connection. OutputStream.Close(); } } catch (Exception) { // Client disconnected or some other error - ignored for this example } } }