private static RuleCodeDomStatement GetStatement(CodeStatement statement) { Type type = statement.GetType(); if (type == typeof(CodeExpressionStatement)) { return ExpressionStatement.Create(statement); } if (type == typeof(CodeAssignStatement)) { return AssignmentStatement.Create(statement); } NotSupportedException exception = new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Messages.CodeStatementNotHandled, new object[] { statement.GetType().FullName })); exception.Data["ErrorObject"] = statement; throw exception; }
internal static bool Match(CodeStatement firstStatement, CodeStatement secondStatement) { if ((firstStatement == null) && (secondStatement == null)) { return true; } if ((firstStatement == null) || (secondStatement == null)) { return false; } if (firstStatement.GetType() != secondStatement.GetType()) { return false; } return GetStatement(firstStatement).Match(secondStatement); }
void EmitStatement(CodeStatement Statement, bool ForceTypes) { if(Statement == null) return; Depth++; Debug("Emitting statement"); if(Statement is CodeAssignStatement) { EmitAssignStatement(Statement as CodeAssignStatement, ForceTypes); } else if(Statement is CodeExpressionStatement) { EmitExpressionStatement(Statement as CodeExpressionStatement, ForceTypes); } else if(Statement is CodeIterationStatement) { EmitIterationStatement(Statement as CodeIterationStatement); } else if(Statement is CodeConditionStatement) { EmitConditionStatement(Statement as CodeConditionStatement); } else if(Statement is CodeGotoStatement) { EmitGotoStatement(Statement as CodeGotoStatement); } else if(Statement is CodeLabeledStatement) { EmitLabeledStatement(Statement as CodeLabeledStatement); } else if(Statement is CodeMethodReturnStatement) { EmitReturnStatement(Statement as CodeMethodReturnStatement); } else if(Statement is CodeVariableDeclarationStatement) { EmitVariableDeclarationStatement(Statement as CodeVariableDeclarationStatement); } else { Depth++; Debug("Unhandled statement: "+Statement.GetType()); Depth--; } Depth--; }
private void EmitStatement(CodeStatement statement) { if (statement is CodeAssignStatement) EmitAssignment((CodeAssignStatement) statement); else if (statement is CodeExpressionStatement) EmitExpressionStatement(((CodeExpressionStatement) statement).Expression); else if (statement is CodeIterationStatement) EmitIteration((CodeIterationStatement) statement); else if (statement is CodeConditionStatement) EmitConditionStatement((CodeConditionStatement) statement); else if (statement is CodeGotoStatement) EmitGoto((CodeGotoStatement) statement); else if (statement is CodeLabeledStatement) EmitLabel((CodeLabeledStatement) statement); else if (statement is CodeMethodReturnStatement) EmitReturn((CodeMethodReturnStatement) statement); else if (statement is CodeVariableDeclarationStatement) EmitVariableDeclaration((CodeVariableDeclarationStatement) statement); else if (statement is CodeCommentStatement) EmitComment((CodeCommentStatement) statement); else throw new ArgumentException("Unrecognised statement: " + statement.GetType()); }
/// <devdoc> /// <para> /// Generates code for /// the specified CodeDom based statement representation. /// </para> /// </devdoc> private void GenerateStatement(CodeStatement e) { if (e.StartDirectives.Count > 0) { GenerateDirectives(e.StartDirectives); } if (e.LinePragma != null) { GenerateLinePragmaStart(e.LinePragma); } if (e is CodeCommentStatement) { GenerateCommentStatement((CodeCommentStatement)e); } else if (e is CodeMethodReturnStatement) { GenerateMethodReturnStatement((CodeMethodReturnStatement)e); } else if (e is CodeConditionStatement) { GenerateConditionStatement((CodeConditionStatement)e); } else if (e is CodeTryCatchFinallyStatement) { GenerateTryCatchFinallyStatement((CodeTryCatchFinallyStatement)e); } else if (e is CodeAssignStatement) { GenerateAssignStatement((CodeAssignStatement)e); } else if (e is CodeExpressionStatement) { GenerateExpressionStatement((CodeExpressionStatement)e); } else if (e is CodeIterationStatement) { GenerateIterationStatement((CodeIterationStatement)e); } else if (e is CodeThrowExceptionStatement) { GenerateThrowExceptionStatement((CodeThrowExceptionStatement)e); } else if (e is CodeSnippetStatement) { // Don't indent snippet statements, in order to preserve the column // information from the original code. This improves the debugging // experience. int savedIndent = Indent; Indent=0; GenerateSnippetStatement((CodeSnippetStatement)e); // Restore the indent Indent=savedIndent; } else if (e is CodeVariableDeclarationStatement) { GenerateVariableDeclarationStatement((CodeVariableDeclarationStatement)e); } else if (e is CodeAttachEventStatement) { GenerateAttachEventStatement((CodeAttachEventStatement)e); } else if (e is CodeRemoveEventStatement) { GenerateRemoveEventStatement((CodeRemoveEventStatement)e); } else if (e is CodeGotoStatement) { GenerateGotoStatement((CodeGotoStatement)e); } else if (e is CodeLabeledStatement) { GenerateLabeledStatement((CodeLabeledStatement)e); } else { throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e"); } if (e.LinePragma != null) { GenerateLinePragmaEnd(e.LinePragma); } if (e.EndDirectives.Count > 0) { GenerateDirectives(e.EndDirectives); } }
private void ValidateStatement(CodeStatement e) { ValidateCodeDirectives(e.StartDirectives); ValidateCodeDirectives(e.EndDirectives); if (e is CodeCommentStatement) { ValidateCommentStatement((CodeCommentStatement)e); } else if (e is CodeMethodReturnStatement) { ValidateMethodReturnStatement((CodeMethodReturnStatement)e); } else if (e is CodeConditionStatement) { ValidateConditionStatement((CodeConditionStatement)e); } else if (e is CodeTryCatchFinallyStatement) { ValidateTryCatchFinallyStatement((CodeTryCatchFinallyStatement)e); } else if (e is CodeAssignStatement) { ValidateAssignStatement((CodeAssignStatement)e); } else if (e is CodeExpressionStatement) { ValidateExpressionStatement((CodeExpressionStatement)e); } else if (e is CodeIterationStatement) { ValidateIterationStatement((CodeIterationStatement)e); } else if (e is CodeThrowExceptionStatement) { ValidateThrowExceptionStatement((CodeThrowExceptionStatement)e); } else if (e is CodeSnippetStatement) { ValidateSnippetStatement((CodeSnippetStatement)e); } else if (e is CodeVariableDeclarationStatement) { ValidateVariableDeclarationStatement((CodeVariableDeclarationStatement)e); } else if (e is CodeAttachEventStatement) { ValidateAttachEventStatement((CodeAttachEventStatement)e); } else if (e is CodeRemoveEventStatement) { ValidateRemoveEventStatement((CodeRemoveEventStatement)e); } else if (e is CodeGotoStatement) { ValidateGotoStatement((CodeGotoStatement)e); } else if (e is CodeLabeledStatement) { ValidateLabeledStatement((CodeLabeledStatement)e); } else { throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e"); } }
void AppendStatement(CodeStatement statement) { if (statement is CodeExpressionStatement) { AppendExpressionStatement((CodeExpressionStatement)statement); } else if (statement is CodeCommentStatement) { AppendCommentStatement((CodeCommentStatement)statement); } else if (statement is CodeAssignStatement) { AppendAssignStatement((CodeAssignStatement)statement); } else if (statement is CodeVariableDeclarationStatement) { AppendVariableDeclarationStatement((CodeVariableDeclarationStatement)statement); } else if (statement is CodeAttachEventStatement) { AppendAttachEventStatement((CodeAttachEventStatement)statement); } else { Console.WriteLine("AppendStatement: " + statement.GetType().Name); } }
internal static bool Match(CodeStatement firstStatement, CodeStatement secondStatement) { // If they're both null, they match. if (firstStatement == null && secondStatement == null) return true; // If only one of them is null, there's no match. if (firstStatement == null || secondStatement == null) return false; if (firstStatement.GetType() != secondStatement.GetType()) return false; RuleCodeDomStatement ruleStmt = GetStatement(firstStatement); return ruleStmt.Match(secondStatement); }
private void RefactorMethodNamesInStatement(CodeStatement statement, string newName) { if (typeof(CodeVariableDeclarationStatement) == statement.GetType()) { CodeVariableDeclarationStatement vdeclStatement = (CodeVariableDeclarationStatement)statement; if (vdeclStatement.InitExpression != null) { if (typeof(CodeCastExpression) == vdeclStatement.InitExpression.GetType()) { CodeCastExpression castExp = (CodeCastExpression)vdeclStatement.InitExpression; if (typeof(CodeMethodInvokeExpression) == castExp.Expression.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)castExp.Expression; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } else if (typeof(CodeMethodInvokeExpression) == vdeclStatement.InitExpression.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)vdeclStatement.InitExpression; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } } else if (typeof(CodeExpressionStatement) == statement.GetType()) { CodeExpressionStatement ceStatement = (CodeExpressionStatement)statement; if (typeof(CodeMethodInvokeExpression) == ceStatement.Expression.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)ceStatement.Expression; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } else if (typeof(CodeAssignStatement) == statement.GetType()) { CodeAssignStatement asnStatement = (CodeAssignStatement)statement; if (typeof(CodeCastExpression) == asnStatement.Right.GetType()) { CodeCastExpression castExp = (CodeCastExpression)asnStatement.Right; if (typeof(CodeMethodInvokeExpression) == castExp.Expression.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)castExp.Expression; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } else if (typeof(CodeMethodInvokeExpression) == asnStatement.Right.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)asnStatement.Right; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } else if (typeof(CodeMethodReturnStatement) == statement.GetType()) { CodeMethodReturnStatement retStatement = (CodeMethodReturnStatement)statement; if (typeof(CodeMethodInvokeExpression) == retStatement.Expression.GetType()) { CodeMethodInvokeExpression miExp = (CodeMethodInvokeExpression)retStatement.Expression; miExp.Method.MethodName = PascalCaseConverterHelper.GetPascalCaseMethodName(miExp.Method.MethodName); } } }
void VisitCodeStatement(CodeStatement statement) { WriteLine("VisitCodeStatement: " + statement.GetType().Name); CodeVariableDeclarationStatement codeVariableDeclarationStatement = statement as CodeVariableDeclarationStatement; CodeAssignStatement codeAssignStatement = statement as CodeAssignStatement; CodeConditionStatement codeConditionStatement = statement as CodeConditionStatement; CodeIterationStatement codeIterationStatement = statement as CodeIterationStatement; CodeExpressionStatement codeExpressionStatement = statement as CodeExpressionStatement; CodeTryCatchFinallyStatement codeTryCatchFinallyStatement = statement as CodeTryCatchFinallyStatement; if (codeVariableDeclarationStatement != null) { VisitCodeVariableDeclarationStatement(codeVariableDeclarationStatement); } else if (codeAssignStatement != null) { VisitCodeAssignStatement(codeAssignStatement); } else if (codeConditionStatement != null) { VisitCodeConditionStatement(codeConditionStatement); } else if (codeIterationStatement != null) { VisitCodeIterationStatement(codeIterationStatement); } else if (codeExpressionStatement != null) { VisitCodeExpressionStatement(codeExpressionStatement); } else if (codeTryCatchFinallyStatement != null) { VisitCodeTryCatchFinallyStatement(codeTryCatchFinallyStatement); } else { WriteLine("Unhandled statement: " + statement.GetType().Name); } }
private void GenerateStatement(CodeStatement e) { if (e.StartDirectives.Count > 0) { this.GenerateDirectives(e.StartDirectives); } if (e.LinePragma != null) { this.GenerateLinePragmaStart(e.LinePragma); } if (e is CodeCommentStatement) { this.GenerateCommentStatement((CodeCommentStatement) e); } else if (e is CodeMethodReturnStatement) { this.GenerateMethodReturnStatement((CodeMethodReturnStatement) e); } else if (e is CodeConditionStatement) { this.GenerateConditionStatement((CodeConditionStatement) e); } else if (e is CodeTryCatchFinallyStatement) { this.GenerateTryCatchFinallyStatement((CodeTryCatchFinallyStatement) e); } else if (e is CodeAssignStatement) { this.GenerateAssignStatement((CodeAssignStatement) e); } else if (e is CodeExpressionStatement) { this.GenerateExpressionStatement((CodeExpressionStatement) e); } else if (e is CodeIterationStatement) { this.GenerateIterationStatement((CodeIterationStatement) e); } else if (e is CodeThrowExceptionStatement) { this.GenerateThrowExceptionStatement((CodeThrowExceptionStatement) e); } else if (e is CodeSnippetStatement) { int num1 = this.Indent; this.Indent = 0; this.GenerateSnippetStatement((CodeSnippetStatement) e); this.Indent = num1; } else if (e is CodeVariableDeclarationStatement) { this.GenerateVariableDeclarationStatement((CodeVariableDeclarationStatement) e); } else if (e is CodeAttachEventStatement) { this.GenerateAttachEventStatement((CodeAttachEventStatement) e); } else if (e is CodeRemoveEventStatement) { this.GenerateRemoveEventStatement((CodeRemoveEventStatement) e); } else if (e is CodeGotoStatement) { this.GenerateGotoStatement((CodeGotoStatement) e); } else { if (!(e is CodeLabeledStatement)) { throw new ArgumentException("InvalidElementType" + e, e.GetType().FullName ); } this.GenerateLabeledStatement((CodeLabeledStatement) e); } if (e.LinePragma != null) { this.GenerateLinePragmaEnd(e.LinePragma); } if (e.EndDirectives.Count > 0) { this.GenerateDirectives(e.EndDirectives); } }
/// <include file='doc\CodeGenerator.uex' path='docs/doc[@for="CodeGenerator.GenerateStatement"]/*' /> /// <devdoc> /// <para> /// Generates code for /// the specified CodeDom based statement representation. /// </para> /// </devdoc> protected void GenerateStatement(CodeStatement e) { if (e.LinePragma != null) { GenerateLinePragmaStart(e.LinePragma); } if (e is CodeCommentStatement) { GenerateCommentStatement((CodeCommentStatement)e); } else if (e is CodeMethodReturnStatement) { GenerateMethodReturnStatement((CodeMethodReturnStatement)e); } else if (e is CodeConditionStatement) { GenerateConditionStatement((CodeConditionStatement)e); } else if (e is CodeTryCatchFinallyStatement) { GenerateTryCatchFinallyStatement((CodeTryCatchFinallyStatement)e); } else if (e is CodeAssignStatement) { GenerateAssignStatement((CodeAssignStatement)e); } else if (e is CodeExpressionStatement) { GenerateExpressionStatement((CodeExpressionStatement)e); } else if (e is CodeIterationStatement) { GenerateIterationStatement((CodeIterationStatement)e); } else if (e is CodeThrowExceptionStatement) { GenerateThrowExceptionStatement((CodeThrowExceptionStatement)e); } else if (e is CodeSnippetStatement) { GenerateSnippetStatement((CodeSnippetStatement)e); } else if (e is CodeVariableDeclarationStatement) { GenerateVariableDeclarationStatement((CodeVariableDeclarationStatement)e); } else if (e is CodeAttachEventStatement) { GenerateAttachEventStatement((CodeAttachEventStatement)e); } else if (e is CodeRemoveEventStatement) { GenerateRemoveEventStatement((CodeRemoveEventStatement)e); } else if (e is CodeGotoStatement) { GenerateGotoStatement((CodeGotoStatement)e); } else if (e is CodeLabeledStatement) { GenerateLabeledStatement((CodeLabeledStatement)e); } else { throw new ArgumentException(SR.GetString(SR.InvalidElementType, e.GetType().FullName), "e"); } if (e.LinePragma != null) { GenerateLinePragmaEnd(e.LinePragma); } }
private Statement Translate(CodeStatement statement){ if (statement == null) return null; if (statement is CodeAssignStatement) return this.Translate((CodeAssignStatement)statement); if (statement is CodeAttachEventStatement) return this.Translate((CodeAttachEventStatement)statement); if (statement is CodeCommentStatement) return this.Translate((CodeCommentStatement)statement); if (statement is CodeConditionStatement) return this.Translate((CodeConditionStatement)statement); if (statement is CodeExpressionStatement) return this.Translate((CodeExpressionStatement)statement); if (statement is CodeGotoStatement) return this.Translate((CodeGotoStatement)statement); if (statement is CodeIterationStatement) return this.Translate((CodeIterationStatement)statement); if (statement is CodeLabeledStatement) return this.Translate((CodeLabeledStatement)statement); if (statement is CodeMethodReturnStatement) return this.Translate((CodeMethodReturnStatement)statement); if (statement is CodeRemoveEventStatement) return this.Translate((CodeRemoveEventStatement)statement); if (statement is CodeSnippetStatement) return this.Translate((CodeSnippetStatement)statement); if (statement is CodeThrowExceptionStatement) return this.Translate((CodeThrowExceptionStatement)statement); if (statement is CodeTryCatchFinallyStatement) return this.Translate((CodeTryCatchFinallyStatement)statement); if (statement is CodeVariableDeclarationStatement) return this.Translate((CodeVariableDeclarationStatement)statement); throw new ArgumentException("unknown statement", statement.GetType().FullName); }
private CodeTypeReferenceCollection GetCodeTypeReferenceInCodeStatement(CodeStatement statement) { CodeTypeReferenceCollection references = new CodeTypeReferenceCollection(); // Is this a variable declaration statement? if (typeof(CodeVariableDeclarationStatement) == statement.GetType()) { // Add CodeTypeReference used to define the type of the variable to output. CodeVariableDeclarationStatement vdeclStatement = (CodeVariableDeclarationStatement)statement; references.Add(vdeclStatement.Type); // Do we have an initialization expression? if (vdeclStatement.InitExpression != null) { // Add CodeTypeReference in the initialization statement if available. CodeTypeReference r = GetCodeTypeReferenceInCodeExpression(vdeclStatement.InitExpression); Debug.Assert(r != null, "Could not obtain a proper CodeTypeReference from the variable initialization expression."); if (r == null) { Debugger.Break(); } references.Add(r); } } //// Is this a return statement? //else if (typeof(CodeMethodReturnStatement) == statement.GetType()) //{ // CodeMethodReturnStatement retStatement = (CodeMethodReturnStatement)statement; // // Add CodeTypeReference in the return statement if available. // CodeTypeReference r = GetCodeTypeReferenceInCodeExpression(retStatement.Expression); // Debug.Assert(r != null, "Could not obtain a proper CodeTypeReference from the variable initialization expression."); // references.Add(r); //} // Finally return the references. return references; }
private static void PrintStatement(TextWriter output, CodeStatement statement) { if (statement is CodeVariableDeclarationStatement) { PrintVariableDeclarationStatement(output, (CodeVariableDeclarationStatement)statement); return; } if (statement is CodeExpressionStatement) { PrintExpressionStatement(output, (CodeExpressionStatement)statement); return; } if (statement is CodeMethodReturnStatement) { PrintMethodReturnStatement(output, (CodeMethodReturnStatement)statement); return; } if (statement is CodeAssignStatement) { PrintAssignStatement(output, (CodeAssignStatement)statement); return; } if (statement is CodeThrowExceptionStatement) { PrintThrowExceptionStatement(output, (CodeThrowExceptionStatement)statement); return; } if (statement is CodeConditionStatement) { PrintConditionStatement(output, (CodeConditionStatement)statement); return; } if (statement is CodeCommentStatement) { PrintCommentStatement(output, (CodeCommentStatement)statement); return; } output.WriteLine("*** UNKNOWN STATEMENT: " + statement.GetType() + " ***"); }
private static RuleCodeDomStatement GetStatement(CodeStatement statement) { Type statementType = statement.GetType(); RuleCodeDomStatement wrapper = null; if (statementType == typeof(CodeExpressionStatement)) { wrapper = ExpressionStatement.Create(statement); } else if (statementType == typeof(CodeAssignStatement)) { wrapper = AssignmentStatement.Create(statement); } else { string message = string.Format(CultureInfo.CurrentCulture, Messages.CodeStatementNotHandled, statement.GetType().FullName); NotSupportedException exception = new NotSupportedException(message); exception.Data[RuleUserDataKeys.ErrorObject] = statement; throw exception; } return wrapper; }
protected void GenerateStatement (CodeStatement s) { if (s.StartDirectives.Count > 0) GenerateDirectives (s.StartDirectives); if (s.LinePragma != null) GenerateLinePragmaStart (s.LinePragma); CodeSnippetStatement snippet = s as CodeSnippetStatement; if (snippet != null) { int indent = Indent; try { Indent = 0; GenerateSnippetStatement (snippet); } finally { Indent = indent; } } else { try { s.Accept (visitor); } catch (NotImplementedException) { throw new ArgumentException ("Element type " + s.GetType () + " is not supported.", "s"); } } if (s.LinePragma != null) GenerateLinePragmaEnd (s.LinePragma); if (s.EndDirectives.Count > 0) GenerateDirectives (s.EndDirectives); }
public IStatement GetStatement(CodeStatement codeStatement, CodeGeneratorOptions codeGeneratorOptions) { return _statementMap[codeStatement.GetType()](codeStatement, codeGeneratorOptions); }