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);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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));
            }
        }
예제 #5
0
        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);
        }
예제 #6
0
        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);
        }
예제 #7
0
 public override string ToString()
 {
     return(VarToken.GetText());
 }
예제 #8
0
 /// <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);
예제 #9
0
 public override string EvaluateVar(VarToken token) => token.Symbol;
예제 #10
0
 public VarNode(VarToken token)
     : base(token)
 {
     _token = token;
 }
예제 #11
0
 public override string EvaluateVar(VarToken token)
 => $"<mi>{token.Symbol}</mi>";
예제 #12
0
 public override Expression EvaluateVar(VarToken token)
 => Context.Parameters[token.Symbol] ?? resolveVar(token.Symbol);
예제 #13
0
        /// <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);
        }
예제 #14
0
        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);
        }