public LanguageParser(Lexers.Lexer lexer)
        {
            TokenStream = new ParseableTokenStream(lexer);

            // we'll tag all lambdas we find starting from 1000 here
            // later when we iterate over scope and create anonnymous lambdas
            // we need the lambdas to have the SAME name even if we iterate over
            // the syntax tree multiple times. this is hacky, i know.
            // curried functions will be labeled from 0 to 1000
            LambdaDeclr.LambdaCount = 1000;
        }
Esempio n. 2
0
        /// <summary>
        /// 新規にパーサーを作成します。
        /// </summary>
        private Grammar CreateParser(AngleMode angleMode)
        {
            var sDelim = Scanners.IsWhitespaces().Many_();
            var OPs    = Terms.GetOperatorsInstance(
                "+", "-", "**", "*", "/", "%", "(", ")", ",", "#");

            var lToken = OPs.Lexer | Lexers.LexDecimal() | Lexers.LexWord();
            var lexeme = Lexers.Lexeme(sDelim, lToken).FollowedBy(Parsers.Eof());

            var pNumber = Terms.OnDecimal((from, len, s) => double.Parse(s));
            var pWord   = Terms.OnWord((from, len, s) => s);

            Terms.FromSimpleToken <string, string>((from, len, s) => s);

            var pPlus   = GetOperator(OPs, "+", new Binary((a, b) => (a + b)));
            var pMinus  = GetOperator(OPs, "-", new Binary((a, b) => (a - b)));
            var pMul    = GetOperator(OPs, "*", new Binary((a, b) => (a * b)));
            var pDiv    = GetOperator(OPs, "/", new Binary((a, b) => (a / b)));
            var pMod    = GetOperator(OPs, "%", new Binary((a, b) => (a % b)));
            var pPow    = GetOperator(OPs, "**", new Binary((a, b) => Math.Pow(a, b)));
            var pNone   = GetOperator(OPs, "+", new Unary(n => n));
            var pNeg    = GetOperator(OPs, "-", new Unary(n => - n));
            var opTable = new OperatorTable <double>()
                          .Infixl(pPlus, 10)
                          .Infixl(pMinus, 10)
                          .Infixl(pMul, 20)
                          .Infixl(pDiv, 20)
                          .Infixl(pMod, 20)
                          .Infixr(pPow, 30)
                          .Prefix(pNone, 40)
                          .Prefix(pNeg, 40);

            var pLParen = OPs.GetParser("(");
            var pRParen = OPs.GetParser(")");
            var pComma  = OPs.GetParser(new string[] { ",", "#" });

            var lazyExpr  = new Grammar[1];
            var pLazyExpr = Parsers.Lazy <double>(() => lazyExpr[0]);
            var pArg
                = pLazyExpr.SepEndBy(pComma).Between(pLParen, pRParen)
                  | pLParen.Seq(pRParen).Seq(Parsers.Return(new double[0]));
            var pTerm
                = pLazyExpr.Between(pLParen, pRParen)
                  | pWord.And(pArg.Optional(), new Map <string, double[], double>(CalcFunc))
                  | pNumber;

            var pExpr = Expressions.BuildExpressionParser(pTerm, opTable);

            lazyExpr[0] = pExpr;
            return(Parsers.ParseTokens(lexeme, pExpr.FollowedBy(Parsers.Eof()), "calculator"));
        }
Esempio n. 3
0
        public override void Initialize(IApp app)
        {
            base.Initialize(app);

            Lexers.ForEach(b =>
            {
                var iface = default(Type);

                if ((iface = b.Type.GetInterface(typeof(ICodeLexer).FullName)) == null)
                {
                    throw new ElideException("ICodeLexer '{0}' doesn't implement ICodeLexer interface.", b.Type);
                }

                LexerInstances.Add(b.Key, TypeCreator.New <ICodeLexer>(b.Type));
            });
        }
Esempio n. 4
0
 private void StyleSetItalic(Lexers.Cpp style, bool italic)
 {
     this.SendMessageDirect(Constants.SCI_STYLESETITALIC, (int)style, italic);
 }
Esempio n. 5
0
 public ExtInfo GetInfo(string section, string key)
 {
     ValidateSection(section);
     return(Lexers.FirstOrDefault(b => b.Key == key));
 }
Esempio n. 6
0
 public IEnumerable <ExtInfo> EnumerateInfos(string section)
 {
     ValidateSection(section);
     return(Lexers.OfType <ExtInfo>().ToArray());
 }