示例#1
0
        private bool TryParseEventHandlerAttachStatement(AbstractStatement statement, out IdentifierName eventName, out IFunctionContext handler)
        {
            eventName = null;
            handler   = null;

            if (!(statement is ExpressionStatement expressionStatement) ||
                !(expressionStatement.Expression is AssignmentExpression assignment))
            {
                return(false);
            }

            if (!(assignment.Left is MemberExpression eventMemberExpression) ||
                !(eventMemberExpression.Member is EventMember eventMember) ||
                !(eventMemberExpression.Target is MemberExpression componentMemberExpression) ||
                !(componentMemberExpression.Target is ThisExpression) ||
                componentMemberExpression.Member != this.DeclaredProperty)
            {
                return(false);
            }

            if (!(assignment.Right is IFunctionContext function))
            {
                return(false);
            }

            eventName = eventMember.Name;
            handler   = function;
            return(true);
        }
示例#2
0
        public static StatementSyntax EmitSyntax(AbstractStatement statement)
        {
            if (statement is ReturnStatement statementReturn)
            {
                return(ReturnStatement(ExpressionSyntaxEmitter.EmitSyntax(statementReturn.Expression)));
            }
            if (statement is BlockStatement statementBlock)
            {
                return(statementBlock.ToSyntax());
            }
            if (statement is ThrowStatement statementThrow)
            {
                return(ThrowStatement(ExpressionSyntaxEmitter.EmitSyntax(statementThrow.Exception)));
            }
            if (statement is ExpressionStatement statementExpression)
            {
                return(ExpressionStatement(ExpressionSyntaxEmitter.EmitSyntax(statementExpression.Expression)));
            }
            if (statement is VariableDeclarationStatement statementVariable)
            {
                return(EmitLocalDeclarationSyntax(statementVariable));
            }
            if (statement is IfStatement statementIf)
            {
                return(EmitIfStatementSyntax(statementIf));
            }
            if (statement is LockStatement statementLock)
            {
                return(LockStatement(ExpressionSyntaxEmitter.EmitSyntax(statementLock.SyncRoot), statementLock.Body.ToSyntax()));
            }

            //TODO: support other types of statements

            throw new NotSupportedException($"Syntax emitter is not supported for statement of type '{statement.GetType().Name}'.");
        }
示例#3
0
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     if (PushSelectionRange(stmt))
     {
         base.VisitAbstractStmt(stmt);
     }
 }
示例#4
0
        public static void WriteStatementLine(CodeTextBuilder code, AbstractStatement statement)
        {
            WriteStatement(code, statement);

            if (!(statement is BlockStatement))
            {
                code.WriteLine(";");
            }
        }
 public virtual void VisitAbstractStmt(AbstractStatement stmt)
 {
     if (stmt.Attributes != null && stmt.Attributes.Length != 0)
     {
         foreach (var attr in stmt.Attributes)
         {
             attr.Accept(this);
         }
     }
 }
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     var back = ctxt.ScopedStatement;
     if (back != stmt) {
         ctxt.CurrentContext.Set (stmt);
         OnScopedStatementChanged (stmt);
     }
     base.VisitAbstractStmt (stmt);
     if (back != stmt)
         ctxt.CurrentContext.Set (back);
 }
示例#7
0
 public static void WriteStatement(CodeTextBuilder code, AbstractStatement statement)
 {
     if (WriterByStatementType.TryGetValue(statement.GetType(), out var writer))
     {
         writer(code, statement);
     }
     else
     {
         throw new NotSupportedException(
                   $"Statement of type '{statement.GetType().Name}' is not supported by {nameof(JavaScriptStatementWriter)}.");
     }
 }
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     var back = ctxt.ScopedStatement;
     bool pop = false;
     if (back != stmt) {
         var parentNode = stmt.ParentNode;
         if (parentNode != null && ctxt.ScopedBlock != parentNode) {
             ctxt.PushNewScope (stmt.ParentNode as IBlockNode, stmt);
             pop = true;
         }
         else if (ctxt.ScopedBlock != null)
             ctxt.CurrentContext.Set (stmt);
         else
             back = stmt;
         OnScopedStatementChanged (stmt);
     }
     base.VisitAbstractStmt (stmt);
     if (back != stmt) {
         if (!pop)
             ctxt.CurrentContext.Set (back);
         else
             ctxt.Pop ();
     }
 }
示例#9
0
        public override void VisitAbstractStmt(AbstractStatement stmt)
        {
            var  back = ctxt.ScopedStatement;
            bool pop  = false;

            if (back != stmt)
            {
                var parentNode = stmt.ParentNode;
                if (parentNode != null && ctxt.ScopedBlock != parentNode)
                {
                    ctxt.PushNewScope(stmt.ParentNode as IBlockNode, stmt);
                    pop = true;
                }
                else if (ctxt.ScopedBlock != null)
                {
                    ctxt.CurrentContext.Set(stmt);
                }
                else
                {
                    back = stmt;
                }
                OnScopedStatementChanged(stmt);
            }
            base.VisitAbstractStmt(stmt);
            if (back != stmt)
            {
                if (!pop)
                {
                    ctxt.CurrentContext.Set(back);
                }
                else
                {
                    ctxt.Pop();
                }
            }
        }
        private bool IsAllowed(AbstractStatement statement)
        {
            var type = statement.GetType();

            foreach (var allowable in AllowableStatements)
            {
                if (allowable.IsAssignableFrom(type))
                {
                    return true;
                }
            }

            return false;
        }
 private void FollowStatement(AbstractStatement sourceStatement)
 {
     AbstractStatement readonlyStatement = FindReadOnly(sourceStatement);
     if (null == readonlyStatement)
     {
         readonlyStatement = sourceStatement.CreateReadOnly();
         PrivateAddStatement(sourceStatement.Index, readonlyStatement);
     }
 }
 private AbstractStatement FindReadOnly(AbstractStatement sourceStatement)
 {
     return Statements.FirstOrDefault(x => x.InheritsFrom(sourceStatement));
 }
 public virtual void RemoveStatement(AbstractStatement statement)
 {
     if (statement.IsEditable)
     {
         PrivateRemoveStatement(statement);
     }
 }
 public void InsertBefore(AbstractStatement statement, AbstractStatement toInsert)
 {
     if (IsEditable)
     {
         InsertAt(Statements.IndexOf(statement), toInsert);
     }
 }
 public virtual void InsertAt(int idx, AbstractStatement statement)
 {
     if (IsEditable)
     {
         if (idx != -1)
         {
             if (IsAllowed(statement))
             {
                 statement.RemoveFromParent();
                 PrivateAddStatement(idx, statement);
             }
         }
     }
 }
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     using(ctxt.Push(stmt.ParentNode, stmt))
         base.VisitAbstractStmt (stmt);
 }
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     scopedStatement = stmt;
     base.VisitAbstractStmt (stmt);
 }
        private void PrivateAddStatement(int idx, AbstractStatement statement)
        {
            if (IsAllowed(statement))
            {
                statement.Scope = this;
                Statements.Insert(idx, statement);

                foreach (Plugin plugin in statement.Plugins)
                {
                    Notify(new PluginUsed(plugin));
                }
            }
        }
 private void UnfollowStatement(AbstractStatement sourceStatement)
 {
     AbstractStatement readonlyStatement = FindReadOnly(sourceStatement);
     if (null != readonlyStatement)
     {
         PrivateRemoveStatement(readonlyStatement);
     }
 }
示例#20
0
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     //base.VisitAbstractStmt (stmt);
 }
示例#21
0
 public virtual void VisitAbstractStmt(AbstractStatement stmt)
 {
 }
		public override void VisitAbstractStmt (AbstractStatement stmt)
		{
			//base.VisitAbstractStmt (stmt);
		}
		public InlineAsmCompletionProvider (AbstractStatement gs,ICompletionDataGenerator gen) : base(gen)
		{
			this.gs = gs;
		}
 private void PrivateRemoveStatement(AbstractStatement statement)
 {
     statement.Scope = null;
     Statements.Remove(statement);
 }
 public override void InsertAt(int idx, AbstractStatement statement)
 {
     if (IsEditable)
     {
         var basicCondition = statement as AbstractBasicCondition;
         if (null != basicCondition && idx == -1)
         {
             Else = basicCondition;
         }
         else
         {
             base.InsertAt(idx, statement);
         }
     }
 }
示例#26
0
 public InlineAsmCompletionProvider(AbstractStatement gs, ICompletionDataGenerator gen) : base(gen)
 {
     this.gs = gs;
 }
示例#27
0
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     using (ctxt.Push(stmt.ParentNode, stmt.Location))
         base.VisitAbstractStmt(stmt);
 }
示例#28
0
        //-----------------------------------------------------------------------------------------------------------------------------------------------------

        internal protected virtual void VisitAbstractStatement(AbstractStatement statement)
        {
        }
 public void AddStatement(AbstractStatement statement)
 {
     if (IsAllowed(statement))
     {
         statement.RemoveFromParent();
         PrivateAddStatement(Statements.Count, statement);
     }
 }
 public override void RemoveStatement(AbstractStatement statement)
 {
     if (IsEditable)
     {
         if (statement == Else)
         {
             Else = null;
         }
         else
         {
             base.RemoveStatement(statement);
         }
     }
 }
 public int IndexOf(AbstractStatement statement)
 {
     return Statements.IndexOf(statement);
 }
		public virtual void VisitAbstractStmt(AbstractStatement stmt)
		{
			
		}
 public override void VisitAbstractStmt(AbstractStatement stmt)
 {
     scopedStatement = stmt;
     base.VisitAbstractStmt(stmt);
 }