public double Eval(Expression es)
{
switch (Kind)
{
case TokenKind.Number: return Num;
case TokenKind.Identifier: return es.GetVar(Ident);
case TokenKind.Add: return Tok1.Eval(es) + Tok2.Eval(es);
case TokenKind.Mul: return Tok1.Eval(es) * Tok2.Eval(es);
case TokenKind.Sub: return (Tok2==null) ? -Tok1.Eval(es) : (Tok1.Eval(es) - Tok2.Eval(es));
case TokenKind.Div: return Tok1.Eval(es) / Tok2.Eval(es);
case TokenKind.Eq: return (Math.Abs(Tok1.Eval(es)-Tok2.Eval(es)) < 1e-6) ? 1:0;
case TokenKind.Neq: return (Math.Abs(Tok1.Eval(es)-Tok2.Eval(es)) < 1e-6) ? 0:1;
case TokenKind.Leq: return (Tok1.Eval(es) <= Tok2.Eval(es)) ? 1:0;
case TokenKind.Geq: return(Tok1.Eval(es) >= Tok2.Eval(es)) ? 1:0;
case TokenKind.Le: return (Tok1.Eval(es) < Tok2.Eval(es)) ? 1:0;
case TokenKind.Ge: return(Tok1.Eval(es) > Tok2.Eval(es)) ? 1:0;
case TokenKind.Mod: return(Tok1.Eval(es) % Tok2.Eval(es));
case TokenKind.If: return (Math.Abs(Tok1.Eval(es))>1e-6) ? Tok2.Eval(es):Tok3.Eval(es);
case TokenKind.Shl: return (int)Tok1.Eval(es)<<(int)Tok2.Eval(es);
case TokenKind.Shr: return (int)Tok1.Eval(es)>>(int)Tok2.Eval(es);
case TokenKind.And: return (Math.Abs(Tok1.Eval(es))>1e-6 && Math.Abs(Tok2.Eval(es))>1e-6) ?1:0;
case TokenKind.Or: return (Math.Abs(Tok1.Eval(es))>1e-6 || Math.Abs(Tok2.Eval(es))>1e-6) ?1:0;
case TokenKind.BitAnd: return (int)Tok1.Eval(es)&(int)Tok2.Eval(es);
case TokenKind.BitOr: return (int)Tok1.Eval(es)|(int)Tok2.Eval(es);
case TokenKind.BitXor: return (int)Tok1.Eval(es)^(int)Tok2.Eval(es);
default: throw new ExpressionException("Unknown operator: " + Kind.ToString());
}
}
public static string GetText(this TokenKind kind)
{
// ToDo: SourceCodeGenerators would be better for this
if (!kind.HasDefaultText())
{
#if DEBUG
var attr = typeof(TokenKind).GetMember(kind.ToString())
.FirstOrDefault(m => m.DeclaringType == typeof(TokenKind))
.GetCustomAttribute <DescriptionAttribute>();
Debug.Assert(attr is null, $"TokenKind.{kind} should have HasDefaultText == true");
#endif
return(null);
}
var attribute = typeof(TokenKind).GetMember(kind.ToString())
.FirstOrDefault(m => m.DeclaringType == typeof(TokenKind))
.GetCustomAttribute <DescriptionAttribute>();
if (attribute is null)
{
throw new Exception(
$"TokenKind.{kind} should have a Description attribute with the default text");
}
return(attribute.Description);
}
private static string GetTokenKindName(TokenKind kind)
{
var type = kind.GetType();
var memberInfo = type.GetMember(kind.ToString());
if (memberInfo.Length <= 0)
{
return(kind.ToString());
}
var attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
return(attrs.Length > 0
? ((DescriptionAttribute)attrs[0]).Description
: kind.ToString());
}
public static bool HasDefaultText(this TokenKind kind)
{
switch (kind)
{
case TokenKind.EoF:
case TokenKind.Plus:
case TokenKind.Minus:
case TokenKind.Star:
case TokenKind.ForwardSlash:
case TokenKind.Bang:
case TokenKind.BangEquals:
case TokenKind.Ampersand:
case TokenKind.AmpersandAmperand:
case TokenKind.Equals:
case TokenKind.EqualsEquals:
case TokenKind.Pipe:
case TokenKind.PipePipe:
case TokenKind.OpenParenthesis:
case TokenKind.CloseParenthesis:
case TokenKind.OpenBrace:
case TokenKind.CloseBrace:
case TokenKind.Comma:
case TokenKind.Colon:
case TokenKind.SemiColon:
case TokenKind.Less:
case TokenKind.LessOrEquals:
case TokenKind.Greater:
case TokenKind.GreaterOrEquals:
case TokenKind.Tilde:
case TokenKind.Hat:
return(true);
case TokenKind.BreakKeyword:
case TokenKind.ContinueKeyword:
case TokenKind.ElseKeyword:
case TokenKind.IfKeyword:
case TokenKind.FalseKeyword:
case TokenKind.ForKeyword:
case TokenKind.FunctionKeyword:
case TokenKind.LetKeyword:
case TokenKind.ReturnKeyword:
case TokenKind.ToKeyword:
case TokenKind.TrueKeyword:
case TokenKind.VarKeyword:
case TokenKind.WhileKeyword:
return(true);
default:
#if DEBUG
// Extra check on the codebase
var attr = typeof(TokenKind).GetMember(kind.ToString())
.FirstOrDefault(m => m.DeclaringType == typeof(TokenKind))
.GetCustomAttribute <DescriptionAttribute>();
Debug.Assert(attr is null, $"TokenKind.{kind} should have HasDefaultText == true");
#endif
return(false);
}
}
private Token Match(TokenKind kind)
{
if (_lookahead.Kind == kind)
return ReadToken();
throw new ParserError(_lookahead.Position, "Expected '" + kind.ToString() + "', found '" + _lookahead.ToString() + "'");
}
public override void PrintOp(int depth)
{
base.PrintOp(depth);
//Console.WriteLine(this.ToString());
LeftExpression.PrintOp(depth + 1);
Console.WriteLine("\t" + Op.ToString());
RightExpression.PrintOp(depth + 1);
}
internal static string ToString(TokenKind spec)
{
#if SALTARELLE
return(Enum.ToString(typeof(TokenKind), spec));
#else
return(spec.ToString());
#endif
}
private Token Match(TokenKind kind)
{
if (_lookahead.Kind == kind)
{
return(ReadToken());
}
throw new ParserError(_lookahead.Position, "Expected '" + kind.ToString() + "', found '" + _lookahead.ToString() + "'");
}
//reporting the error
void ReportError(Token received, TokenKind expected)
{
if (received.Kind.ToString() != expected.ToString())
{
System.Console.WriteLine("The token We have is : " + "[" + received + "]" + "The token we expected is : " + "[" + expected + "]");
}
errorCount++;
}
private void Accept(TokenKind expected)
{
if (currentToken.Kind == expected)
{
AcceptIt();
}
else
{
SyntaxError(expected.ToString() + " expected, but "+currentToken.Kind+" was found");
}
}
public override void PrintOp(int depth)
{
base.PrintOp(depth);
for (var i = 0; i <= depth; i++)
{
Console.Write('\t');
}
Console.WriteLine(Op.ToString());
Expression.PrintOp(depth + 1);
}
public override string ToString()
{
if (Kind == TokenKind.Number)
{
return(Value.ToString());
}
else
{
return(Kind.ToString());
}
}
public static string GetDescription(this TokenKind kind)
{
var type = typeof(TokenKind);
var memInfo = type.GetMember(kind.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(TokenDescriptionAttribute), false);
if (attributes.Length > 0)
{
return(((TokenDescriptionAttribute)attributes[0]).Description);
}
return(String.Empty);
}
// Проверить, что тип текущего распознанного токена совпадает с заданным.
// Если совпадает, то распознать следующий токен, иначе синтаксическая ошибка.
private Token Match(TokenKind tkn)
{
if (lexAn.Token.Type == tkn) // Сравниваем.
{
var token = lexAn.Token;
lexAn.RecognizeNextToken(); // Распознаем следующий токен.
return(token);
}
else
{
SyntaxError("Ожидалось " + tkn.ToString()); // Обнаружена синтаксическая ошибка.
}
return(null);
}
static public string TokenKindToString(TokenKind s)
{
switch (s)
{
case TokenKind.ADD:
return("+");
case TokenKind.SUB:
return("-");
case TokenKind.LPAR:
return("(");
case TokenKind.RPAR:
return(")");
case TokenKind.LBRA:
return("{");
case TokenKind.RBRA:
return("}");
case TokenKind.LT:
return("<");
case TokenKind.GT:
return(">");
case TokenKind.EQU:
return("=");
case TokenKind.SEMI:
return(";");
case TokenKind.END:
return("#");
default:
return(s.ToString());
}
}
protected void Expect(TokenKind kind, string text = null)
{
bool emitError = true;
while (enumerator_.TryPeek(out var next))
{
if (kind == next.Kind && (text == null || text.Equals(next.Text, StringComparison.OrdinalIgnoreCase)))
{
enumerator_.MoveNext();
return;
}
if (emitError)
{
if (text != null && kind == next.Kind)
{
EmitError(string.Format(Errors.UnexpectedTokenText, text, next.Text));
}
else
{
EmitError(string.Format(Errors.UnexpectedTokenKind,
text != null ? $"{kind}('{text}')" : kind.ToString(),
$"{next.Kind}('{next.Text}')"));
}
emitError = false;
}
if (CanRecoverInParentScope(next.Kind, next.Text, out var scope))
{
throw new ErrorRecoveryException(scope);
}
enumerator_.MoveNext();
}
throw new ParsingException(Errors.UnexpectedEndOfFile, CurrentToken.Span);
}
/// <summary>
/// 各種トークンを受け取りStringBuilderに格納します
/// </summary>
public void Write(TokenKind kind, string value)
{
switch (kind)
{
case TokenKind.None:
builder.Append(Escape(value));
break;
case TokenKind.WhiteSpace:
case TokenKind.EOL:
builder.Append(Escape(value));
break;
default:
builder.Append("<span class=\"" + kind.ToString() + "\">" + Escape(value) + "</span>");
break;
}
}
public override string ToString()
{
return(kind.ToString());
}
private string BuildFilename(TokenKind kind)
{
return(kind.ToString() + "_" + AccessTokenFn);
}
private OperatorKind TokenKindToOperator(Position position, TokenKind kind)
{
switch (kind)
{
case TokenKind.Asterisk: return(OperatorKind.Multiplication);
case TokenKind.Backslash: return(OperatorKind.Difference);
case TokenKind.Equal: return(OperatorKind.Equality);
case TokenKind.GreaterThan: return(OperatorKind.GreaterThan);
case TokenKind.LessThan: return(OperatorKind.LessThan);
case TokenKind.Minus: return(OperatorKind.Subtraction);
case TokenKind.Plus: return(OperatorKind.Addition);
default: throw new ParserError(position, "Invalid operator encountered: " + kind.ToString());
}
}
private string TokenKindToOperatorName(Position position, TokenKind kind)
{
switch (kind)
{
case TokenKind.Asterisk: return("*");
case TokenKind.Backslash: return("\\");
case TokenKind.Equal: return("=");
case TokenKind.GreaterThan: return(">");
case TokenKind.LessThan: return("<");
case TokenKind.Minus: return("-");
case TokenKind.Plus: return("+");
default: throw new ParserError(position, "Invalid operator encountered: " + kind.ToString());
}
}
public override string ToString()
{
return(tk.ToString());
}
public void UsesDescriptiveNameForToString()
{
lower.ToString().ShouldBe("Lowercase");
upper.ToString().ShouldBe("Uppercase");
caseInsensitive.ToString().ShouldBe("Case Insensitive");
}
private string TokenKindToOperatorName(Position position, TokenKind kind)
{
switch (kind)
{
case TokenKind.Asterisk : return "*";
case TokenKind.Backslash : return "\\";
case TokenKind.Equal : return "=";
case TokenKind.GreaterThan: return ">";
case TokenKind.LessThan : return "<";
case TokenKind.Minus : return "-";
case TokenKind.Plus : return "+";
default: throw new ParserError(position, "Invalid operator encountered: " + kind.ToString());
}
}
public override string ToString()
{
return(string.Format("{0}: {1} {2}", Position.ToString(), Kind.ToString(), Text));
}
private SyntaxToken EatToken(TokenKind tokenKind)
{
SyntaxToken syntax;
if (_token.Kind == tokenKind)
{
syntax = Open <SyntaxToken>();
}
else
{
// Create an invalid token in case we don't match it
var invalid = Open <InvalidSyntaxToken>();
invalid.InvalidKind = _token.Kind;
syntax = invalid;
var tokenText = tokenKind.ToText();
var expectingTokenText = tokenText != null ? $"while expecting `{tokenText}` (token: `{tokenKind.ToString().ToLowerInvariant()}`)" : $"while expecting token `{tokenKind.ToString().ToLowerInvariant()}`";
if (_token.Kind == TokenKind.Invalid)
{
LogError($"Unexpected token found `{ToPrintable(_token)}` {expectingTokenText}");
}
else
{
LogError($"Unexpected token found `{ToPrintable(_token)}` (token: `{_token.Kind.ToString().ToLowerInvariant()}`) {expectingTokenText}");
}
}
syntax.TokenKind = tokenKind;
syntax.Text = _token.Kind.ToText() ?? _token.GetText(_lexer.Source);
if (tokenKind == TokenKind.NewLine)
{
// Once we have found a new line, we let all the other NewLines as trivias
_hideNewLine = true;
}
NextToken();
return(Close(syntax));
}
private Token MatchCurrent(TokenKind l)
{
if (l != _enumerator.Current.Kind)
{
throw new SyntaxException("Got " + _enumerator.Current.Kind.ToString() + $", {l.ToString()} expected" +
$" at {_enumerator.Current.row + 1}:{_enumerator.Current.column}",
_enumerator.Current.row, _enumerator.Current.column);
}
else
{
//Console.WriteLine(_enumerator.Current.ToString());
return(_enumerator.Current);
}
}
private string GetDebuggerDisplay()
{
return((Text == null) ?
Kind.ToString() :
$"{Kind}: \"{Text}\"");
}
private OperatorKind TokenKindToOperator(Position position, TokenKind kind)
{
switch (kind)
{
case TokenKind.Asterisk: return OperatorKind.Multiplication;
case TokenKind.Backslash: return OperatorKind.Difference;
case TokenKind.Equal: return OperatorKind.Equality;
case TokenKind.GreaterThan: return OperatorKind.GreaterThan;
case TokenKind.LessThan: return OperatorKind.LessThan;
case TokenKind.Minus: return OperatorKind.Subtraction;
case TokenKind.Plus: return OperatorKind.Addition;
default: throw new ParserError(position, "Invalid operator encountered: " + kind.ToString());
}
}
private ExpressionType GetBinaryOperator(TokenKind kind)
{
return(kind switch
{
TokenKind.Add => ExpressionType.Add,
TokenKind.Subtract => ExpressionType.Subtract,
TokenKind.Multiply => ExpressionType.Multiply,
TokenKind.Divide => ExpressionType.Divide,
TokenKind.Mod => ExpressionType.Modulo,
TokenKind.Power => ExpressionType.Power,
TokenKind.LessThan => ExpressionType.LessThan,
TokenKind.LessThanOrEqual => ExpressionType.LessThanOrEqual,
TokenKind.Equal => ExpressionType.Equal,
TokenKind.GreaterThanOrEqual => ExpressionType.GreaterThanOrEqual,
TokenKind.GreaterThan => ExpressionType.GreaterThan,
TokenKind.NotEqual => ExpressionType.NotEqual,
_ => throw new CompilerException(tokenizer.Position, string.Format("operator TokenKind:{0} error!", kind.ToString())),
});
/// <summary>
/// Reports an error and then throws a {@link SyntaxError} exception. It calls
/// {@link #RaiseSyntacticError(string, string)} using the spelling of the
/// given token kind, or the empty string if the token kind is null.
/// </summary>
/// <param name="messageTemplate">
/// the message template
/// </param>
/// <param name="kind">
/// the token kind
/// </param>
/// <throws type="SyntaxError">
/// a syntactic error
/// </throws>
void RaiseSyntacticError(string messageTemplate, TokenKind kind)
{
RaiseSyntacticError(messageTemplate, kind.ToString());
}
private SyntaxError NotRecognizedToken(TokenKind token)
{
return(NotRecognizedToken(token.ToString()));
}
private SyntaxException UnexpectedToken(TokenKind expected)
{
return(UnexpectedToken(expected.ToString()));
}
private void ValidateExpression(StringTokenizer t, TokenKind endToken)
{
this.Transforms = new List <Transform>();
this.Errors = new List <TokenError>();
while (!t.EOF)
{
Token token = t.Next();
if (token.Kind != TokenKind.Word)
{
this.Errors.Add(new TokenError("A transform name was expected", token.Line, token.Column, token.Value, this.context));
return;
}
if (!ActiveConfig.XmlConfig.Transforms.Contains(token.Value))
{
this.Errors.Add(new TokenError("The transform was not found", token.Line, token.Column, token.Value, this.context));
}
else
{
this.Transforms.Add(ActiveConfig.XmlConfig.Transforms[token.Value]);
}
token = t.Next();
if (token.Kind == TokenKind.EOF)
{
if (endToken == TokenKind.EOF)
{
return;
}
else
{
this.Errors.Add(new TokenError(string.Format("Expected '>>' or '{0}'", endToken.ToString()), token.Line, token.Column, token.Value, this.context));
}
}
else if (token.Kind == endToken)
{
return;
}
else if (token.Kind == TokenKind.TransformOperator)
{
continue;
}
else
{
this.Errors.Add(new TokenError(string.Format("Expected '>>' or '{0}'", endToken.ToString()), token.Line, token.Column, token.Value, this.context));
return;
}
}
}
