Exemplo n.º 1
0
 public override int GenerateFunction(functionExpressionNode node, string name, StatementNode r, out FunctionDelegate _delegate)
 {
     DynamicMethod method = new DynamicMethod(name, MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(JSValue), new Type[] { typeof(JSContext) }, typeof(JSContext), false);
     ILGenerator tmp = method.GetILGenerator();
     base.GenerateFunctionBody(r, tmp);
     _delegate = (FunctionDelegate) method.CreateDelegate(typeof(FunctionDelegate));
     base.Source.FunctionList.Add(node);
     return (base.Source.FunctionList.Count - 1);
 }
Exemplo n.º 2
0
 public override int GenerateFunction(functionExpressionNode node, string name, StatementNode r, out FunctionDelegate _delegate)
 {
     int n = this.FunctionList.Count;
     MethodBuilder method = this.tb.DefineMethod(name + "_" + n, MethodAttributes.Static | MethodAttributes.Public, typeof(JSValue), new Type[] { typeof(JSContext) });
     method.DefineParameter(1, ParameterAttributes.None, "context");
     base.GenerateFunctionBody(r, method.GetILGenerator());
     this.FunctionList.Add(new _FncInfo() { args=node.ParameterList.Names, mb = method});
     _delegate = null;
     return n;
 }
Exemplo n.º 3
0
        void Write(StatementNode stmt)
        {
            #region contract
            if(stmt == null)
                throw new ArgumentNullException("stmt");
            #endregion

            _sql.Write(new[] {'\t'}, 0, _indent);
            if(stmt is SelectNode)
                Write(stmt as SelectNode);
            else
                throw new ApplicationException("Can handle only 'select' statements but got: "+stmt.GetType().Name);
        }
Exemplo n.º 4
0
 internal override void ConstructionComplete()
 {
     CommonTree CatchTmp = (((CommonTree) base.Children[1]).ChildCount != 0) ? ((CommonTree) ((CommonTree) base.Children[1]).Children[0]) : null;
     if (CatchTmp != null)
     {
         this.CatchTree = (StatementNode) CatchTmp.Children[1];
         this.CatchId = CompileContext.EscapeIdentifier(((CommonTree) CatchTmp.Children[0]).Text);
     }
     this.FinallyTree = (((CommonTree) base.Children[2]).ChildCount != 0) ? ((StatementNode) ((CommonTree) base.Children[2]).Children[0]) : null;
     if (this.FinallyTree == null)
     {
         this.DeleteChild(2);
     }
     if (this.CatchTree == null)
     {
         this.DeleteChild(1);
     }
     else
     {
         this.ReplaceChildren(1, 1, this.CatchTree);
     }
     base.ConstructionComplete();
 }
Exemplo n.º 5
0
 public IEnumerable <ValueNode> Default(StatementNode node)
 => emptyArray;
Exemplo n.º 6
0
 public void Add(StatementNode stat)
 {
     StList.Add(stat);
 }
Exemplo n.º 7
0
 void SimpleStatement(ref StatementNode node)
 {
     Expect(49);
     node = new SimpleStatementNode(t.val);
 }
        internal bool TryFindContextNodes(Position position, out StatementNode currentNode, out StatementNode parentNode)
        {
            currentNode = null;
            parentNode  = null;

            if (this.statementNodeRoot == null)
            {
                return(false);
            }

            currentNode = this.FindInnermostNode(this.statementNodeRoot, position);

            if (currentNode.Parent == null)
            {
                parentNode  = currentNode;
                currentNode = null;
            }
            else
            {
                parentNode = currentNode.Parent;

                // For Rtype, determining the parent depends on indentation...
                if (this.language == ParserLanguage.Rtype)
                {
                    // We think we've found the parent node, but we may have to climb
                    // back up the tree if we're less indented than the current statement.
                    while (parentNode != null && position.Column <= parentNode.Indent)
                    {
                        parentNode = parentNode.Parent;
                    }

                    // We think we've found the current node, but if we're at the same
                    // or less indent, it *can't* be a continuation of the current
                    // statement.
                    if (position.Column <= currentNode.Indent)
                    {
                        currentNode = null;
                    }
                }
                else if (this.language == ParserLanguage.Xml)
                {
                    // For XML, we have to see if we're *after* the end of
                    // each statement... we might just be in the parent's content!
                    if (currentNode != null)
                    {
                        if (currentNode.Statement.AllTokens.Last().Range.End <= position)
                        {
                            currentNode = null;
                        }
                    }
                }
            }

            return(true);
        }
Exemplo n.º 9
0
		private static string FormatTerminal(StatementNode node)
		{
			var terminal = node as StatementGrammarNode;
			if (terminal == null)
			{
				return node.Token.Value;
			}

			var formatOptions = OracleConfiguration.Configuration.Formatter.FormatOptions;
			var value = terminal.Token.Value;
			if (terminal.Id.IsIdentifier() || GrammarSpecificFunctions.Contains(terminal.Id))
			{
				return FormatTerminalValue(value, formatOptions.Identifier);
			}

			if (terminal.Id.IsAlias())
			{
				return FormatTerminalValue(value, formatOptions.Alias);
			}

			if (terminal.IsReservedWord)
			{
				return FormatTerminalValue(value, formatOptions.ReservedWord);
			}

			if (!String.Equals(terminal.Id, Terminals.StringLiteral))
			{
				return FormatTerminalValue(value, formatOptions.Keyword);
			}

			return value;
		}
Exemplo n.º 10
0
 void ReturnStatement(ref StatementNode node)
 {
     Expect(36);
     node = new ReturnStatementNode();
 }
Exemplo n.º 11
0
 public void Add(StatementNode node)
 {
     _sts.Add(node);
 }
Exemplo n.º 12
0
 public virtual void Visit(StatementNode statement)
 {
 }
Exemplo n.º 13
0
        protected override bool ParseCilInstructionInternal(Instruction instruction,
                                                            ProgramState state)
        {
            switch (instruction.OpCode.Code)
            {
            case Code.Box:
                (var value, var type) = state.Pop();

                var boxedValueIdentifier = state.GetIdentifier(Identifier.IdentKind.Normal);
                var boxedObjectVariable  = new VarExpression(boxedValueIdentifier);
                var boxedObjectType      = new BoxedValueType(Tptr.PtrKind.Pk_pointer,
                                                              new Tstruct("System.Object"),
                                                              value,
                                                              type);
                var callFlags = new Call.CallFlags(false, false, false);

                // The value in question is boxed into a generic object.
                var objectAllocationCall =
                    new Call(boxedValueIdentifier,
                             boxedObjectType,
                             new ConstExpression(ProcedureName.BuiltIn__new),
                             new List <Call.CallArg>
                {
                    new Call.CallArg(
                        new SizeofExpression(
                            boxedObjectType.StripPointer(), "exact"),
                        boxedObjectType)
                },
                             callFlags,
                             state.CurrentLocation);

                var objectConstructorCall =
                    new Call(state.GetIdentifier(Identifier.IdentKind.Normal),
                             new Tvoid(),
                             new ConstExpression(new ProcedureName(".ctor",
                                                                   new List <string>(),
                                                                   "System.Object",
                                                                   "System.Void",
                                                                   false)),
                             new List <Call.CallArg>
                {
                    new Call.CallArg(boxedObjectVariable, boxedObjectType)
                },
                             callFlags,
                             state.CurrentLocation);

                var node = new StatementNode(state.CurrentLocation,
                                             StatementNode.StatementNodeKind.Call,
                                             state.ProcDesc,
                                             comment: "System.Void System.Object::.ctor()");
                node.Instructions.Add(objectAllocationCall);
                node.Instructions.Add(objectConstructorCall);
                RegisterNode(state, node);

                state.PushExpr(boxedObjectVariable, boxedObjectType);
                state.PushInstruction(instruction.Next, node);
                state.AppendToPreviousNode = true;

                return(true);

            default:
                return(false);
            }
        }
Exemplo n.º 14
0
 public BlockNode(StatementNode node)
 {
     _sts.Add(node);
 }
Exemplo n.º 15
0
 public IfNode(ExprNode expr, StatementNode stat)
 {
     Expr       = expr;
     Stat_first = stat;
 }
Exemplo n.º 16
0
 public IfNode(ExprNode expr, StatementNode stat_first, StatementNode stat_second)
 {
     Expr        = expr;
     Stat_first  = stat_first;
     Stat_second = stat_second;
 }
Exemplo n.º 17
0
 public ForNode(StatementNode a, ExprNode expr, StatementNode stat)
 {
     Assign = a;
     Expr   = expr;
     Stlist = stat;
 }
Exemplo n.º 18
0
 public WhileNode(ExprNode expr, StatementNode stat)
 {
     Expr = expr;
     Stat = stat;
 }
Exemplo n.º 19
0
 public WithStatement(uint start, uint end, Token op1, StatementNode[] withItems, Token[] separators, Token colon, Token typeComment, StatementNode suite) : base(start, end)
 {
     Operator1   = op1;
     WithItems   = withItems;
     Separators  = separators;
     Operator2   = colon;
     TypeComment = typeComment;
     Suite       = suite;
 }
Exemplo n.º 20
0
 public RepeatNode(StatementNode stlist, ExprNode expr)
 {
     Expr = expr;
     StList.Add(stlist);
 }
Exemplo n.º 21
0
 private static SourcePosition CreateNodePosition(StatementNode movedNode, StatementGrammarNode nodeToExchange)
 {
     return(nodeToExchange == null
                         ? SourcePosition.Empty
                         : SourcePosition.Create(nodeToExchange.SourcePosition.IndexStart, GetLastNonChainingNodePosition(nodeToExchange, movedNode.ParentNode.Id)));
 }
Exemplo n.º 22
0
 internal AssemblyBuilder GenerateAB(StatementNode r)
 {
     base.GenerateGlobalCode(r);
     MethodInfo mi_PushContext = typeof(JSContext).GetMethod("PushContext", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(JSContext) }, null);
     MethodInfo mi_PopContext = typeof(JSContext).GetMethod("PopContext", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, new Type[0], null);
     ILGenerator gen = this.tb.DefineMethod("__Run", MethodAttributes.Public, typeof(JSValue), Type.EmptyTypes).GetILGenerator();
     LocalBuilder l_ctx = gen.DeclareLocal(typeof(JSContext));
     LocalBuilder value = gen.DeclareLocal(typeof(JSValue));
     Label label60 = gen.DefineLabel();
     gen.Emit(OpCodes.Newobj, this.ctor1);
     gen.Emit(OpCodes.Stloc, l_ctx.LocalIndex);
     gen.Emit(OpCodes.Ldloc, l_ctx.LocalIndex);
     gen.EmitCallV( mi_PushContext);
     gen.BeginExceptionBlock();
     gen.Emit(OpCodes.Ldloc, l_ctx.LocalIndex);
     gen.EmitCallV( this.GlobalMethod);
     gen.Emit(OpCodes.Stloc, value.LocalIndex);
     gen.Emit(OpCodes.Leave_S, label60);
     gen.BeginFinallyBlock();
     gen.EmitCallV( mi_PopContext);
     gen.Emit(OpCodes.Endfinally);
     gen.EndExceptionBlock();
     gen.MarkLabel(label60);
     gen.Emit(OpCodes.Ldloc, value.LocalIndex);
     gen.Emit(OpCodes.Ret);
     MethodBuilder method = this.tb.DefineMethod(".cctor", MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Private);
     ConstructorInfo ctor2 = typeof(JSDebugFunctionDef).GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
     FieldInfo param_names = typeof(JSDebugFunctionDef).GetField("param_names");
     ConstructorInfo ctor4 = typeof(Func<,>).MakeGenericType(new Type[] { typeof(JSContext), typeof(JSValue) }).GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(object), typeof(IntPtr) }, null);
     MethodInfo set_del = typeof(JSDebugFunctionDef).GetMethod("set_del", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(Func<,>).MakeGenericType(new Type[] { typeof(JSContext), typeof(JSValue) }) }, null);
     method.SetReturnType(typeof(void));
     gen = method.GetILGenerator();
     LocalBuilder def = gen.DeclareLocal(typeof(JSDebugFunctionDef));
     LocalBuilder strarr = gen.DeclareLocal(typeof(string[]));
     LocalBuilder defArray = gen.DeclareLocal(typeof(JSDebugFunctionDef[]));
     gen.Emit(OpCodes.Nop);
     gen.Emit(OpCodes.Ldc_I4, this.FunctionList.Count);
     gen.Emit(OpCodes.Newarr, typeof(JSDebugFunctionDef));
     gen.Emit(OpCodes.Stloc, defArray.LocalIndex);
     for (int i = 0; i < this.FunctionList.Count; i++)
     {
         gen.Emit(OpCodes.Ldloc, defArray.LocalIndex);
         gen.Emit(OpCodes.Ldc_I4, i);
         gen.Emit(OpCodes.Newobj, ctor2);
         gen.Emit(OpCodes.Stloc, def.LocalIndex);
         gen.Emit(OpCodes.Ldloc, def.LocalIndex);
         string[] names = this.FunctionList[i].args;
         gen.Emit(OpCodes.Ldc_I4, names.Length);
         gen.Emit(OpCodes.Newarr, typeof(string));
         gen.Emit(OpCodes.Stloc, strarr.LocalIndex);
         for (int j = 0; j < names.Length; j++)
         {
             gen.Emit(OpCodes.Ldloc, strarr.LocalIndex);
             gen.Emit(OpCodes.Ldc_I4, j);
             gen.Emit(OpCodes.Ldstr, names[j]);
             gen.Emit(OpCodes.Stelem_Ref);
         }
         gen.Emit(OpCodes.Ldloc, strarr.LocalIndex);
         gen.Emit(OpCodes.Stfld, param_names);
         gen.Emit(OpCodes.Ldloc, def.LocalIndex);
         gen.Emit(OpCodes.Ldnull);
         gen.Emit(OpCodes.Ldftn, this.FunctionList[i].mb);
         gen.Emit(OpCodes.Newobj, ctor4);
         gen.EmitCallV( set_del);
         gen.Emit(OpCodes.Nop);
         gen.Emit(OpCodes.Ldloc, def.LocalIndex);
         gen.Emit(OpCodes.Stelem_Ref);
     }
     gen.Emit(OpCodes.Ldloc, defArray.LocalIndex);
     gen.Emit(OpCodes.Stsfld, this.fncListField);
     gen.Emit(OpCodes.Ret);
     method = this.tb.DefineMethod("GetFunctionReference", MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Public);
     ConstructorInfo ctor3 = typeof(JSDebugFunction).GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(JSDebugFunctionDef), typeof(JSEnvRec) }, null);
     method.SetReturnType(typeof(JSValue));
     method.SetParameters(new Type[] { typeof(int), typeof(JSEnvRec) });
     method.DefineParameter(1, ParameterAttributes.None, "key");
     method.DefineParameter(2, ParameterAttributes.None, "r");
     gen = method.GetILGenerator();
     LocalBuilder value2 = gen.DeclareLocal(typeof(JSValue));
     Label label17 = gen.DefineLabel();
     gen.Emit(OpCodes.Nop);
     gen.Emit(OpCodes.Ldsfld, this.fncListField);
     gen.Emit(OpCodes.Ldarg_1);
     gen.Emit(OpCodes.Ldelem_Ref);
     gen.Emit(OpCodes.Ldarg_2);
     gen.Emit(OpCodes.Newobj, ctor3);
     gen.Emit(OpCodes.Stloc_0);
     gen.Emit(OpCodes.Br_S, label17);
     gen.MarkLabel(label17);
     gen.Emit(OpCodes.Ldloc_0);
     gen.Emit(OpCodes.Ret);
     Type t = this.tb.CreateType();
     return this.ab;
 }
Exemplo n.º 23
0
 private static void GenerateExternalAssembly(StatementNode r)
 {
     ASMCompileContext ctx = new ASMCompileContext();
     ctx.GenerateAB(r).Save("DynamicAssemblyExample.dll");
 }
Exemplo n.º 24
0
        void Statement(ref StatementNode node)
        {
            var stoken = t;

            switch (la.kind)
            {
            case 11:
            case 12: {
                EndStatement(ref node);
                break;
            }

            case 46: {
                OptionStatement(ref node);
                break;
            }

            case 36: {
                ReturnStatement(ref node);
                break;
            }

            case 37: {
                IfThenStatement(ref node);
                break;
            }

            case 39: {
                ForStatement(ref node);
                break;
            }

            case 41: {
                NextStatement(ref node);
                break;
            }

            case 44: {
                RestoreStatement(ref node);
                break;
            }

            case 1:
            case 9:
            case 29: {
                LetStatement(ref node);
                break;
            }

            case 42: {
                DataStatement(ref node);
                break;
            }

            case 13: {
                PrintStatement(ref node);
                break;
            }

            case 43: {
                ReadStatement(ref node);
                break;
            }

            case 31:
            case 32:
            case 33: {
                GotoOrSubStatement(ref node);
                break;
            }

            case 45: {
                DimStatement(ref node);
                break;
            }

            case 48: {
                OnGotoStatement(ref node);
                break;
            }

            case 49: {
                SimpleStatement(ref node);
                break;
            }

            case 50: {
                DefStatement(ref node);
                break;
            }

            case 51: {
                InputStatement(ref node);
                break;
            }

            default: SynErr(55); break;
            }
            if (node != null)
            {
                node.Line = stoken.line;
                node.Col  = stoken.col;
            }
        }
Exemplo n.º 25
0
 private static CompiledScript GenerateMethod(StatementNode r, ScriptSource Source)
 {
     DynamicMethod method = new DynamicMethod("GlobalCode", MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(JSValue), new Type[] { typeof(JSContext) }, typeof(JSContext), false);
     DMCompileContext ctx = new DMCompileContext(method.GetILGenerator());
     ctx.Source = Source;
     ctx.GenerateGlobalCode(r);
     GlobalCodeDelegate _delegate = (GlobalCodeDelegate) method.CreateDelegate(typeof(GlobalCodeDelegate));
     CompiledScript cs = new CompiledScript(_delegate);
     cs.Source = Source;
     return cs;
 }
Exemplo n.º 26
0
 void RestoreStatement(ref StatementNode node)
 {
     Expect(44);
     node = new RestoreStatementNode();
 }
Exemplo n.º 27
0
 public IfElseNode(ExpressionNode condition, StatementNode body, StatementNode elseBody)
 {
     Condition = condition;
     Body      = body;
     ElseBody  = elseBody;
 }
Exemplo n.º 28
0
 protected override void Visit(StatementNode node)
 {
     Add(node);
 }
Exemplo n.º 29
0
 public TryCatchNodeTests()
 {
     @try    = new BlockNode(SourcePosition.NIL);
     @catch  = new BlockNode(SourcePosition.NIL);
     subject = new TryCatchNode(SourcePosition.NIL, @try, @catch, new IdentNode(SourcePosition.NIL, "foo"));
 }
Exemplo n.º 30
0
 public WhileNode(AssignNode assign, ExprNode expr, StatementNode stat)
 {
     Assign = assign;
     Expr   = expr;
     Stat   = stat;
 }
Exemplo n.º 31
0
        protected override bool ParseCilInstructionInternal(Instruction instruction,
                                                            ProgramState state)
        {
            switch (instruction.OpCode.Code)
            {
            case Code.Ret:
                Store retInstr;
                var   retType = state.Method.ReturnType.GetElementType();
                if (retType == state.Method.Module.TypeSystem.Void)
                {
                    state.PreviousNode.Successors.Add(state.ProcDesc.ExitNode);
                }
                else
                {
                    var retNode = new StatementNode(state.CurrentLocation,
                                                    StatementNode.StatementNodeKind.ReturnStmt,
                                                    state.ProcDesc);
                    (var returnValue, _) = state.Pop();
                    Expression returnVariable = new LvarExpression(
                        new LocalVariable(Identifier.ReturnIdentifier,
                                          state.Method));

                    if (returnValue is BinopExpression)
                    {
                        // We see that for the auto-generated method op_Inequality in records,
                        // an equality expression is pushed directly onto the stack and
                        // returned. However, return of an expression is not valid in the SIL --
                        // we must inline a variable store and load of the value prior to
                        // subsequently returning it.
                        var inlineReturn     = new LocalVariable("inlineReturn", state.Method);
                        var inlineIdentifier = state.GetIdentifier(Identifier.IdentKind.Normal);

                        var storeInlineReturn = new Store(new LvarExpression(inlineReturn),
                                                          returnValue,
                                                          Typ.FromTypeReference(retType),
                                                          state.CurrentLocation);
                        AddMethodBodyInstructionsToCfg(state, storeInlineReturn);

                        var loadInlineReturn = new Load(inlineIdentifier,
                                                        new LvarExpression(inlineReturn),
                                                        Typ.FromTypeReference(retType),
                                                        state.CurrentLocation);
                        AddMethodBodyInstructionsToCfg(state, loadInlineReturn);

                        retInstr = new Store(returnVariable,
                                             new VarExpression(inlineIdentifier),
                                             Typ.FromTypeReference(retType),
                                             state.CurrentLocation);
                    }
                    else
                    {
                        retInstr = new Store(returnVariable,
                                             returnValue,
                                             Typ.FromTypeReference(retType),
                                             state.CurrentLocation);
                    }
                    retNode.Instructions.Add(retInstr);
                    retNode.Successors = new List <CfgNode> {
                        state.ProcDesc.ExitNode
                    };
                    RegisterNode(state, retNode);
                }
                return(true);

            default:
                return(false);
            }
        }
Exemplo n.º 32
0
 public BlockNode(StatementNode stat)
 {
     Add(stat);
 }
Exemplo n.º 33
0
 internal void GenerateGlobalCode(StatementNode r)
 {
     this.gen.Emit(OpCodes.Ldarg_0);
     this.gen.EmitCallV( mi_JSUndefined_Instance);
     this.gen.EmitCallV( mi_Set_Returnval);
     this.GenerateCode(r);
     this.gen.Emit(OpCodes.Ldarg_0);
     this.gen.EmitCallV( mi_Get_Returnval);
     this.gen.Emit(OpCodes.Ret);
 }
Exemplo n.º 34
0
 public IfNode(ExprNode expr, StatementNode ifTrue, StatementNode ifFalse = null)
 {
     this.expr    = expr;
     this.ifTrue  = ifTrue;
     this.ifFalse = ifFalse;
 }
Exemplo n.º 35
0
 private void GenerateCode(StatementNode r)
 {
     r.GenCode(this);
 }
Exemplo n.º 36
0
 public void Visit(StatementNode node)
 {
 }
Exemplo n.º 37
0
 public void Visit(StatementNode node)
 {
     Nodes.Push(new StatementNode(Nodes.Pop()));
 }
Exemplo n.º 38
0
 public abstract int GenerateFunction(functionExpressionNode node, string name, StatementNode r, out FunctionDelegate _delegate);
Exemplo n.º 39
0
 public void Visit(StatementNode node)
 {
     node.Node.Accept(this);
     node.Accept(_visitor);
 }
Exemplo n.º 40
0
 protected void GenerateFunctionBody(StatementNode r, ILGenerator gen)
 {
     LocalFunctionData oldData = this.fncData;
     try
     {
         this.fncData = new LocalFunctionData(gen, gen.DefineLabel(), gen.DeclareLocal(typeof(JSValue)));
         r.GenCode(this);
         gen.EmitCallV(mi_JSUndefined_Instance);
         gen.Emit(OpCodes.Stloc, this.fncData.return_local);
         gen.MarkLabel(this.fncData.return_label);
         gen.Emit(OpCodes.Ldloc, this.fncData.return_local);
         gen.Emit(OpCodes.Ret);
     }
     finally
     {
         this.fncData = oldData;
     }
 }
Exemplo n.º 41
0
 public ForNode(AssignNode assign, ExprNode bord, StatementNode body) : this(assign, bord, new IntNumNode(1), body)
 {
 }
Exemplo n.º 42
0
        public override IEnumerable<ParseNode> Parse(ParseNode node)
        {
            var c = node.ReadChar();
            while (c != '\0')
            {
                if (c == '[')
                {
                    while (c != ']')
                        c = node.ReadChar();
                    var statement = new StatementNode
                                        {
                                            Name = "customAttribute",
                                            Data = new StringReader(node.Buffer.ToString())
                                        };
                    yield return statement;
                    c = node.ReadChar();
                    while (c == ' ' || c == '\r' || c == '\n')
                    {
                        node.ResetBuffer();
                        c = node.ReadChar();
                    }

                }
                while (c != ' ' && c != '.' && c != '\0')
                    c = node.ReadChar();

                var value = node.Buffer.ToString(0, node.Buffer.Length - 1);
                if (c == ' ')
                {
                    if (value == "using")
                    {
                        node.ResetBuffer();
                        var statement = new StatementNode
                                            {
                                                Name = "using",
                                                Data = new StringReader(node.GetStringData())
                                            };
                        yield return statement;
                        continue;
                    }

                    if (value == "class")
                    {
                        node.ResetBuffer();
                        c = node.ReadChar();
                        while (c == ' ')
                        {
                            node.ResetBuffer();
                            c = node.ReadChar();
                        }

                        while (c != ' ' && c != '\r' && c != '\n' && c != '\0')
                            c = node.ReadChar();

                        var statement = new StatementNode
                                            {
                                                Name = "class",
                                                Data = new StringReader(node.Buffer.ToString())
                                            };
                        yield return statement;

                        continue;
                    }

                    if (value == "public")
                    {
                        node.ResetBuffer();
                        var statement = new StatementNode
                                            {
                                                Name = "accessModifier",
                                                Data = new StringReader("public")
                                            };
                        yield return statement;
                        c = node.ReadChar();
                        while (c == ' ')
                            c = node.ReadChar();
                        continue;
                    }

                    if (value == "namespace")
                    {
                        node.ResetBuffer();
                        var statement = new StatementNode()
                                            {
                                                Name = "namespace",
                                                Data = new StringReader(node.GetStringData())
                                            };
                        yield return statement;
                        continue;
                    }
                }
                yield break;
            }
            yield break;
        }
Exemplo n.º 43
0
 public BlockNode(StatementNode stat)
 {
     StList = new List <StatementNode>();
     StList.Add(stat);
 }
        //There are a couple of ways to accomplish this...
        //When I hit {, I could go into recursive mode
        //Alternatively, when I hit { I could seek ahead for the end node
        //This causes hard to follow looping logic if done correctly though
        public override IEnumerable<ParseNode> Parse(ParseNode node)
        {
            var c = node.ReadChar();
            while (c != '\0')
            {
                while (c != ';' && c != '{' && c != '\0' && c != '/' && c != '\'' && c != '"')
                    c = node.ReadChar();

                if (c == '"')
                {
                    c = ProcessStringLiteral(node);
                    continue;
                }
                if (c == '/')
                {
                    c = node.ReadChar();
                    if (c == '/')
                    {
                        while (c != '\r')
                            c = node.ReadChar();
                    }
                }
                if (c == '\'')
                {
                    c = ProcessCharacterLiteral(node);
                    continue;
                }
                if (c == ';')
                {
                    var statement = new StatementNode
                                        {
                                            Name = "statement",
                                            Data = new StringReader(node.Buffer.ToString().TrimStart(' ', '\r', '\n', '\t'))
                                        };
                    node.ResetBuffer();
                    c = node.ReadChar();
                    statement.Children = ApplyTemplates(statement).ToArray();

                    yield return statement;
                    continue;
                }
                if (c == '{')
                {
                    var nestCount = 1;
                    while (nestCount > 0)
                    {
                        c = node.ReadChar();
                        //Would be much better to create CharacterLiteral, StringLiteral, Comment classes, then parse them
                        if (c == '/')
                        {
                            c = node.ReadChar();
                            if (c == '/')
                            {
                                while (c != '\r')
                                    c = node.ReadChar();
                            }
                        }
                        if (c == '\'')
                        {
                            ProcessCharacterLiteral(node);
                            continue;
                        }
                        if (c == '{') nestCount++;
                        if (c == '}') nestCount--;
                    }
                    var stringData = node.Buffer.ToString().TrimStart(' ', '\r', '\n', '\t');
                    var firstBracket = stringData.IndexOf('{');
                    var innerData = stringData.Substring(firstBracket + 1, stringData.Length - firstBracket - 2).Trim();

                    var children = new List<ParseNode>();
                    var statementNode = new StatementNode
                                            {
                                                Name = "command",
                                                Data =
                                                    new StringReader(stringData.Substring(0, firstBracket - 1).Trim())
                                            };
                    statementNode.Children = ApplyTemplates(statementNode).ToArray();
                    children.Add(statementNode);

                    var nestedNode = new NestedStatementNode
                                         {
                                             CommandData = stringData.Substring(0, firstBracket - 1).Trim(),
                                             Name = "nestedStatement",
                                             Data = new StringReader(innerData)
                                         };
                    children.AddRange(ApplyTemplates(nestedNode));

                    nestedNode.Children = children;
                    yield return nestedNode;
                    node.ResetBuffer();
                    c = node.ReadChar();
                    continue;
                }
                yield break;
            }
        }
Exemplo n.º 45
0
 public ForNode(StatementNode initialization, StatementNode condition, StatementNode final, StatementNode block)
 {
     Initialization = initialization;
     Condition      = condition;
     Final          = final;
     Block          = block;
 }