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]; } } }