public override string ToPySyncsFromString(string Code, Logger.Logger logger)
{
var compiler = new Cache.MessyCompilerCache(_tSet);
compiler.LoadString(Code);
for (compiler.CurrentLine = 0;
compiler.StillProcessing();
compiler.CurrentLine++)
{
logger.Debug.WriteLine(this, compiler, "Parsing Line: " + compiler.CurrentLine);
// Parse our current line of code etc into a
// more usable format.
// - line = The untouched code
// - trim = The code that has whitespace removed.
// - trims = The code that has only the starting whitespace removed
string line = compiler.GetCurrentLine(),
trim = "",
trims = "";
// Support for a multiline comment
if (compiler.commentML)
{
line = SubString(line, compiler.offsetIndex, line.Length);
}
// Trim the code
trim = line.Trim();
trims = line.TrimStart();
if (string.IsNullOrWhiteSpace(trim))
{
// Whitespaced line, append new line with correct tabulation/whitespace.
compiler.WriteLine("", true);
continue;
}
/* 0. Check for starting comment such as // or /* */
{
if (trim.StartsWith("//"))
{
// Just add the line to the file
// - Add the comment to the file with indentation
compiler.WriteLine(trim, true);
continue;
}
else if (trim.StartsWith("/*") && trim.Contains("*/"))
{
// The line contains a multi line comment but it stops on the
// same line. TODO: CHECK FOR CODE.
int comStart = trim.IndexOf("/*"),
comEnd = trim.IndexOf("*/") + 2;
string s1 = SubString(trim, 0, comStart),
com = SubString(trim, comStart, comEnd),
s2 = SubString(trim, comEnd, trim.Length - 2); // What?
// Process s1, write the comment, Process s2.
if (!string.IsNullOrWhiteSpace(s1))
{
s_ProcessBraces(s1, s1, compiler);
}
compiler.WriteLine(com, true);
if (!string.IsNullOrWhiteSpace(s2))
{
s_ProcessBraces(s2, s2, compiler);
}
}
else if (trim.StartsWith("/*"))
{
// This is when the line consists of just a multi line comment
// - Let the compiler process the multi line comment automatically.
compiler.WriteLine(compiler.GetMultiLineComment().Trim(), true);
continue;
}
else if (trim.Contains("/*"))
{
// This means there is code or a character before the comment
// Display code
// - Trim the text to get the code before a multiline comment
// - Write the code
// - Parse multi line comments
var code = SubString(trim, 0, line.IndexOf("/*")).Replace(";", "");
compiler.Write(code, false, true);
compiler.GetMultiLineComment();
continue;
}
}
/* 1. Check for semi-colons */
{
// Count the amount of colons there are on the line
var colcnt = countOcc(";", line);
// If there is more than one colon
if (colcnt >= 1)
{
// If there is 1 colon
if (colcnt == 1)
{
string res1 = trim.Replace(";", ""),
res2 = RemoveNL(res1);
compiler.WriteLine(res2, true);
}
// More than one
else
{
// Multiple instructions
// - Split them into a array
// - Add each instruction on a new line
string[] instructions = line.Split(';');
foreach (string inst in instructions)
{
compiler.WriteLine(RemoveNL(inst.Trim()), true);
}
}
}
else
{
if (s_ProcessBraces(trim, trims, compiler))
{
continue;
}
}
}
}
return(compiler.Output);
}
// Returns if to continue
bool s_ProcessBraces(string trim, string trims, Cache.MessyCompilerCache compiler)
{
// Method namespace etc,
// Something with braces.
// THIS COULD BE A FAKE BRACE
// SUCH AS /*COMMENT*/ { CODE }
// DETECT?
if (trim == "{")
{
// Append ":" after the method/statement
// - Get the list of lines of the output
// - Remove the last line (A line just with a brace)
// - Append ":" to the last item
// - Remove the last item (the statement/method)
var nl = compiler.Output.Split('\n');
nl = nl.Take(nl.Count() - 1).ToArray();
var cnt = nl.Length - 1;
var lin = nl[cnt].Trim() + ":\n";
nl = nl.Take(nl.Count() - 1).ToArray();
// Rebuild the output
// - Set the output to the current array joined by a new line
// and add a new line for the next statement
// - Increment the currentIndent
// - Append the current statement/method etc.
compiler.Output = string.Join("\n", nl) + "\n";
compiler.WriteLine(lin, true);
compiler.currentIndent++; return(true);
}
else if (trim == "}")
{
// Closing brace
// - Decrement the current indent
compiler.currentIndent--; return(true);
}
// Braces with code
// Example: { // Blah
// Example: { /**/ {} }
else if (trim.StartsWith("{"))
{
// TODO: Support for multi braces.
// Increment the currentIndent
compiler.currentIndent++;
// Remove the brace and writeline
compiler.WriteLine(SubString(trim, 0, 1));
}
// Example: /* test */ { // test2
else if (trim.Contains("{"))
{
bool sw = trim.StartsWith("{"),
ew = trim.EndsWith("{");
if (sw)
{
// Append ":" after the method/statement
// - Get the list of lines of the output
// - Remove the last line (A line just with a brace)
// - Append ":" to the last item
// - Remove the last item (the statement/method)
var nl = compiler.Output.Split('\n');
nl = nl.Take(nl.Count() - 1).ToArray();
var cnt = nl.Length - 1;
var lin = nl[cnt].Trim() + ":\n";
nl = nl.Take(nl.Count() - 1).ToArray();
// Rebuild the output
// - Set the output to the current array joined by a new line
// and add a new line for the next statement
// - Increment the currentIndent
// - Append the current statement/method etc.
compiler.Output = string.Join("\n", nl) + "\n";
compiler.WriteLine(lin, true);
compiler.currentIndent++; return(true);
}
else if (ew)
{
trim = SubString(trim, 0, trim.Length - 2);
}
else
{
// The brace is somewhere between 2 statements
var index = trim.IndexOf("{");
string s1 = SubString(trim, 0, index - 1),
s2 = SubString(trim, index + 1, trim.Length - 1);
compiler.WriteLine(s1 + ":", true);
compiler.currentIndent++;
compiler.WriteLine(s2, true);
return(true);
}
compiler.WriteLine(trim, true);
compiler.currentIndent++;
return(true);
}
// Example: } // End !getUses
else if (trim.StartsWith("}"))
{
// We start with the brace, lets just remove it and append the line
trim = SubString(trim, 0, 1);
compiler.currentIndent--;
compiler.WriteLine(trim, true);
return(true);
}
// Example: /**/ }
else if (trim.EndsWith("}"))
{
// We start with the brace, lets just remove it and append the line
trim = SubString(trim, 0, trim.Length - 2);
compiler.WriteLine(trim, true);
}
else if (trim.Contains("}"))
{
bool sw = trim.StartsWith("{"),
ew = trim.EndsWith("{");
if (sw)
{
// Append ":" after the method/statement
// - Get the list of lines of the output
// - Remove the last line (A line just with a brace)
// - Append ":" to the last item
// - Remove the last item (the statement/method)
var nl = compiler.Output.Split('\n');
nl = nl.Take(nl.Count() - 1).ToArray();
var cnt = nl.Length - 1;
var lin = nl[cnt].Trim() + "\n";
nl = nl.Take(nl.Count() - 1).ToArray();
// Rebuild the output
// - Set the output to the current array joined by a new line
// and add a new line for the next statement
// - Increment the currentIndent
// - Append the current statement/method etc.
compiler.Output = string.Join("\n", nl) + "\n";
compiler.WriteLine(lin, true);
compiler.currentIndent++; return(true);
}
else if (ew)
{
trim = SubString(trim, 0, trim.Length - 1);
}
else
{
// The brace is somewhere between 2 statements
var index = trim.IndexOf("}");
string s1 = SubString(trim, 0, index - 1),
s2 = SubString(trim, index + 1, trim.Length);
compiler.WriteLine(s1, true);
compiler.currentIndent++;
compiler.WriteLine(s2, true);
return(true);
}
compiler.WriteLine(trim, true);
compiler.currentIndent++;
return(true);
}
// Example: /* */ {
else if (trim.EndsWith("{"))
{
// Check if the line ends with a space and brace
var flag = (trim.EndsWith(" {"));
// IF the line ends with " {"
// - Remove the last 2 characters and append ":"
// ELSE - Remove the last character (ENDS WITH "}") and append ":"
if (flag)
{
compiler.WriteLine(SubString(trim, 0, trim.Length - 2) + ":");
}
else
{
compiler.WriteLine(SubString(trim, 0, trim.Length - 1) + ":");
}
compiler.currentIndent++; return(true);
}
else if (trim.EndsWith("}"))
{
compiler.currentIndent--; return(true);
}
// OTHER, PROB TODO STUFF
else
{
// Cant figure out what it is but hell lets just add it in anyway for debugging
//
// IF (Settings -> RetainEmptyLineWhitespace)
// - Add trims to the compiler instead of trims to allow whitespace for comments.
// ELSE - Add trim to compiler to remove extra trailing whitespace
if (this._tSet.Syntax.RetainEmptyLineWhitespace)
{
compiler.WriteLine(trims, true);
}
else
{
compiler.WriteLine(trim, true);
}
return(true);
}
return(false);
}