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); }
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}'."); }
public override void VisitAbstractStmt(AbstractStatement stmt) { if (PushSelectionRange(stmt)) { base.VisitAbstractStmt(stmt); } }
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); }
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 (); } }
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); } }
public override void VisitAbstractStmt(AbstractStatement stmt) { //base.VisitAbstractStmt (stmt); }
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); } } }
public InlineAsmCompletionProvider(AbstractStatement gs, ICompletionDataGenerator gen) : base(gen) { this.gs = gs; }
public override void VisitAbstractStmt(AbstractStatement stmt) { using (ctxt.Push(stmt.ParentNode, stmt.Location)) base.VisitAbstractStmt(stmt); }
//----------------------------------------------------------------------------------------------------------------------------------------------------- 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 override void VisitAbstractStmt(AbstractStatement stmt) { scopedStatement = stmt; base.VisitAbstractStmt(stmt); }