public new static TCall LeftClaim(StringClaimer claimer, TExpression left) { Claim lb = claimer.Claim(LeftBracket); if (!lb.Success) // Left Bracket is a requirement. { return(null); } lb.Pass(); // At this point, we cannot fail. TCall newCall = new TCall { _caller = left }; while (true) { Claim rb = claimer.Claim(RightBracket); if (rb.Success) { rb.Pass(); break; } TArgument newArg = TArgument.Claim(claimer); if (newArg == null) { break; } newCall._arguments.Add(newArg); claimer.Claim(Comma); } return(newCall); }
public new static TParenExpression Claim(StringClaimer claimer) { Claim lb = claimer.Claim(LeftBracket); if (!lb.Success) { return(null); } TParenExpression ptoken = new TParenExpression { _realExpression = TExpression.Claim(claimer) }; if (ptoken._realExpression == null) { lb.Fail(); return(null); } lb.Pass(); Claim rb = claimer.Claim(RightBracket); if (rb.Success) { rb.Pass(); // right bracket is optional. So just pass it if we get it. } return(ptoken); }
public new static TWhile Claim(StringClaimer claimer) { Claim failpoint = claimer.FailPoint(); Claim c = claimer.Claim(While); if (!c.Success) { failpoint.Fail(); return(null); } TExpression condition = TExpression.Claim(claimer); if (condition == null) { failpoint.Fail(); return(null); } TExpression action = TExpression.Claim(claimer); TWhile whileBlock = new TWhile { _condition = condition, _action = action }; return(whileBlock); }
public new static TBlock Claim(StringClaimer claimer) { Claim c = claimer.Claim(LeftBracket); if (!c.Success) { return(null); } c.Pass(); TBlock newBlock = new TBlock(); TExpression nExp; while ((nExp = TExpression.Claim(claimer)) != null) { newBlock._expressions.Add(nExp); claimer.Claim(SemiColon); if (!(c = claimer.Claim(RightBracket)).Success) { continue; } c.Pass(); return(newBlock); } return(newBlock); }
private static TExpression pre_claim(StringClaimer claimer) { return(TAssignment.Claim(claimer) ?? TIf.Claim(claimer) ?? TFor.Claim(claimer) ?? TWhile.Claim(claimer) ?? TVariable.Claim(claimer) ?? TLiteral.Claim(claimer) ?? TParenExpression.Claim(claimer) ?? TBlock.Claim(claimer) as TExpression); }
public new static TArgExpression Claim(StringClaimer claimer) { TExpression heldExpr = TExpression.Claim(claimer); if (heldExpr == null) { return(null); } TArgExpression newArgExp = new TArgExpression { _heldExp = heldExpr }; return(newArgExp); }
public new static TLiteralStringSimple Claim(StringClaimer claimer) { Claim c = claimer.Claim(String); if (!c.Success) { return(null); } c.Pass(); TLiteralStringSimple str = new TLiteralStringSimple { _value = new VarString(Regex.Unescape(c.GetMatch().Groups["text"].Value)) }; return(str); }
public new static TExpression Claim(StringClaimer claimer) { TExpression preClaimed = pre_claim(claimer); if (preClaimed == null) { return(null); } TExpression nextClaim; while ((nextClaim = post_claim(claimer, preClaimed)) != null) { preClaimed = nextClaim; } return(preClaimed); }
public new static TIf Claim(StringClaimer claimer) { Claim failpoint = claimer.FailPoint(); Claim c = claimer.Claim(If); if (!c.Success) { failpoint.Fail(); return(null); } TExpression condition = TExpression.Claim(claimer); if (condition == null) { failpoint.Fail(); return(null); } TExpression action = TExpression.Claim(claimer); TIf ifblock = new TIf { _condition = condition, _action = action }; c = claimer.Claim(Else); if (!c.Success) { return(ifblock); } TExpression otherwise = TExpression.Claim(claimer); if (otherwise == null) { c.Fail(); } else { ifblock._otherwise = otherwise; c.Pass(); } return(ifblock); }
public new static TOperator Claim(StringClaimer claimer) { foreach (var thisOp in Operators) { Claim c = claimer.Claim(thisOp.Regex); if (!c.Success) { continue; } c.Pass(); TOperator newOp = new TOperator { _op = thisOp }; return(newOp); } return(null); }
public new static TIdentifier Claim(StringClaimer claimer) { TIdentifier ident = new TIdentifier(); Claim c = claimer.Claim(Local); if (c.Success) { c.Pass(); ident._isLocal = true; } c = claimer.Claim(Identifier); if (!c.Success) { return(null); } ident.Name = c.GetText(); return(ident); }
public new static TLeftExpression Claim(StringClaimer claimer) { Claim failTo = claimer.FailPoint(); TExpression newLeft = TExpression.Claim(claimer); if (newLeft == null) { failTo.Fail(); return(null); } newLeft = LeftClaim(claimer, newLeft); if (newLeft != null) { return((TLeftExpression)newLeft); } failTo.Fail(); return(null); }
public new static TLiteralNumber Claim(StringClaimer claimer) { TLiteralNumber numb = new TLiteralNumber(); Claim claim = claimer.Claim(Number); if (!claim.Success) { return(null); } claim.Pass(); double v; Match m = claim.GetMatch(); if (m.Groups["integer"].Length > 0) { // x or b integer format. v = m.Groups["hex_val"].Length > 0 ? int.Parse(m.Groups["hex_val"].Value, NumberStyles.HexNumber) : Convert.ToInt32(m.Groups["bin_val"].Value, 2); } else { var num = m.Groups["int"].Length > 0 ? m.Groups["int"].Value : m.Groups["float"].Value; v = Convert.ToDouble(num); if (m.Groups["expon"].Length > 0) { for (int i = Convert.ToInt32(m.Groups["expon"].Value); i > 0; i--) { v *= 10; } } } if (m.Groups["negative"].Length > 0) // Has a - { v *= -1; } numb._value = new VarNumber(v); return(numb); }
public new static TLeftExpression LeftClaim(StringClaimer claimer, TExpression left) { Claim failTo = claimer.FailPoint(); TOperator operand = TOperator.Claim(claimer); if (operand == null) { failTo.Fail(); return(null); } TExpression right = TExpression.Claim(claimer); if (right == null) { failTo.Fail(); return(null); } TArithmetic newArith = new TArithmetic { _leftArg = left, _rightArg = right, _op = operand }; if (!(right is TLeftExpression t) || t.GetAssociativity() == Associativity.Na) { return(newArith); } int prec = operand.GetPrecedence(); int rPrec = t.GetPrecedence(); if (prec >= rPrec && (prec != rPrec || operand.GetAssociativity() != Associativity.LeftToRight)) { return(newArith); } newArith._rightArg = t.GetLeft(); t.SetLeft(newArith); return(t); }
new public static TFor Claim(StringClaimer claimer) { Claim c = claimer.Claim(FOR); if (!c.Success) { return(null); } TExpression[] exprs = new TExpression[4]; claimer.Claim(LEFT_BRACKET); int claimed = 0; for (; claimed < 3; claimed++) { if ((exprs[claimed] = TExpression.Claim(claimer)) == null) // Out of Expressions. :( { break; } } claimed--; c = claimer.Claim(RIGHT_BRACKET); if ((exprs[3] = TExpression.Claim(claimer)) == null && !c.Success) { if (claimed >= 0 && exprs[claimed] != null) { exprs[3] = exprs[claimed]; exprs[claimed] = null; } } TFor newFor = new TFor(); newFor.initial = exprs[0]; newFor.condition = exprs[1]; newFor.after = exprs[2]; newFor.body = exprs[3]; return(newFor); }
public new static TAssignment Claim(StringClaimer claimer) { Claim failTo = claimer.FailPoint(); TVariable toAssign = TVariable.Claim(claimer); if (toAssign == null) { failTo.Fail(); return(null); } TOperator newOp = TOperator.Claim(claimer); Claim c = claimer.Claim(Set); if (!c.Success) { failTo.Fail(); return(null); } TExpression assignValue = TExpression.Claim(claimer); if (assignValue == null) { failTo.Fail(); return(null); } TAssignment newAssign = new TAssignment { _var = toAssign, _op = newOp, _value = assignValue }; return(newAssign); }
public new static TLiteral Claim(StringClaimer claimer) { return(TLiteralNumber.Claim(claimer) ?? TLiteralStringSimple.Claim(claimer) as TLiteral); }
public static TLeftExpression LeftClaim(StringClaimer claimer, TExpression left) => null;
public static Token Claim(StringClaimer claimer) { return(null); }
private static TExpression post_claim(StringClaimer claimer, TExpression lastClaim) { return(TCall.LeftClaim(claimer, lastClaim) ?? TArithmetic.LeftClaim(claimer, lastClaim)); }
public new static TVariable Claim(StringClaimer claimer) { TVariable result; return((result = TIdentifier.Claim(claimer)) != null ? result : null); }
public new static TArgument Claim(StringClaimer claimer) { return(TArgExpression.Claim(claimer)); }