public void ToStringReturnsCorrectRepresentation()
{
var token = new ForToken();
token.Line = 20;
token.Column = 40;
Assert.AreEqual("<Keyword - 'for'>", token.ToString());
var token2 = new VarToken();
Assert.AreEqual("<Keyword - 'var'>", token2.ToString());
}
public void TwoDifferentKeywordTokensAreNotEqual()
{
var token = new ForToken();
token.Line = 5;
token.Column = 20;
var token2 = new VarToken();
token2.Line = 44;
token2.Column = 23;
Assert.AreNotEqual(token, token2);
}
public override Token getToken()
{
VarToken token = new VarToken();
token.setType(TokenType.Var);
token.setName(this.objVar.GetFullVarName());
VarInfo varInfo = VarInfo.Init(token.getName());
varInfo.setRawLabelAndVar(this.objVar.GetFullLabelAndVar());
token.setVarInfo(varInfo);
return(token);
}
public override double EvaluateVar(VarToken token)
{
object val = parser.GetVariable(token.Symbol);
if (val == null)
{
throw new ParserUnassignedVariableException(token.Symbol);
}
else if (val is BigDecimal)
{
return((double)(BigDecimal)val);
}
else
{
return(Convert.ToDouble(val));
}
}
public override Token getToken()
{
VarToken token = new VarToken();
token.setName(this.objVar.GetFullVarName());
int dotIndex = token.getName().IndexOf('.');
if (dotIndex > 0 && dotIndex < token.getName().Length)
{
token.setIsObject(true);
String[] arrp = token.getName().Split('.');
token.setObjName(arrp[0]);
token.setObjAccessor(arrp);
}
token.setRawLabelAndVar(this.objVar.GetFullLabelAndVar());
return(token);
}
public Token GetToken()
{
State = LexicAnalyserState.Initial;
Value = HasNext ? Character.ToString() : "";
Token token = null;
while (HasNext && token == null)
{
switch (State)
{
case LexicAnalyserState.Initial:
HandleInitial();
break;
case LexicAnalyserState.NonTerminal:
token = new NonTerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Space:
token = new SpaceToken();
CurrentIndex++;
break;
case LexicAnalyserState.Terminal:
token = new TerminalToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Empty:
token = new EmptyToken();
CurrentIndex++;
break;
case LexicAnalyserState.NewLine:
token = new NewLineToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Identifier:
token = new IdentifierToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Number:
token = new NumberToken(Value);
CurrentIndex++;
break;
case LexicAnalyserState.Var:
token = new VarToken();
CurrentIndex++;
break;
case LexicAnalyserState.Write:
token = new WriteToken();
CurrentIndex++;
break;
case LexicAnalyserState.Read:
token = new ReadToken();
CurrentIndex++;
break;
case LexicAnalyserState.If:
token = new IfToken();
CurrentIndex++;
break;
case LexicAnalyserState.End:
token = new EndToken();
CurrentIndex++;
break;
case LexicAnalyserState.Then:
token = new ThenToken();
CurrentIndex++;
break;
case LexicAnalyserState.Begin:
token = new BeginToken();
CurrentIndex++;
break;
case LexicAnalyserState.While:
token = new WhileToken();
CurrentIndex++;
break;
case LexicAnalyserState.Do:
token = new DoToken();
CurrentIndex++;
break;
case LexicAnalyserState.SemiColon:
token = new SemiColonToken();
CurrentIndex++;
break;
case LexicAnalyserState.OpenParentheses:
token = new OpenParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.CloseParentheses:
token = new CloseParenthesesToken();
CurrentIndex++;
break;
case LexicAnalyserState.Plus:
token = new PlusToken();
CurrentIndex++;
break;
case LexicAnalyserState.Sub:
token = new SubToken();
CurrentIndex++;
break;
case LexicAnalyserState.Great:
token = new GreatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Less:
token = new LessToken();
CurrentIndex++;
break;
case LexicAnalyserState.Equal:
token = new EqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.Repeat:
token = new RepeatToken();
CurrentIndex++;
break;
case LexicAnalyserState.Until:
token = new UntilToken();
CurrentIndex++;
break;
case LexicAnalyserState.Attribution:
token = new AttributionToken();
CurrentIndex++;
break;
case LexicAnalyserState.NotEqual:
token = new NotEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.GreatOrEqual:
token = new GreatOrEqualToken();
CurrentIndex++;
break;
case LexicAnalyserState.LessOrEqual:
token = new LessOrEqualToken();
CurrentIndex++;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(token);
}
public override string ToString()
{
return(VarToken.GetText());
}
/// <summary> /// Evaluates a given variable token. /// </summary> /// <param name="token">The token to be evaluated.</param> /// <returns>The evaluated value.</returns> public abstract T EvaluateVar(VarToken token);
public override string EvaluateVar(VarToken token) => token.Symbol;
public VarNode(VarToken token)
: base(token)
{
_token = token;
}
public override string EvaluateVar(VarToken token)
=> $"<mi>{token.Symbol}</mi>";
public override Expression EvaluateVar(VarToken token) => Context.Parameters[token.Symbol] ?? resolveVar(token.Symbol);
/// <summary>
/// Reads the arguments given to a function and puts them into a FuncParamToken.
/// </summary>
/// <returns>The created FuncParamToken conatining the arguments given to the function.</returns>
private Token readFuncParams(FuncToken funcToken, InputStream str)
{
if (str.AtEnd)
{
throw new ParserSyntaxException("Invalid function usage.", funcToken.Position);
}
FuncParamToken paramtok = new FuncParamToken(str.Position);
LinkedList <Token> subTokenList = new LinkedList <Token>();
int open = 0, close = 0;
bool withBrackets = false;
string removeVar = null;
// Match the index variable if it's a VarFuncToken.
if (funcToken is VarFuncToken varFuncToken)
{
var match = varFuncRegex.Match(str.InputString);
if (match.Success)
{
withBrackets = true; open++;
var varToken = new VarToken(match.Groups[1].ToString(), str.Position);
paramtok.ParamList.Add(new LinkedList <Token>(new[] { varToken }));
str.MoveForward(match.Length);
if (!TokenDict.ContainsKey(varToken.Symbol))
{
removeVar = varToken.Symbol;
TokenDict.Add(removeVar, new Tuple <Type, int>(typeof(VarToken), 0));
}
}
else
{
throw new ParserSyntaxException("Invalid index variable definition.", str.Position);
}
}
Token tok = funcToken;
do
{
if (str.StartsWith(ArgumentSeparator.ToString()))
{
paramtok.ParamList.Add(subTokenList);
subTokenList = new LinkedList <Token>();
tok = funcToken;
}
tok = readNextToken(subTokenList, tok, str);
if (tok is LeftBracketToken)
{
open++;
if (!withBrackets)
{
withBrackets = true; subTokenList.RemoveLast();
}
;
}
else if (tok is RightBracketToken)
{
close++;
}
if (tok is FuncToken func)
{
subTokenList.AddLast(tok = readFuncParams(func, str));
}
}while (!str.AtEnd && (open != close));
if (open != close)
{
throw new ParserBracketException("Unequal number of opening and closing brackets.", str.Position);
}
paramtok.ParamList.Add(subTokenList);
if (withBrackets)
{
paramtok.ParamList[paramtok.ParamList.Count - 1].RemoveLast();
}
if (removeVar != null)
{
TokenDict.Remove(removeVar);
}
return(paramtok);
}
public override Exp Analy(AnalyExpContext context)
{
base.Analy(context);
var symbols = this.AnalyExpContext.Symbols;
VarName = VarToken.GetText();
if (!IsNestedField)
{
if (VarSymbol == null)
{
VarSymbol = symbols.Get(VarName);
}
if (VarSymbol == null)
{
//VarSymbol = symbols.Get(VarName);
List <SymbolEnumItem> enumValues = context.ClassContext.SearchEnumItem(VarName);
if (enumValues.Count == 1)
{
VarSymbol = enumValues[0];
}
if (enumValues.Count > 1)
{
errorf("'{0}'有多个相同约定值", VarName);
return(null);
}
}
if (VarSymbol == null)
{
if (context.ClassContext.ClassSymbol.BaseGcl != null)
{
ExPropertyInfo property = context.ClassContext.ClassSymbol.BaseGcl.SearchExProperty(VarName);
if (property != null)
{
if (ReflectionUtil.IsPublic(property.Property) ||
ReflectionUtil.IsProtected(property.Property))
{
SymbolDefProperty ps = new SymbolDefProperty(VarName, property.Property.PropertyType,
ReflectionUtil.IsStatic(property.Property));
ps.SetProperty(property.Property);
VarSymbol = ps;
}
}
}
}
if (VarSymbol == null)
{
if (context.ClassContext.ClassSymbol.BaseGcl != null)
{
ExFieldInfo field = context.ClassContext.ClassSymbol.BaseGcl.SearchExField(VarName);
if (field != null)
{
if (field.Field.IsPublic || field.Field.IsFamily)
{
SymbolDefField fs = new SymbolDefField(VarName, field.Field.FieldType,
field.Field.IsStatic);
fs.SetField(field.Field);
VarSymbol = fs;
}
}
}
}
if (VarSymbol == null)
{
if (IsAssignedBy)
{
SymbolVar varSymbol = new SymbolVar(VarName);
if (!varSymbol.IsInBlock)
{
varSymbol.LoacalVarIndex = context.StmtContext.MethodContext.CreateLocalVarIndex(VarName);
symbols.Add(varSymbol);
}
VarSymbol = varSymbol;
}
else
{
errorf("'{0}'没有赋值", VarName);
return(null);
}
}
RetType = ((InstanceSymbol)VarSymbol).DimType;
}
else
{
}
return(this);
}
