public HlTokenReadEvent(HlTokenType expected, HlTokenType got) : base( $"Expected Token '{expected}' but got '{got}'", ErrorEventKeys.s_HlInvalidToken, false ) { }
protected InvalidHlMemberModifiersEvent(HlTokenType a, HlTokenType b) : base( $"Token '{a}' can not be used together with '{b}'", ErrorEventKeys.s_HlInvalidMemberModifiers, false ) { }
public static int ReadList( List <IHlToken> tokens, int start, HlTokenType item, HlTokenType separator, out IHlToken[] items) { List <IHlToken> list = new List <IHlToken>(); int i = start; while (i < tokens.Count && tokens[i].Type == item) { list.Add(tokens[i]); i++; if (i >= tokens.Count || tokens[i].Type != separator) { items = list.ToArray(); return(i - start); } i++; } EventManager <ErrorEvent> .SendEvent( new HlTokenReadEvent( tokens, item, tokens[i].Type, start ) ); items = list.ToArray(); return(i - start); }
/// <summary> /// Public Constructor /// </summary> /// <param name="context">XL Context</param> /// <param name="left">Left Side</param> /// <param name="operationType">Operation FunctionType</param> /// <param name="right">Right Side</param> public HlBinaryOp( HlExpression left, HlTokenType operationType, HlExpression right) : base(left.SourceIndex) { Left = left; OperationType = operationType; Right = right; }
/// <summary> /// Reads Exactly one token of a specified type /// </summary> /// <param name="tokens">Token Stream</param> /// <param name="start">Start Index</param> /// <param name="type">Accepted FunctionType</param> /// <returns></returns> public static IHlToken ReadOne(List <IHlToken> tokens, int start, HlTokenType type) { if (!ReadOneOrNone(tokens, start, type, out IHlToken ret)) { EventManager <ErrorEvent> .SendEvent(new HlTokenReadEvent( tokens, type, ret.Type, start )); } return(ret); }
/// <summary> /// Creates an implemented expression /// </summary> /// <param name="parser">XLExpressionParser</param> /// <param name="currentNode">Current Expression Node</param> /// <returns></returns> public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode) { HlTokenType type = parser.CurrentToken.Type; parser.Eat(type); HlExpression token = new HlUnaryOp(parser.ParseExpr(PrecedenceLevel), type); return(token); }
/// <summary> /// Public Constructor /// </summary> /// <param name="tokenSequence">Token Sequence</param> /// <param name="expected">Expected Token</param> /// <param name="unmatched">Unmatched Token</param> /// <param name="start">Start index in source</param> public HlTokenReadEvent( IEnumerable <IHlToken> tokenSequence, HlTokenType expected, HlTokenType unmatched, int start) : this( tokenSequence, new[] { expected }, unmatched, start ) { }
/// <summary> /// Creates an implemented expression /// </summary> /// <param name="parser">XLExpressionParser</param> /// <param name="currentNode">Current Expression Node</param> /// <returns></returns> public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode) { HlTokenType tt = parser.CurrentToken.Type == HlTokenType.OpPlus ? HlTokenType.OpUnaryPostfixIncrement : HlTokenType.OpUnaryPostfixDecrement; parser.Eat(parser.CurrentToken.Type); parser.Eat(parser.CurrentToken.Type); HlExpression token = new HlUnaryOp(currentNode, tt); return(token); }
/// <summary> /// Public Constructor /// </summary> /// <param name="tokenSequence">Token Sequence</param> /// <param name="expected">Expected Tokens</param> /// <param name="unmatched">Unmatched Token</param> /// <param name="start">Start index in source</param> public HlTokenReadEvent( IEnumerable <IHlToken> tokenSequence, HlTokenType[] expected, HlTokenType unmatched, int start) : base( $"Expected '{GetExpectedTokenString( expected )}' but got '{unmatched} at index {start}'", ErrorEventKeys.s_HlInvalidToken, false ) { m_Sequence = tokenSequence; m_Expected = expected; m_Unmatched = unmatched; }
/// <summary> /// Consumes the Specified Token /// Throws an Error if a different token was found /// </summary> /// <param name="type">Expected Token FunctionType</param> public void Eat(HlTokenType type) { if (CurrentToken.Type == type) { CurrentToken = Reader.GetNext(); } else { EventManager <ErrorEvent> .SendEvent( new HlTokenReadEvent( Reader.Tokens, type, CurrentToken.Type, CurrentToken.SourceIndex ) ); } }
/// <summary> /// reads one or none token of the accepted type /// </summary> /// <param name="tokens">Token Stream</param> /// <param name="start">Start index</param> /// <param name="type">Token FunctionType</param> /// <param name="result">Read Token</param> /// <returns>True if token was read.</returns> public static bool ReadOneOrNone(List <IHlToken> tokens, int start, HlTokenType type, out IHlToken result) { if (start >= 0 && tokens.Count > start) { result = tokens[start]; if (tokens[start].Type == type) { return(true); } return(false); } result = new EofToken(); return(false); }
/// <summary> /// Creates an implemented expression /// </summary> /// <param name="parser">XLExpressionParser</param> /// <param name="currentNode">Current Expression Node</param> /// <returns></returns> public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode) { HlTokenType type = parser.CurrentToken.Type; parser.Eat(parser.CurrentToken.Type); HlExpression node = null; if (type == HlTokenType.OpLessThan) { if (parser.CurrentToken.Type == HlTokenType.OpEquality) { parser.Eat(HlTokenType.OpEquality); node = new HlBinaryOp( currentNode, HlTokenType.OpLessOrEqual, parser.ParseExpr(PrecedenceLevel) ); } else { node = new HlBinaryOp(currentNode, type, parser.ParseExpr(PrecedenceLevel)); } } else if (type == HlTokenType.OpGreaterThan) { if (parser.CurrentToken.Type == HlTokenType.OpEquality) { parser.Eat(HlTokenType.OpEquality); node = new HlBinaryOp( currentNode, HlTokenType.OpGreaterOrEqual, parser.ParseExpr(PrecedenceLevel) ); } else { node = new HlBinaryOp(currentNode, type, parser.ParseExpr(PrecedenceLevel)); } } return(node); }
/// <summary> /// Creates an implemented expression /// </summary> /// <param name="parser">XLExpressionParser</param> /// <param name="currentNode">Current Expression Node</param> /// <returns></returns> public override HlExpression Create(HlExpressionParser parser, HlExpression currentNode) { HlTokenType type = parser.CurrentToken.Type; parser.Eat(type); parser.Eat(type); if (type == HlTokenType.OpLessThan) { type = HlTokenType.OpShiftLeft; } else if (type == HlTokenType.OpGreaterThan) { type = HlTokenType.OpShiftRight; } return(new HlBinaryOp( currentNode, type, parser.ParseExpr(PrecedenceLevel) )); }
/// <summary> /// Creates a Value based on the Current State of the Expression Parser /// </summary> /// <param name="parser">The Parser</param> /// <returns>Parsed Expression</returns> public HlExpression CreateValue(HlExpressionParser parser, uint maxPrecedence) { if (parser.CurrentToken.Type == HlTokenType.OpBang || parser.CurrentToken.Type == HlTokenType.OpTilde || parser.CurrentToken.Type == HlTokenType.OpPlus || parser.CurrentToken.Type == HlTokenType.OpMinus) { if (parser.Reader.PeekNext().Type == HlTokenType.OpPlus) { parser.Eat(HlTokenType.OpPlus); parser.Eat(HlTokenType.OpPlus); HlTokenType t = HlTokenType.OpUnaryPrefixIncrement; HlExpression token = new HlUnaryOp(parser.ParseExpr(), t); return(token); } else if (parser.Reader.PeekNext().Type == HlTokenType.OpMinus) { parser.Eat(HlTokenType.OpMinus); parser.Eat(HlTokenType.OpMinus); HlTokenType t = HlTokenType.OpUnaryPrefixDecrement; HlExpression token = new HlUnaryOp(parser.ParseExpr(), t); return(token); } else { HlTokenType t = parser.CurrentToken.Type; parser.Eat(t); HlExpression token = new HlUnaryOp(parser.ParseExpr(), t); return(token); } } if (parser.CurrentToken.Type == HlTokenType.OpAnd) { HlTokenType t = parser.CurrentToken.Type; parser.Eat(t); HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpReference); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpAsterisk) { HlTokenType t = parser.CurrentToken.Type; parser.Eat(t); HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpDeReference); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpNew && maxPrecedence >= 3) { parser.Eat(parser.CurrentToken.Type); HlExpression token = new HlUnaryOp(parser.ParseExpr(2), HlTokenType.OpNew); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpReturn) { IHlToken rt = parser.CurrentToken; parser.Eat(HlTokenType.OpReturn); if (parser.CurrentToken.Type == HlTokenType.OpSemicolon) { return(new HlReturnOp(null, rt.SourceIndex)); } return(new HlReturnOp(parser.ParseExpr(), rt.SourceIndex)); } if (parser.CurrentToken.Type == HlTokenType.OpContinue) { IHlToken ct = parser.CurrentToken; parser.Eat(HlTokenType.OpContinue); return(new HlContinueOp(ct.SourceIndex)); } if (parser.CurrentToken.Type == HlTokenType.OpBreak) { IHlToken bt = parser.CurrentToken; parser.Eat(HlTokenType.OpBreak); return(new HlBreakOp(bt.SourceIndex)); } if (parser.CurrentToken.Type == HlTokenType.OpIf) { return(HlSpecialOps.ReadIf(parser)); } if (parser.CurrentToken.Type == HlTokenType.OpFor) { return(HlSpecialOps.ReadFor(parser)); } if (parser.CurrentToken.Type == HlTokenType.OpWhile) { return(HlSpecialOps.ReadWhile(parser)); } if (parser.CurrentToken.Type == HlTokenType.OpBracketOpen) { parser.Eat(HlTokenType.OpBracketOpen); HlExpression token = parser.ParseExpr(); parser.Eat(HlTokenType.OpBracketClose); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpThis || parser.CurrentToken.Type == HlTokenType.OpBase) { HlExpression token = new HlVarOperand( parser.CurrentToken, parser.CurrentToken.SourceIndex ); parser.Eat(parser.CurrentToken.Type); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpWord || parser.CurrentToken.Type == HlTokenType.OpNew) { IHlToken item = parser.CurrentToken; parser.Eat(parser.CurrentToken.Type); HlExpression token = new HlVarOperand(item, item.SourceIndex); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpVariableDefinition) { VariableDefinitionToken vd = ( VariableDefinitionToken )parser.CurrentToken; HlVarDefOperand token; if (vd.InitializerExpression != null && vd.InitializerExpression.Length != 0) { HlExpressionParser p = HlExpressionParser.Create(new HlExpressionReader(vd.InitializerExpression.ToList())); token = new HlVarDefOperand(vd, p.Parse()); } else { token = new HlVarDefOperand(vd, new HlExpression[0]); } parser.Eat(HlTokenType.OpVariableDefinition); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpFunctionDefinition) { FunctionDefinitionToken fToken = ( FunctionDefinitionToken )parser.CurrentToken; parser.Eat(HlTokenType.OpFunctionDefinition); HlExpression[] expressionBlock = null; if (fToken.Mods.All(x => x.Type != HlTokenType.OpAbstractMod)) { expressionBlock = HlExpressionParser.Create(new HlExpressionReader(fToken.Block.ToList())). Parse(); } HlExpression token = new HlFuncDefOperand( fToken, expressionBlock ); return(token); } if (parser.CurrentToken.Type == HlTokenType.OpNumber || parser.CurrentToken.Type == HlTokenType.OpDecimalNumber || parser.CurrentToken.Type == HlTokenType.OpStringLiteral || parser.CurrentToken.Type == HlTokenType.OpCharLiteral) { HlExpression token = new HlValueOperand(parser.CurrentToken); parser.Eat(parser.CurrentToken.Type); return(token); } EventManager <ErrorEvent> .SendEvent(new HlTokenReadEvent( HlTokenType.Any, parser.CurrentToken.Type )); return(null); }
/// <summary> /// Public Constructor /// </summary> /// <param name="type">Token FunctionType</param> /// <param name="value">Token Value</param> /// <param name="startIndex">Start index in the source stream</param> public HlTextToken(HlTokenType type, string value, int startIndex) { Type = type; Value = value; SourceIndex = startIndex; }
/// <summary> /// Reads none or many of the specified token /// </summary> /// <param name="tokens">Token Stream</param> /// <param name="start">Start Index</param> /// <param name="step">Step per read token</param> /// <param name="type">Accepted FunctionType</param> /// <returns>Read Tokens</returns> public static IHlToken[] ReadNoneOrMany(List <IHlToken> tokens, int start, int step, HlTokenType type) { List <IHlToken> ret = new List <IHlToken>(); int currentStart = start; while (ReadOneOrNone(tokens, currentStart, type, out IHlToken current)) { currentStart += step; ret.Add(current); } return(ret.ToArray()); }
/// <summary> /// Reads one or many tokens of the specified type /// </summary> /// <param name="tokens">Token Stream</param> /// <param name="start">Start index</param> /// <param name="step">Step per read token</param> /// <param name="type">Accepted Token</param> /// <returns>Read Tokens</returns> public static IHlToken[] ReadOneOrMany(List <IHlToken> tokens, int start, int step, HlTokenType type) { List <IHlToken> ret = new List <IHlToken> { ReadOne(tokens, start, type) }; ret.AddRange(ReadNoneOrMany(tokens, start + step, step, type)); return(ret.ToArray()); }
/// <summary> /// Reads until end of stream or the specified type has been read. /// </summary> /// <param name="tokens">Token Stream</param> /// <param name="start">Start index</param> /// <param name="step">Step per read Token</param> /// <param name="type">End token type</param> /// <returns>Read Tokens</returns> public static IHlToken[] ReadUntil(List <IHlToken> tokens, int start, int step, HlTokenType type) { return(ReadUntilAny(tokens, start, step, new[] { type })); }
/// <summary> /// Protected Constructor /// </summary> /// <param name="type">Token FunctionType</param> /// <param name="subtokens">Child Tokens</param> /// <param name="start">Start index in the source</param> protected CombinedToken(HlTokenType type, IHlToken[] subtokens, int start) { SubTokens = subtokens; SourceIndex = start; Type = type; }
/// <summary> /// Public Constructor /// </summary> /// <param name="context">XL Context</param> /// <param name="left">Left Side</param> /// <param name="operationType">Operation FunctionType</param> public HlUnaryOp(HlExpression left, HlTokenType operationType) : base(left.SourceIndex) { Left = left; OperationType = operationType; }