public override void Parse(MemoryStream ms, ParseState state)
{
/* eat the Local byte */
byte variableType = (byte)ms.ReadByte();
switch(variableType)
{
case 68:
declareType = DeclareType.LOCAL;
break;
case 69:
declareType = DeclareType.GLOBAL;
break;
case 84:
declareType = DeclareType.COMPONENT;
break;
case 86:
declareType = DeclareType.CONSTANT;
break;
case 98:
declareType = DeclareType.INSTANCE;
break;
}
byte nextByte = Peek(ms);
Element stringElement = new PureStringElement();
StringBuilder sb = new StringBuilder();
if (declareType != DeclareType.CONSTANT)
{
while (nextByte != 1)
{
var e = Element.GetNextElement(ms, state, -1);
if (e.Value == ":" && sb[sb.Length - 1] == ' ')
{
sb.Length--;
}
e.Write(sb);
if (e.Value != ":" && sb[sb.Length-1] != ':')
{
sb.Append(" ");
}
nextByte = Peek(ms);
}
VariableType = sb.ToString().Trim();
}
while (nextByte != 21) /* semicolon */
{
Declaration.Add(GetNextElement(ms, state, 0));
nextByte = Peek(ms);
}
/* eat the semicolon */
ms.ReadByte();
}
public override void Parse(MemoryStream ms, ParseState state)
{
/* eat the opening Function byte */
ms.ReadByte();
/* function name */
var stringElement = new PureStringElement();
stringElement.Parse(ms, state);
MethodName = stringElement.Value;
byte nextByte = Peek(ms);
if (nextByte == 11)
{
/* function has parameters */
/* eat open parens */
ms.ReadByte();
nextByte = Peek(ms);
while (nextByte != 20) /* close paren */
{
stringElement.Parse(ms, state);
var paramName = stringElement.Value;
/* eat the "as" */
ms.ReadByte();
stringElement.Parse(ms, state);
var paramType = stringElement.Value;
Params.Add(new Parameter() { Name = paramName, Type = paramType });
nextByte = Peek(ms);
if (nextByte == 3) /* comma */
{
ms.ReadByte();
nextByte = Peek(ms);
}
}
/* eat close parens */
ms.ReadByte();
}
/* eat the newline */
ms.ReadByte();
while (nextByte != 55) /* end function */
{
Element nextElement = Element.GetNextElement(ms, state, IndentLevel,true);
Body.Add(nextElement);
nextByte = Peek(ms);
}
/* eat end-function */
ms.ReadByte();
/* eat the semicolon */
ms.ReadByte();
}
public override void Parse(MemoryStream ms, ParseState state)
{
/* eat the method byte */
ms.ReadByte();
Element stringElement = new PureStringElement();
stringElement.Parse(ms, state);
MethodName = stringElement.Value;
/* eat the open paren */
ms.ReadByte();
byte nextByte = Peek(ms);
while (nextByte != 20) /* close paren */
{
stringElement.Parse(ms, state);
var paramName = stringElement.Value;
/* eat the "as" */
ms.ReadByte();
stringElement.Parse(ms, state);
var paramType = stringElement.Value;
Params.Add(new Parameter() { Name = paramName, Type = paramType });
nextByte = Peek(ms);
if (nextByte == 3)
{
/* eat the comma */
ms.ReadByte();
nextByte = Peek(ms);
}
}
/* eat the close paren */
ms.ReadByte();
if (Peek(ms) == 57)
{
/* has a return value */
/* eat the "Returns" */
ms.ReadByte();
nextByte = Peek(ms);
while (nextByte != 21) /* semicolon */
{
stringElement.Parse(ms, state);
ReturnType += stringElement.Value + " ";
nextByte = Peek(ms);
}
ReturnType = ReturnType.Trim();
}
/* eat the semicolon */
ms.ReadByte();
}
public override void Parse(MemoryStream ms, ParseState state)
{
/* eat comment marker */
byte commentType = (byte) ms.ReadByte();
if (commentType == 36)
{
Type = CommentType.SLASH_STAR;
}
else if (commentType == 78)
{
//TODO: make a global string writer to use instead of each element making its own string builder
Type = CommentType.SLASH_STAR_SAME_LINE;
}
else if (commentType == 85)
{
Type = CommentType.ANGLE_STAR;
}
else if (commentType == 109)
{
Type = CommentType.SLASH_PLUS;
}
if (Type == CommentType.SLASH_PLUS)
{
ms.Seek(-1, SeekOrigin.Current);
PureStringElement commentText = new PureStringElement();
commentText.Parse(ms, state);
this.Value = "/+ " + commentText.Value + " +/";
} else
{
byte[] bShort = new byte[2];
bShort[0] = (byte)ms.ReadByte();
bShort[1] = (byte)ms.ReadByte();
int commentLength = BitConverter.ToInt16(bShort, 0);
byte[] commentData = new byte[commentLength];
ms.Read(commentData, 0, commentLength);
string s = Encoding.Unicode.GetString(commentData);
s = s.Replace("\r\n", "\n"); // CRLF to LF
s = s.Replace("\n", "\r\n"); // LF to CRLF
this.Value = s;
}
}
public override void Parse(MemoryStream ms, ParseState state)
{
/* eat the Property byte */
byte variableType = (byte)ms.ReadByte();
byte nextByte = Peek(ms);
Element stringElement = new PureStringElement();
while (nextByte != 10)
{
stringElement.Parse(ms, state);
VariableType += stringElement.Value + " ";
nextByte = Peek(ms);
}
VariableType = VariableType.Trim();
while (nextByte != 21) /* semicolon */
{
if (nextByte == 95)
{
HasGet = true;
ms.ReadByte();
}
else if (nextByte == 73)
{
HasSet = true;
ms.ReadByte();
}
else
{
Declaration.Add(GetNextElement(ms, state, 0));
}
nextByte = Peek(ms);
}
/* eat the semicolon */
ms.ReadByte();
}
public override void Parse(MemoryStream ms, ParseState state)
{
/* eat the method byte */
ms.ReadByte();
/* eat the 65 byte ? */
ms.ReadByte();
Element stringElement = new PureStringElement();
stringElement.Parse(ms, state);
MethodName = stringElement.Value;
if (MethodName == "createObject")
{
//Debugger.Break();
}
/* eat new line */
Element.GetNextElement(ms, state, IndentLevel, false);
while (Peek(ms) != 100)
{
state.AlternateBreak = 100;
Element nextElement = Element.GetNextElement(ms, state, IndentLevel,true);
Body.Add(nextElement);
if (Peek(ms) == 21)
{
ms.ReadByte();
}
}
/* eat the end method */
ms.ReadByte();
/* eat the semicolon */
ms.ReadByte();
}
public static Element GetNextElement(MemoryStream ms, ParseState state, int indentationLevel, bool collapsePrimitives = false)
{
bool isPrimitive = false;
byte nextByte = Peek(ms);
/* bytes that we should just skip */
if (nextByte == 65)
{
/* this is for "AND" inside an IF */
ms.ReadByte();
nextByte = Peek(ms);
}
Element nextElement;
switch (nextByte)
{
case 0:
case 1:
case 10:
case 18:
isPrimitive = true;
nextElement = new PureStringElement();
break;
case 3:
case 4:
case 5:
case 6:
case 8:
case 9:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 19:
case 20:
case 21:
case 35:
case 46:
case 67:
case 75:
case 76:
case 77:
case 87:
case 105:
isPrimitive = true;
nextElement = new OperatorElement();
break;
case 22:
isPrimitive = true;
nextElement = new QuotedStringElement();
break;
case 24:
case 29:
case 30:
case 47:
case 48:
isPrimitive = true;
nextElement = new BooleanLogicElement();
break;
case 28:
nextElement = new IfElement();
break;
case 33:
case 74:
isPrimitive = true;
nextElement = new ReferenceElement();
break;
case 36:
case 78:
case 85:
case 109:
nextElement = new CommentElement();
break;
case 37:
nextElement = new WhileElement();
break;
case 41:
nextElement = new ForElement();
break;
case 45:
case 79:
nextElement = new NewLineElement();
break;
case 49:
nextElement = new DeclareFunctionElement();
break;
case 50:
nextElement = new FunctionElement();
break;
case 56:
isPrimitive = true;
nextElement = new ReturnElement();
break;
case 60:
nextElement = new EvaluateElement();
break;
case 64:
nextElement = new PureStringElement();
break;
case 66:
nextElement = new PureStringElement();
ms.ReadByte();
nextElement.Value = "";
return nextElement;
case 68:
case 69:
case 84:
case 86:
case 98:
nextElement = new VariableDeclarationElement();
break;
case 80:
isPrimitive = true;
nextElement = new NumberElement();
break;
case 88:
nextElement = new ImportElement();
break;
case 89:
nextElement = new OperatorElement();
break;
case 90:
nextElement = new ClassElement();
break;
case 94:
nextElement = new PropertyElement();
break;
case 95:
nextElement = new GetterElement();
break;
case 73:
nextElement = new SetterElement();
break;
case 99:
if (state.InClassDefn)
{
nextElement = new MethodDeclarationElement();
} else
{
nextElement = new MethodElement();
//nextElement = new MethodElement();
}
break;
case 101:
nextElement = new TryElement();
break;
case 104:
nextElement = new ThrowElement();
break;
default:
return null;
}
nextElement.IndentLevel = indentationLevel + 1;
nextElement.Parse(ms, state);
if (isPrimitive && collapsePrimitives && Peek(ms) != state.AlternateBreak) {
StringBuilder sb = new StringBuilder();
nextElement.Write(sb);
/* we found a "primitive" (non-control struct), lets collapse until we see a semicolon */
var tempElement = GetNextElement(ms, state, indentationLevel, false);
while (tempElement != null && (tempElement.Value == null || tempElement.Value.Equals(";") == false || tempElement is NewLineElement))
{
tempElement.Write(sb);
if (Peek(ms) == state.AlternateBreak)
{
break;
}
tempElement = GetNextElement(ms, state, -1, false);
}
string finalLine = sb.ToString().Trim() + ";\r\n";
nextElement = new PureStringElement();
nextElement.IndentLevel = indentationLevel + 1;
nextElement.Value = finalLine;
}
return nextElement;
}
public override void Parse(MemoryStream ms, ParseState state)
{
Element stringElement = new PureStringElement();
stringElement.Parse(ms, state);
Value = "\"" + stringElement.Value.Replace("\"","\"\"") + "\"";
}
public override void Parse(MemoryStream ms, ParseState state)
{
Element stringElement = new PureStringElement();
/* eat the class byte */
ms.ReadByte();
state.InClassDefn = true;
stringElement.Parse(ms, state);
ClassName = stringElement.Value;
byte nextByte = Peek(ms);
if (nextByte == 114) /* implements */
{
/* eat implements byte */
ms.ReadByte();
do
{
if (Peek(ms) == 87)
{
Implements += Element.GetNextElement(ms, state, 0).Value;
}
Implements += Element.GetNextElement(ms, state, 0).Value;
} while (Peek(ms) == 87);
}
while (nextByte != 91 && nextByte != 97 && nextByte != 115)
{
Element nextElement = Element.GetNextElement(ms, state,IndentLevel);
Public.Add(nextElement);
nextByte = Peek(ms);
}
if (nextByte == 115) /* has protected section */
{
/* eat protected byte */
ms.ReadByte();
while (nextByte != 91 && nextByte != 97)
{
Element nextElement = Element.GetNextElement(ms, state, IndentLevel);
Protected.Add(nextElement);
nextByte = Peek(ms);
}
}
if (nextByte == 97) /* has private section */
{
/* eat private byte */
ms.ReadByte();
while (nextByte != 91)
{
Element nextElement = Element.GetNextElement(ms, state, IndentLevel);
Private.Add(nextElement);
nextByte = Peek(ms);
}
}
/* eat the end-class */
ms.ReadByte();
state.InClassDefn = false;
/* eat the semicolon */
ms.ReadByte();
/* class defn has been parsed, now for the body */
while (Peek(ms) != 7)
{
Element nextElement = Element.GetNextElement(ms, state, IndentLevel - 1);
Body.Add(nextElement);
}
nextByte = Peek(ms);
/* handle parse options */
if (state.Options.AlphabetizeMethodDeclarations)
{
List<MethodDeclarationElement> methods = new List<MethodDeclarationElement>();
List<int> indexes = new List<int>();
/* process Public */
for (var x = 0; x < Public.Count; x++)
{
if (Public[x] is MethodDeclarationElement)
{
methods.Add((MethodDeclarationElement)Public[x]);
indexes.Add(x);
}
}
methods = methods.OrderBy(p => p.MethodName).ToList<MethodDeclarationElement>();
for (var x = 0; x < indexes.Count; x++)
{
Public[indexes[x]] = methods[x];
}
methods.Clear();
indexes.Clear();
/* process Protected */
for (var x = 0; x < Protected.Count; x++)
{
if (Protected[x] is MethodDeclarationElement)
{
methods.Add((MethodDeclarationElement)Protected[x]);
indexes.Add(x);
}
}
methods = methods.OrderBy(p => p.MethodName).ToList<MethodDeclarationElement>();
for (var x = 0; x < indexes.Count; x++)
{
Protected[indexes[x]] = methods[x];
}
methods.Clear();
indexes.Clear();
/* process Private */
for (var x = 0; x < Private.Count; x++)
{
if (Private[x] is MethodDeclarationElement)
{
methods.Add((MethodDeclarationElement)Private[x]);
indexes.Add(x);
}
}
methods = methods.OrderBy(p => p.MethodName).ToList<MethodDeclarationElement>();
for (var x = 0; x < indexes.Count; x++)
{
Private[indexes[x]] = methods[x];
}
methods.Clear();
indexes.Clear();
}
if (state.Options.MatchMethodDeclarationOrder)
{
/* get ordered list of all declares */
List<MethodDeclarationElement> declares = new List<MethodDeclarationElement>();
foreach(var e in Public.Concat(Protected).Concat(Private).ToList())
{
if (e is MethodDeclarationElement)
{
declares.Add((MethodDeclarationElement)e);
}
}
/* search body for all methods */
List<MethodElement> methods = new List<MethodElement>();
List<int> methodIndexes = new List<int>();
for (var x = 0; x < Body.Count; x++)
{
if (Body[x] is MethodElement)
{
methods.Add((MethodElement)Body[x]);
methodIndexes.Add(x);
}
}
for (var x = 0; x < declares.Count; x++)
{
MethodElement currMethod = methods.Where(m => m.MethodName == declares[x].MethodName).First();
Body[methodIndexes[x]] = currMethod;
}
}
if (state.Options.PairGetSets)
{
List<GetterElement> getters = new List<GetterElement>();
List<SetterElement> setters = new List<SetterElement>();
List<int> indexes = new List<int>();
for(var x = 0; x < Body.Count; x++)
{
if (Body[x] is GetterElement)
{
getters.Add((GetterElement)Body[x]);
indexes.Add(x);
}
if (Body[x] is SetterElement)
{
setters.Add((SetterElement)Body[x]);
indexes.Add(x);
}
}
List<Tuple<GetterElement, SetterElement>> pairs = new List<Tuple<GetterElement, SetterElement>>();
foreach (var g in getters)
{
var s = setters.Where(p => p.PropertyName == g.PropertyName).FirstOrDefault();
if (s != null) {
pairs.Add(new Tuple<GetterElement, SetterElement>(g, s));
}
}
/* remove paired items from other lists */
foreach (var t in pairs)
{
getters.Remove(t.Item1);
setters.Remove(t.Item2);
}
var y = 0;
for (var x = 0; x < pairs.Count; x+=2)
{
Body[indexes[x]] = pairs[y].Item1;
Body[indexes[x + 1]] = pairs[y++].Item2;
}
/* add leftover getters */
for (var x = pairs.Count; x < getters.Count; x++)
{
Body[indexes[x]] = getters[x];
}
/* add leftover setters */
for (var x = pairs.Count + getters.Count; x < setters.Count; x++)
{
Body[indexes[x]] = setters[x];
}
}
}
