public static void Parse( CharStream stream, string identifier, Internal.LocaleContext.Builder builder) { var startingPos = stream.Position; try { // private identifiers start with an underscore // and can only be referenced from within an l20n file bool isPrivate = (identifier.IndexOf('_') == 0); // an optional index is possible AST.INode index = null; Index.PeekAndParse(stream, out index); // White Space is required WhiteSpace.Parse(stream, false); var valuePos = stream.Position; // Now we need the actual value var value = Value.Parse(stream); if ((value as IO.AST.HashValue) == null && index != null) { string msg = String.Format( "an index was given, but a stringValue was given, while a hashValue was expected", stream.ComputeDetailedPosition(valuePos)); throw new Exceptions.ParseException(msg); } // an optional attributes collection is possible AST.Attributes attributes; Attributes.PeekAndParse(stream, out attributes); // White Space is optional WhiteSpace.Parse(stream, true); stream.SkipCharacter('>'); var entityAST = new AST.Entity(identifier, isPrivate, index, value, attributes); try { var entity = (Objects.Entity)entityAST.Eval(); builder.AddEntity(identifier, entity); } catch (Exception e) { throw new Exceptions.EvaluateException( String.Format("couldn't evaluate `{0}`", entityAST.Display()), e); } } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <entity> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static Info Parse(CharStream stream, Info expected = null) { string output; int pos = stream.Position; if (!stream.ReadReg("(\'|\")", out output)) { throw new Exceptions.ParseException( String.Format( "expected to read a <quote> (starting at {0}), but no characters were left", stream.ComputeDetailedPosition(pos))); } Info info; if (output[0] == '"') { info = new Info(Type.Double); } else { info = new Info(Type.Single); } if (expected != null && expected.CompareTo(info) != 0) { throw new Exceptions.ParseException( String.Format( "expected to read {0} (starting at {1}), but found {2}", expected.ToString(), stream.ComputeDetailedPosition(pos), info.ToString())); } return info; }
public static AST.INode Parse(CharStream stream) { var startingPos = stream.Position; AST.INode expression = null; try { // skip opening tags stream.SkipString("{{"); WhiteSpace.Parse(stream, true); // parse actual expression expression = Expression.Parse(stream); // skip closing tags WhiteSpace.Parse(stream, true); stream.SkipString("}}"); return expression; } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <expander> starting at {0}, expression was: {1} ({2})", stream.ComputeDetailedPosition(startingPos), expression != null ? expression.Display() : "<null>", expression != null ? expression.GetType().ToString() : "null"); throw new Exceptions.ParseException(msg, e); } }
public static AST.INode Parse(CharStream stream) { var startingPos = stream.Position; try { var condition = Expressions.Logic.Parse(stream); // check if we have an IfElse case or simply a logical expression string s; if (stream.ReadReg(@"\s*\?\s*", out s)) { var first = Expression.Parse(stream); WhiteSpace.Parse(stream, true); stream.SkipCharacter(':'); WhiteSpace.Parse(stream, true); var second = Expression.Parse(stream); return new AST.Conditional(condition, first, second); } else { // it's simply a logical expression return condition; } } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <expression> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static string Parse(CharStream stream) { var startingPos = stream.Position; try { var output = ""; var quote = Quote.Parse(stream); char c; while ((c = stream.PeekNext()) != '\0') { if (c == '\\') { output += stream.ForceReadNext(); } else if (Quote.Peek(stream, quote)) { break; // un-escaped quote means we're ending the string } output += stream.ForceReadNext(); } Quote.Parse(stream, quote); return output; } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <string_value> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static void Parse( CharStream stream, string identifier, Internal.LocaleContext.Builder builder) { var startingPos = stream.Position; try { var macroAST = new AST.Macro(identifier); stream.SkipCharacter('('); WhiteSpace.Parse(stream, true); // variables are optional, // but we do have them, we need at least one (duh) if (Expressions.Variable.Peek(stream)) { macroAST.AddParameter(Macro.ParseVariable(stream)); // more than 1 is possible as well while (stream.SkipIfPossible(',')) { WhiteSpace.Parse(stream, true); macroAST.AddParameter(Macro.ParseVariable(stream)); } } stream.SkipCharacter(')'); WhiteSpace.Parse(stream, false); stream.SkipCharacter('{'); WhiteSpace.Parse(stream, true); // Parse the Actual Macro Expression macroAST.SetExpression(Expression.Parse(stream)); WhiteSpace.Parse(stream, true); stream.SkipCharacter('}'); WhiteSpace.Parse(stream, true); stream.SkipCharacter('>'); // return the fully parsed macro try { var macro = (Objects.Macro)macroAST.Eval(); builder.AddMacro(identifier, macro); } catch (Exception e) { throw new Exceptions.EvaluateException( String.Format("couldn't evaluate `{0}`", macroAST.Display()), e); } } catch (Exception e) { string msg = String.Format( "something went wrong parsing a <macro> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static AST.INode Parse(CharStream stream) { var startingPos = stream.Position; try { var first = Binary.Parse(stream); string op; if (stream.ReadReg(@"\s*(\|\||\&\&)", out op)) { WhiteSpace.Parse(stream, true); var second = Logic.Parse(stream); return new AST.LogicExpression( first, second, op.Trim()); } else { return first; } } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <logical_expression> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static AST.HashValue.Item Parse(CharStream stream) { var startingPos = stream.Position; try { // check if a hash item is supposed to be a default bool isDefault = stream.SkipIfPossible('*'); // parse the raw identifier (key) var identifier = Identifier.Parse(stream, false); // whitespace is optional WhiteSpace.Parse(stream, true); // the seperator char is required as it seperates the key and the value stream.SkipCharacter(':'); // more optional whitespace WhiteSpace.Parse(stream, true); // get the actual value, which is identified by the key var value = Value.Parse(stream); return new AST.HashValue.Item(identifier, value, isDefault); } catch (Exception e) { string msg = String.Format( "something went wrong parsing a <hash_item> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
public static AST.INode Parse(CharStream stream) { var startingPos = stream.Position; try { // skip open char stream.SkipCharacter('['); // we need at least one index var index = new AST.Index(ParseExpression(stream)); // others are optional while (stream.SkipIfPossible(',')) { index.AddIndex(ParseExpression(stream)); } // skip close char stream.SkipCharacter(']'); return index; } catch (Exception e) { string msg = String.Format( "something went wrong parsing an <index> starting at {0}", stream.ComputeDetailedPosition(startingPos)); throw new Exceptions.ParseException(msg, e); } }
private static AST.INode ParseExpression(CharStream stream) { WhiteSpace.Parse(stream, true); var expression = Expression.Parse(stream); WhiteSpace.Parse(stream, true); return expression; }
public StandardTokenizer(CharStream stream) { token_source = new StandardTokenizerTokenManager(stream); token = new Token(); jj_ntk = - 1; jj_gen = 0; for (int i = 0; i < 1; i++) jj_la1[i] = - 1; }
public static AST.INode Parse(CharStream stream) { string raw; if (!stream.ReadReg(@"[\-\+]?[0-9]+", out raw)) { throw stream.CreateException("a number literal whas expected"); } return new AST.Literal(raw); }
public static bool PeekAndParse(CharStream stream) { if (stream.PeekNext() != '/' || stream.PeekNext(1) != '*') { return false; } Comment.Parse(stream); return true; }
public static bool PeekAndParse(CharStream stream, out string identifier, bool allow_underscore) { var reg = allow_underscore ? @"[_a-zA-Z]\w*" : @"[a-zA-Z]\w*"; if (!stream.EndOfStream() && stream.ReadReg(reg, out identifier)) { return true; } identifier = null; return false; }
public static bool PeekAndParse(CharStream stream, out AST.Attributes value) { if (KeyValuePair.Peek(stream)) { value = Attributes.Parse(stream); return true; } value = null; return false; }
public static string Parse(CharStream stream, bool allow_underscore) { string identifier; if (!Identifier.PeekAndParse(stream, out identifier, allow_underscore)) { throw stream.CreateException( "expected to read an <identifier>, but non-word character was found"); } return identifier; }
public static bool PeekAndParse(CharStream stream, out AST.HashValue.Item item) { if (stream.PeekNext() == '*' || Identifier.Peek(stream)) { item = HashItem.Parse(stream); return true; } item = null; return false; }
public static bool PeekAndParse(CharStream stream, out string value) { if (StringValue.Peek(stream)) { value = PureStringValue.Parse(stream); return true; } value = null; return false; }
public static bool PeekAndParse(CharStream stream, out AST.Attributes.Item item) { if (KeyValuePair.Peek(stream)) { item = KeyValuePair.Parse(stream); return true; } item = null; return false; }
public static bool PeekAndParse(CharStream stream, out AST.INode expression) { if (stream.PeekNext() == '(' || Primary.Peek(stream)) { expression = Parenthesis.Parse(stream); return true; } expression = null; return false; }
public static bool PeekAndParse( CharStream stream, out AST.INode value) { if (StringValue.PeekAndParse(stream, out value)) return true; if (HashValue.PeekAndParse(stream, out value)) return true; return false; }
public static bool PeekAndParse(CharStream stream, out AST.INode index) { if (stream.PeekNext() != '[') { index = null; return false; } index = Index.Parse(stream); return true; }
private static AST.INode ParseExpression(CharStream stream) { // optional white space WhiteSpace.Parse(stream, true); // first expression var index = Expression.Parse(stream); // optional white space WhiteSpace.Parse(stream, true); return index; }
public static bool PeekAndParse( CharStream stream, out AST.INode expression) { if (stream.PeekReg(@"(\$|\@|\_|)?\w+(\.|\[)")) { expression = Property.Parse(stream); return true; } expression = null; return false; }
public static bool PeekAndParse( CharStream stream, out AST.INode value) { if (HashValue.Peek(stream)) { value = HashValue.Parse(stream); return true; } value = null; return false; }
public static bool PeekAndParse( CharStream stream, out AST.INode expression) { if (stream.PeekNextRange(2) == "{{") { expression = Expander.Parse(stream); return true; } expression = null; return false; }
public void CharStream_CanProperlyOrderCharacters(string input) { var cs = new CharStream(input); foreach (var c in input) { var found = cs.Read(); Assert.True(found.HasValue); Assert.Equal(c, found.Value); } var end = cs.Read(); Assert.True(!end.HasValue); }
public static bool PeekAndParse( CharStream stream, out AST.INode expression) { if (stream.PeekReg(@"[$@]?\w+(\.\w+)*::")) { expression = Attribute.Parse(stream); return true; } expression = null; return false; }
public static bool PeekAndParse( CharStream stream, out AST.INode literal) { if (!Literal.Peek(stream)) { literal = null; return false; } literal = Literal.Parse(stream); return true; }
public static bool PeekAndParse( CharStream stream, out AST.INode variable) { if (!Variable.Peek(stream)) { variable = null; return false; } variable = Variable.Parse(stream); return true; }