public CodeForStatement(CodeExpression init, CodeExpression condition,CodeExpression next, CodeStatement statement) { Init = init; Condition = condition; Next = next; Statement = statement; }
public void Ctor_String_CodeTypeReference_ParamsCodeStatement(string localName, CodeTypeReference catchExceptionType, CodeStatement[] statements) { var catchClause = new CodeCatchClause(localName, catchExceptionType, statements); Assert.Equal(localName ?? string.Empty, catchClause.LocalName); Assert.Equal((catchExceptionType ?? new CodeTypeReference(typeof(Exception))).BaseType, catchClause.CatchExceptionType.BaseType); Assert.Equal(statements, catchClause.Statements.Cast<CodeStatement>()); }
public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements) { InitStatement = initStatement; TestExpression = testExpression; IncrementStatement = incrementStatement; Statements.AddRange(statements); }
private static double AddChildItems(string name, CodeStatement<TSqlStatement> sqlModule, CodeCoverageStore store, double parentStatements, string file, TreeViewItem child, ref double parentCoveredStatements, ref double childStatements, ref double childCoveredStatements) { if (string.IsNullOrEmpty(name)) return parentStatements; //need to enumerate the statement tree to find statements (flatten tree - have probably already done it?? maybe can just use a visitor - see count lines of code surely?) var script = File.ReadAllText(sqlModule.FileName); if (script.Length < sqlModule.Length) { //bad tings.... return parentStatements; } IList<ParseError> errors; var statementNodes = ScriptDom.GetStatements(script.Substring(sqlModule.StartLocation, sqlModule.Length), out errors); if (errors != null && errors.Count > 1) { //more bad tings return parentStatements; } var coveredStatements = store.GetCoveredStatements(name, sqlModule.FileName); var beginEndBlocks = statementNodes.Count(p => p.GetType() == typeof (BeginEndBlockStatement)); var statementCount = statementNodes.Count - 1 - beginEndBlocks; parentStatements += statementCount; parentCoveredStatements += coveredStatements?.Count ?? 0; childStatements += statementCount; childCoveredStatements += coveredStatements?.Count ?? 0; //if the file has changed we can't get anything useful from it... if (coveredStatements != null && coveredStatements.Count > 0 && !coveredStatements.Any(p => p.TimeStamp < File.GetLastWriteTimeUtc(file))) { var coveragePercent = ((double) coveredStatements.Count/(double) statementCount)*100; var label = new LabelWithProgressIndicator(string.Format("{0} - {1}% ({2} / {3})", name, coveragePercent, coveredStatements.Count, statementCount), coveragePercent, file); label.Configure(); child.Items.Add(label); } else { var label = new LabelWithProgressIndicator(name + " - 0 %", 0, file); label.Configure(); child.Items.Add(label); } return parentStatements; }
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) { throw new NotImplementedException(); }
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.Format(SR.InvalidElementType, e.GetType().FullName), nameof(e)); } }
/// <summary> /// Determines which statement group the given statement should belong to. The expression parameter /// is an expression that the statement has been reduced to, and targetType represents the type /// of this statement. This method returns the name of the component this statement should be grouped /// with. /// </summary> public virtual string GetTargetComponentName(CodeStatement statement, CodeExpression expression, Type targetType) { throw new NotImplementedException(SR.NotImplementedByDesign); }
public CodeIfStatement(CodeExpression condition, CodeStatement statement, CodeStatement elseStatement) { Condition = condition; Statement = statement; ElseStatement = elseStatement; }
public CodeConditionStatement(CodeExpression condition, CodeStatement[] trueStatements, CodeStatement[] falseStatements) {}
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"); } }
public CodeLabeledStatement(string label, CodeStatement statement) {}
public void GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { bool setLocal = false; if (output != null && w != output.InnerWriter) { throw new InvalidOperationException("Wrong output writer"); } if (output == null) { setLocal = true; options = (o == null) ? new CodeGeneratorOptions() : o; output = new IndentedTextWriter(w, options.IndentString); } try { GenerateStatement(e); } finally { if (setLocal) { output = null; options = null; } } }
// Methods public int Add(CodeStatement value) { }
/// <summary> /// Create a instance cast expression /// </summary> private CodeStatement CreateCastTryCatch(Type toType, CodeExpression targetObject, CodeExpression sourceObject, CodeStatement failExpression) { return(new CodeTryCatchFinallyStatement( new CodeStatement[] { new CodeAssignStatement(targetObject, new CodeCastExpression(new CodeTypeReference(toType), sourceObject)), }, new CodeCatchClause[] { new CodeCatchClause("e", new CodeTypeReference(typeof(Exception)), new CodeExpressionStatement(new CodeMethodInvokeExpression(s_traceError, this.CreateStringFormatExpression("Casting Error: {0}", new CodeVariableReferenceExpression("e")))), failExpression) })); }
private void GenerateStatement(CodeStatement e) { 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 CodeLabeledStatement) { GenerateLabeledStatement((CodeLabeledStatement)e); } else { throw new ArgumentException("Invalid element type: " + e.GetType().FullName, "e"); } }
public void Ctor_NullObjectInStatements_ThrowsArgumentNullException() { CodeStatement[] statements = new CodeStatement[] { null }; AssertExtensions.Throws <ArgumentNullException>("value", () => new CodeCatchClause("name", new CodeTypeReference(typeof(void)), statements)); }
public void GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { throw new BadImageFormatException("6"); }
public CodeTryCatchFinallyStatement(CodeStatement[] tryStatements, CodeCatchClause[] catchClauses, CodeStatement[] finallyStatements) { TryStatements.AddRange(tryStatements); CatchClauses.AddRange(catchClauses); FinallyStatements.AddRange(finallyStatements); }
public static CodeStatement CreateTryCatchStatement(CodeTypeDeclaration classType, CodeStatement statement, CodeGenerationInfo generationInfo) { var tryStatement = new CodeTryCatchFinallyStatement(); tryStatement.TryStatements.Add(statement); var catchClause = new CodeCatchClause("e", new CodeTypeReference("std::exception&")); var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression($"{generationInfo.BaseNamespace}.CremaData"), "InvokeErrorOccured"); var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("e")); var conditionStatement = new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression(methodInvokeExp, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false)) }; conditionStatement.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("e"))); catchClause.Statements.Add(conditionStatement); tryStatement.CatchClauses.Add(catchClause); return(tryStatement); }
public bool Contains(CodeStatement value) { }
public static CodeStatement CreateTryCatchStatement(CodeTypeDeclaration classType, CodeStatement statement, bool isDevmode) { if (isDevmode == false) { return(statement); } var tryStatement = new CodeTryCatchFinallyStatement(); tryStatement.TryStatements.Add(statement); var catchClause = new CodeCatchClause("e"); var methodRefExp = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "onErrorOccured"); var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("e")); var conditionStatement = new CodeConditionStatement(); conditionStatement.Condition = new CodeBinaryOperatorExpression(methodInvokeExp, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false)); conditionStatement.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("e"))); catchClause.Statements.Add(conditionStatement); tryStatement.CatchClauses.Add(catchClause); return(tryStatement); }
public int IndexOf(CodeStatement value) { }
public void Ctor_NullObjectInStatements_ThrowsArgumentNullException() { CodeStatement[] statements = new CodeStatement[] { null }; Assert.Throws<ArgumentNullException>("value", () => new CodeCatchClause("name", new CodeTypeReference(typeof(void)), statements)); }
public void Insert(int index, CodeStatement value) { }
// Generate code for a statement. protected void GenerateStatement(CodeStatement e) { LinePragmaStart(e.LinePragma); if(e is CodeAttachEventStatement) { GenerateAttachEventStatement ((CodeAttachEventStatement)e); } else if(e is CodeCommentStatement) { GenerateCommentStatement ((CodeCommentStatement)e); } else if(e is CodeConditionStatement) { GenerateConditionStatement ((CodeConditionStatement)e); } else if(e is CodeRemoveEventStatement) { GenerateRemoveEventStatement ((CodeRemoveEventStatement)e); } else if(e is CodeVariableDeclarationStatement) { GenerateVariableDeclarationStatement ((CodeVariableDeclarationStatement)e); } else if(e is CodeAssignStatement) { GenerateAssignStatement ((CodeAssignStatement)e); } else if(e is CodeExpressionStatement) { GenerateExpressionStatement ((CodeExpressionStatement)e); } else if(e is CodeGotoStatement) { GenerateGotoStatement ((CodeGotoStatement)e); } else if(e is CodeIterationStatement) { GenerateIterationStatement ((CodeIterationStatement)e); } else if(e is CodeLabeledStatement) { GenerateLabeledStatement ((CodeLabeledStatement)e); } else if(e is CodeMethodReturnStatement) { GenerateMethodReturnStatement ((CodeMethodReturnStatement)e); } else if(e is CodeSnippetStatement) { GenerateSnippetStatement ((CodeSnippetStatement)e); } else if(e is CodeThrowExceptionStatement) { GenerateThrowExceptionStatement ((CodeThrowExceptionStatement)e); } else if(e is CodeTryCatchFinallyStatement) { GenerateTryCatchFinallyStatement ((CodeTryCatchFinallyStatement)e); } else { throw new ArgumentException (S._("Arg_InvalidCodeDom"), "e"); } LinePragmaEnd(e.LinePragma); }
public void Remove(CodeStatement value) { }
void ICodeGenerator.GenerateCodeFromStatement(CodeStatement statement, TextWriter output, CodeGeneratorOptions options) { InitOutput(output, options); GenerateStatement(statement); }
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) => CreateGeneratorHelper().GenerateCodeFromStatement(statement, writer, options);
public CodeCatchClause(string localName, CodeTypeReference catchExceptionType, CodeStatement[] statements) {}
/// <summary> /// Generates methods for loading data from xml files and other types /// to memory /// </summary> public void LoadXml() { CodeMemberMethod LoadXmlMethod = BuildMethodSignature("LoadXml", MemberAttributes.Public, new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <string, string> >() { new System.Collections.Generic.KeyValuePair <string, string>("TableList<T>", "table") }); TheType.Members.Add(LoadXmlMethod); CodeStatement TableNameAssignment = GetAssignment("System.String", "tableName", new CodeVariableReferenceExpression("table.Name")); LoadXmlMethod.Statements.Add(TableNameAssignment); // CodeStatement cas12 = GetMethodInvokationAssignment("string", "fileName", "string", "Format", new System.Collections.Generic.List<KeyValuePair<string, bool>>() { new KeyValuePair<string, bool>("{0}.{1}", false), new KeyValuePair<string, bool>("tableName", true), new KeyValuePair<string, bool>("table.Format", true) }); CodeExpression FormatMethodInvokationStatement = GetMethodInvokationExpression("System.String", "Format", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("{0}\\\\Files\\\\{1}.{2}", false), new KeyValuePair <string, bool>(generateDirectory, false), new KeyValuePair <string, bool>("tableName", true), new KeyValuePair <string, bool>("Format", true) }); CodeStatement FileNameAssignmentStatement = GetAssignment("System.String", "fileName", FormatMethodInvokationStatement); LoadXmlMethod.Statements.Add(FileNameAssignmentStatement); CodeExpression LoadMethodInvokationStatement = GetMethodInvokationExpression("XDocument", "Load", new System.Collections.Generic.List <KeyValuePair <string, bool> > { new KeyValuePair <string, bool>("fileName", true) }); CodeStatement XmlAssignmentStatement = GetAssignment("XDocument", "xdTable", LoadMethodInvokationStatement); CodeStatement DataElementNameAssignmentStatement = GetAssignment("System.String", "xmlDataElement", new CodePrimitiveExpression("Data")); CodeExpression ElementMethodInvokationExpression = GetMethodInvokationExpression("xdTable.Root", "Element", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xmlDataElement", true) }); CodeStatement DataElementAssignmentStatement = GetAssignment("XElement", "xu", ElementMethodInvokationExpression); CodeStatement CheckThatDataExistsStatement = GetUnoConditionIf("xu", CodeBinaryOperatorType.ValueEquality, "null", new List <CodeStatement>() { new CodeMethodReturnStatement() }); CodeExpression ElementsXmlSearchExpression = GetMethodInvokationExpression("xu", "Elements", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("Elements", false) }); CodeStatement ElementsAssignmentStatement = GetAssignment("IEnumerable<XElement>", "elements", ElementsXmlSearchExpression); CodeExpression ToListMethodInvokationExpression = GetMethodInvokationExpression("elements", "ToList", new List <KeyValuePair <string, bool> >()); CodeStatement ElementListAssignmentStatement = GetAssignment("List<XElement>", "lstElements", ToListMethodInvokationExpression); CodeStatement CollectionAddMethodnvokationStatement = GetMethodInvokationStatement("table", "Add", new List <string>() { "xu.Elements(\"Element\")[i]" }); LoadXmlMethod.Statements.Add(DataElementNameAssignmentStatement); LoadXmlMethod.Statements.Add(XmlAssignmentStatement); LoadXmlMethod.Statements.Add(DataElementAssignmentStatement); LoadXmlMethod.Statements.Add(ElementMethodInvokationExpression); LoadXmlMethod.Statements.Add(CheckThatDataExistsStatement); LoadXmlMethod.Statements.Add(ElementsAssignmentStatement); LoadXmlMethod.Statements.Add(ElementListAssignmentStatement); //LoadXmlMethod.Statements.Add(CollectionAddMethodnvokationStatement); List <CodeStatement> lstLoadDbRecordsStatements = CreateLoadXmlStatements("lstElements", "i"); CodeCompoundStatement LoadDbRecordCycleStatement = GetSimpleForInteger("i", new System.Collections.Generic.KeyValuePair <int, string>(0, "lstElements.Count"), 1, lstLoadDbRecordsStatements); LoadXmlMethod.Statements.AddRange(LoadDbRecordCycleStatement.Statements.ToArray()); CodeMemberMethod LoadJsonMethod = BuildMethodSignature("LoadJson", MemberAttributes.Public, new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <string, string> >() { new System.Collections.Generic.KeyValuePair <string, string>("TableList<T>", "table") }); TheType.Members.Add(LoadJsonMethod); CodeMemberMethod LoadOtherTypesMethod = BuildMethodSignature("LoadOtherTypes", MemberAttributes.Public, new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <string, string> >() { new System.Collections.Generic.KeyValuePair <string, string>("TableList<T>", "table") }); TheType.Members.Add(LoadOtherTypesMethod); }
internal static CodeStatement Try(CodeStatement tryStmnt, CodeCatchClause catchClause) { return(new CodeTryCatchFinallyStatement(new CodeStatement[] { tryStmnt }, new CodeCatchClause[] { catchClause })); }
/// <summary> /// Generating the code to load each property from xml to current record in memory(element in collection) /// </summary> /// <param name="propertyElementName">Name of variable that is collection of properties</param> /// <param name="indexName">Name of index for cycle(index)</param> /// <returns>List of load property statements(for inner for cycle)</returns> private List <CodeStatement> CreateLoadPropertyStatements(string propertyElementName, string indexName) { List <CodeStatement> lst = new List <CodeStatement>(); CodeStatement CurrentPropertyXElementAssignStatement = GetAssignment("XElement", "xeCurrentProperty", new CodeVariableReferenceExpression(string.Format("{0}[{1}]", propertyElementName, indexName))); lst.Add(CurrentPropertyXElementAssignStatement); CodeExpression GetAttributeValueInvokationExpression = GetMethodInvokationExpression("this", "GetAttribute", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xeCurrentProperty", true), new KeyValuePair <string, bool>("PropertyValue", false) }); CodeExpression GetAttributeNameInvokeExpression = GetMethodInvokationExpression("this", "GetAttribute", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xeCurrentProperty", true), new KeyValuePair <string, bool>("PropertyName", false) }); CodeStatement PropertyValueAssignStatement = GetAssignment("System.String", "propertyValue", GetAttributeValueInvokationExpression); CodeStatement PropertyNameAssignStatement = GetAssignment("System.String", "propertyName", GetAttributeNameInvokeExpression); lst.Add(PropertyNameAssignStatement); lst.Add(PropertyValueAssignStatement); CodeExpression GetTypeInvokeExpression = GetMethodInvokationExpression("record", "GetType", new List <KeyValuePair <string, bool> >()); CodeStatement RecordTypeAssignStatement = GetAssignment("Type", "recordType", GetTypeInvokeExpression); lst.Add(RecordTypeAssignStatement); CodeExpression GetPropertyInvokationExpression = GetMethodInvokationExpression("recordType", "GetProperty", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("propertyName", true) }); CodeStatement CurrentPropertyAssignStatement = GetAssignment("PropertyInfo", "currentProperty", GetPropertyInvokationExpression); lst.Add(CurrentPropertyAssignStatement); CodeStatement CurrentPropertyTypeAssignStatement = GetAssignment("Type", "currentPropertyType", new CodeVariableReferenceExpression("currentProperty.PropertyType")); lst.Add(CurrentPropertyTypeAssignStatement); CodeExpression ToStringMethodInvokeExpression = GetMethodInvokationExpression("currentPropertyType", "ToString", new List <KeyValuePair <string, bool> >()); CodeStatement PropertyTypeStringAssignStatement = GetAssignment("System.String", "propTypeStr", ToStringMethodInvokeExpression); //lst.Add(PropertyTypeStringAssignStatement); CodeExpression CreateInstanceInvokationExpression = GetMethodInvokationExpression("Activator", "CreateInstance", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("currentPropertyType", true), new KeyValuePair <string, bool>("propertyValue", true) }); CodeStatement PropertyObjectAssignStatement = GetAssignmentWithExpression("objProperty", CreateInstanceInvokationExpression); CodeStatement SetValueInvokationStatement = GetMethodInvokationStatement("currentProperty", "SetValue", new List <string>() { "record", "objProperty" }); CodeStatement SetValueInvokationStatement0 = GetMethodInvokationStatement("pp", "SetValue", new List <string>() { "PropertyObject", "objProperty" }); //lst.Add(PropertyObjectAssignStatement); CodeExpression ce = GetMethodInvokationExpression("TypeDescriptor", "GetConverter", new List <CodeExpression>() { new CodeVariableReferenceExpression("currentPropertyType") }); CodeStatement cs = GetAssignment("TypeConverter", "tcConvert", ce); CodeExpression ce1 = GetMethodInvokationExpression("tcConvert", "ConvertFromString", new List <CodeExpression>() { new CodeVariableReferenceExpression("propertyValue") }); CodeStatement cs1 = GetAssignmentWithExpression("objProperty", ce1); CodeStatement cs0 = GetDeclaration("objProperty", "System.Object"); lst.Add(cs0); CodeExpression cee0 = GetMethodInvokationExpression("currentProperty", "GetValue", new List <CodeExpression>() { new CodeVariableReferenceExpression("record") }); CodeStatement cse0 = GetAssignment("System.Object", "PropertyObject", cee0); CodeExpression cee = GetMethodInvokationExpression("currentPropertyType", "GetProperty", new List <CodeExpression>() { new CodePrimitiveExpression("Value") }); CodeStatement cse = GetAssignment("PropertyInfo", "pp", cee); CodeExpression ce2 = GetMethodInvokationExpression("TypeDescriptor", "GetConverter", new List <CodeExpression>() { new CodeVariableReferenceExpression("pp.PropertyType") }); CodeStatement cs2 = GetAssignment("TypeConverter", "tcConvert", ce2); CodeStatement cs3 = GetAssignmentWithExpression("objProperty", ce1); CodeStatement csIfValueType = GetUnoConditionIf("currentPropertyType.BaseType.Name", CodeBinaryOperatorType.IdentityInequality, "ValueType", false, new List <CodeStatement>() { cse0, cse, cs2, cs3, SetValueInvokationStatement0 }, new List <CodeStatement>() { cs, cs1, SetValueInvokationStatement }); lst.Add(csIfValueType); // lst.Add(SetValueInvokationStatement); return(lst); }
/// <summary> /// This method deserializes a single statement. It is equivalent of calling /// DeserializeStatement, except that it returns an object instance if the /// resulting statement was a variable assign statement, a variable /// declaration with an init expression, or a field assign statement. /// </summary> protected object DeserializeStatementToInstance(IDesignerSerializationManager manager, CodeStatement statement) { throw new NotImplementedException(SR.NotImplementedByDesign); }
/// <summary> /// Generates method that saves records of table to xml file /// </summary> private void SaveXml() { CodeMemberMethod SaveXmlmethod = BuildMethodSignature("SaveXml", MemberAttributes.Public, new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <string, string> >() { new System.Collections.Generic.KeyValuePair <string, string>("TableList<T>", "table") }); TheType.Members.Add(SaveXmlmethod); CodeStatement TableNameAssignStatement = GetAssignment("System.String", "tableName", new CodeVariableReferenceExpression("table.Name")); SaveXmlmethod.Statements.Add(TableNameAssignStatement); // CodeStatement cas12 = GetMethodInvokationAssignment("string", "fileName", "string", "Format", new System.Collections.Generic.List<KeyValuePair<string, bool>>() { new KeyValuePair<string, bool>("{0}.{1}", false), new KeyValuePair<string, bool>("tableName", true), new KeyValuePair<string, bool>("table.Format", true) }); CodeExpression FormatMethodInvokeStatement = GetMethodInvokationExpression("System.String", "Format", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("{0}\\\\Files\\\\{1}.{2}", false), new KeyValuePair <string, bool>(generateDirectory, false), new KeyValuePair <string, bool>("tableName", true), new KeyValuePair <string, bool>("Format", true) }); CodeStatement FileNameAssignStatement = GetAssignment("System.String", "fileName", FormatMethodInvokeStatement); SaveXmlmethod.Statements.Add(FileNameAssignStatement); CodeExpression LoadMethodInvokeExpression = GetMethodInvokationExpression("XDocument", "Load", new System.Collections.Generic.List <KeyValuePair <string, bool> > { new KeyValuePair <string, bool>("fileName", true) }); CodeStatement TableXElementAssignmentStatement = GetAssignment("XDocument", "xdTable", LoadMethodInvokeExpression); CodeStatement DataElementXElementAssignStatement = GetAssignment("System.String", "xmlDataElement", new CodePrimitiveExpression("Data")); CodeExpression SearchElementInXmlStatement = GetMethodInvokationExpression("xdTable.Root", "Element", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xmlDataElement", true) }); CodeStatement XElementAssignStatement = GetAssignment("XElement", "xu", SearchElementInXmlStatement); CodeStatement CreateDataElementXmlObjStatement = GetObjectCreateStatement("XElement", "xu", true, new List <string>() { "Data" }); CodeStatement AddXElementToXmlStatement = GetMethodInvokationStatement("xdTable.Root", "Add", new List <string>() { "xu" }); CodeStatement RemoveAllInvokationStatement = GetMethodInvokationStatement("xu", "RemoveAll", new List <string>()); CodeStatement CheckRecordExistanceStatement = GetUnoConditionIf("xu", CodeBinaryOperatorType.ValueEquality, "null", new List <CodeStatement>() { CreateDataElementXmlObjStatement, AddXElementToXmlStatement }, new List <CodeStatement>() { RemoveAllInvokationStatement }); CodeExpression RemoveMethodInvokationExpression = GetMethodInvokationExpression("xu.Elements()", "Remove", new List <KeyValuePair <string, bool> >()); CodeStatement RemoveMethodInvokationStatement = new CodeExpressionStatement(RemoveMethodInvokationExpression); CodeStatement CollectionAddInvokationStatement = GetMethodInvokationStatement("table", "Add", new List <string>() { "xu.Elements(\"Element\")[i]" }); CodeExpression SearchElementsXElementExpression = GetMethodInvokationExpression("xu", "Elements", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("Elements", false) }); CodeStatement ElementAssignStatement = GetAssignment("IEnumerable<XElement>", "elements", SearchElementsXElementExpression); SaveXmlmethod.Statements.Add(TableXElementAssignmentStatement); SaveXmlmethod.Statements.Add(DataElementXElementAssignStatement); SaveXmlmethod.Statements.Add(XElementAssignStatement); SaveXmlmethod.Statements.Add(CheckRecordExistanceStatement); SaveXmlmethod.Statements.Add(ElementAssignStatement); SaveXmlmethod.Statements.Add(RemoveMethodInvokationStatement); List <CodeStatement> SaveRecordStatements = CreateSaveXmlStatements("table", "i"); CodeCompoundStatement SaveRecordCycleStatement = GetSimpleForInteger("i", new System.Collections.Generic.KeyValuePair <int, string>(0, "table.Count"), 1, SaveRecordStatements); SaveXmlmethod.Statements.AddRange(SaveRecordCycleStatement.Statements.ToArray()); CodeStatement XDocumentSaveInvokeStatement = GetMethodInvokationStatement("xdTable", "Save", new List <string>() { "fileName" }); SaveXmlmethod.Statements.Add(XDocumentSaveInvokeStatement); CodeMemberMethod SaveOtherTypesMethod = BuildMethodSignature("SaveOtherTypes", MemberAttributes.Public, new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <string, string> >() { new System.Collections.Generic.KeyValuePair <string, string>("TableList<T>", "table") }); TheType.Members.Add(SaveOtherTypesMethod); }
protected void GenerateStatement(CodeStatement s) { bool handled = false; #if NET_2_0 if (s.StartDirectives.Count > 0) { GenerateDirectives(s.StartDirectives); } #endif if (s.LinePragma != null) { GenerateLinePragmaStart(s.LinePragma); } CodeAssignStatement assign = s as CodeAssignStatement; if (assign != null) { GenerateAssignStatement(assign); handled = true; } CodeAttachEventStatement attach = s as CodeAttachEventStatement; if (attach != null) { GenerateAttachEventStatement(attach); handled = true; } CodeCommentStatement comment = s as CodeCommentStatement; if (comment != null) { GenerateCommentStatement(comment); handled = true; } CodeConditionStatement condition = s as CodeConditionStatement; if (condition != null) { GenerateConditionStatement(condition); handled = true; } CodeExpressionStatement expression = s as CodeExpressionStatement; if (expression != null) { GenerateExpressionStatement(expression); handled = true; } CodeGotoStatement gotostmt = s as CodeGotoStatement; if (gotostmt != null) { GenerateGotoStatement(gotostmt); handled = true; } CodeIterationStatement iteration = s as CodeIterationStatement; if (iteration != null) { GenerateIterationStatement(iteration); handled = true; } CodeLabeledStatement label = s as CodeLabeledStatement; if (label != null) { GenerateLabeledStatement(label); handled = true; } CodeMethodReturnStatement returnstmt = s as CodeMethodReturnStatement; if (returnstmt != null) { GenerateMethodReturnStatement(returnstmt); handled = true; } CodeRemoveEventStatement remove = s as CodeRemoveEventStatement; if (remove != null) { GenerateRemoveEventStatement(remove); handled = true; } CodeSnippetStatement snippet = s as CodeSnippetStatement; if (snippet != null) { #if NET_2_0 int indent = Indent; try { Indent = 0; GenerateSnippetStatement(snippet); } finally { Indent = indent; } #else GenerateSnippetStatement(snippet); #endif handled = true; } CodeThrowExceptionStatement exception = s as CodeThrowExceptionStatement; if (exception != null) { GenerateThrowExceptionStatement(exception); handled = true; } CodeTryCatchFinallyStatement trycatch = s as CodeTryCatchFinallyStatement; if (trycatch != null) { GenerateTryCatchFinallyStatement(trycatch); handled = true; } CodeVariableDeclarationStatement declaration = s as CodeVariableDeclarationStatement; if (declaration != null) { GenerateVariableDeclarationStatement(declaration); handled = true; } if (!handled) { throw new ArgumentException("Element type " + s + " is not supported."); } if (s.LinePragma != null) { GenerateLinePragmaEnd(s.LinePragma); } #if NET_2_0 if (s.EndDirectives.Count > 0) { GenerateDirectives(s.EndDirectives); } #endif }
/// <summary> /// Generate inner cycle statements for saving table field value to xml /// </summary> /// <param name="propertyElementName">Name of proerty</param> /// <param name="indexName">Cycle index(commonly i,j, k)</param> /// <returns>List of cycle statements</returns> private List <CodeStatement> CreateSavePropertyStatements(string propertyElementName, string indexName) { List <CodeStatement> lst = new List <CodeStatement>(); CodeStatement CurrentPropertyAssignStatement = GetAssignment("PropertyInfo", "pj", new CodeVariableReferenceExpression(string.Format("{0}[{1}]", propertyElementName, indexName))); lst.Add(CurrentPropertyAssignStatement); CodeStatement PropertyXElementDeclarationStatement = GetDeclaration("xeProperty", "XElement"); lst.Add(PropertyXElementDeclarationStatement); CodeStatement PropertyXElementObjectCreateStatement = GetObjectCreateStatement("XElement", "xeProperty", true, new List <string>() { "Property" }); lst.Add(PropertyXElementObjectCreateStatement); CodeExpression PropertyValueGetAttributeInvokeStatement = GetMethodInvokationExpression("this", "GetAttribute", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xeProperty", true), new KeyValuePair <string, bool>("PropertyValue", false) }); CodeExpression PropertyNameGetAttributeInvokeStatement = GetMethodInvokationExpression("this", "GetAttribute", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("xeProperty", true), new KeyValuePair <string, bool>("PropertyName", false) }); CodeStatement NameDeclarationStatement = GetDeclaration("name", "System.String"); lst.Add(NameDeclarationStatement); CodeStatement NameAssignStatement = GetAssignment("name", new KeyValuePair <string, bool>("pj.Name", true)); lst.Add(NameAssignStatement); CodeStatement PropertyNameAssignmentStatement = GetAssignment("System.String", "propertyName", PropertyNameGetAttributeInvokeStatement); lst.Add(PropertyNameAssignmentStatement); CodeExpression PropertyGetValueInvokeStatement = GetMethodInvokationExpression("pj", "GetValue", new System.Collections.Generic.List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("record", true) }); CodeStatement PropertyValueAssignmentStatement = GetAssignment("System.object", "pvalue", PropertyGetValueInvokeStatement); lst.Add(PropertyValueAssignmentStatement); CodeExpression PropertyTypeInvokeExpression = GetMethodInvokationExpression("pvalue", "GetType", new List <KeyValuePair <string, bool> >()); CodeStatement PropertyTypeAssignmentStatement = GetAssignment("Type", "tt", PropertyTypeInvokeExpression); lst.Add(PropertyTypeAssignmentStatement); CodeExpression ValueGetPropertyInvokationExpression = GetMethodInvokationExpression("tt", "GetProperty", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("Value", false) }); CodeStatement ValuePropertyInfoAssignStatement = GetAssignment("PropertyInfo", "pw", ValueGetPropertyInvokationExpression); lst.Add(ValuePropertyInfoAssignStatement); CodeStatement csDeclare = GetDeclaration("value", "System.Object"); lst.Add(csDeclare); CodeExpression ValueGetValueInvokeStatement = GetMethodInvokationExpression("pw", "GetValue", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("pvalue", true) }); CodeStatement ValueAssignStatement = GetAssignmentWithExpression("value", ValueGetValueInvokeStatement); //lst.Add(ValueAssignStatement); CodeStatement css = GetAssignment("value", new KeyValuePair <string, bool> ("pvalue", true)); CodeStatement csIf = GetUnoConditionIf("pw", CodeBinaryOperatorType.IdentityInequality, "null", new List <CodeStatement>() { ValueAssignStatement }, new List <CodeStatement>() { css }); lst.Add(csIf); CodeExpression SetAttributeValueOfNameInvokationExpression = GetMethodInvokationExpression("xeProperty", "SetAttributeValue", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("PropertyName", false), new KeyValuePair <string, bool>("name", true) }); CodeStatement SetAttributeValueNameInvokeStatement = new CodeExpressionStatement(SetAttributeValueOfNameInvokationExpression); lst.Add(SetAttributeValueNameInvokeStatement); CodeExpression SetAttributeValueValueInvokationExpression = GetMethodInvokationExpression("xeProperty", "SetAttributeValue", new List <KeyValuePair <string, bool> >() { new KeyValuePair <string, bool>("PropertyValue", false), new KeyValuePair <string, bool>("value", true) }); CodeStatement SetAttributeValueValueInvokationStatement = new CodeExpressionStatement(SetAttributeValueValueInvokationExpression); lst.Add(SetAttributeValueValueInvokationStatement); CodeStatement XElementAddPropertyInvokeStatement = GetMethodInvokationStatement("xeCurrent", "Add", new List <string>() { "xeProperty" }); lst.Add(XElementAddPropertyInvokeStatement); return(lst); }
public void GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { GenerateCodeFromCodeObject(e, w, o); }
static CodeIterationStatement _ParseForStatement(_PC pc) { // expects to be on for if (!pc.Advance()) { throw new ArgumentException("Unterminated for statement", "input"); } _SkipComments(pc); if (ST.lparen != pc.SymbolId || !pc.Advance()) { throw new ArgumentException("Unterminated for statement", "input"); } _SkipComments(pc); CodeStatement init = null; if (pc.IsEnded) { throw new ArgumentException("Unterminated for statement", "input"); } if (ST.semi != pc.SymbolId) { var pc2 = pc.GetLookAhead(); pc2.EnsureStarted(); try { init = _ParseVariableDeclaration(pc2); } catch { init = null; } } if (null != init) { _ParseVariableDeclaration(pc); _SkipComments(pc); } else { _SkipComments(pc); if (ST.semi != pc.SymbolId) { var e = _ParseExpression(pc); var bbo = e as CodeBinaryOperatorExpression; if (null == e) { throw new NotImplementedException("Expression in init statement was null"); } if (null != bbo && CodeBinaryOperatorType.Assign == bbo.Operator) { init = new CodeAssignStatement(bbo.Left, bbo.Right); } else { init = new CodeExpressionStatement(e); } _SkipComments(pc); if (ST.semi != pc.SymbolId) { throw new ArgumentException("Invalid init statement in for statement", "input"); } if (pc.IsEnded) { throw new ArgumentException("Unterminated for statement", "input"); } } } if (null == init) { if (ST.semi != pc.SymbolId) { throw new ArgumentException("Invalid for statement", "input"); } pc.Advance(); _SkipComments(pc); } if (pc.IsEnded) { throw new ArgumentException("Unterminated for statement", "input"); } CodeExpression test = null; if (ST.semi != pc.SymbolId) { test = _ParseExpression(pc); _SkipComments(pc); if (ST.semi != pc.SymbolId) { throw new ArgumentException("Invalid test expression in for statement", "input"); } if (!pc.Advance()) { throw new ArgumentException("Unterminated for statement", "input"); } } _SkipComments(pc); if (pc.IsEnded) { throw new ArgumentException("Unterminated for statement", "input"); } CodeExpression inc = null; if (ST.rparen != pc.SymbolId) { inc = _ParseExpression(pc); _SkipComments(pc); } if (ST.rparen != pc.SymbolId) { throw new ArgumentNullException("Invalid incremement statement in for loop"); } if (!pc.Advance()) { throw new ArgumentException("Unterminated for statement", "input"); } _SkipComments(pc); if (pc.IsEnded) { throw new ArgumentException("Unterminated for statement", "input"); } var bo = inc as CodeBinaryOperatorExpression; CodeStatement incs = null; if (null != inc) { if (null != bo && CodeBinaryOperatorType.Assign == bo.Operator) { incs = new CodeAssignStatement(bo.Left, bo.Right); } else { incs = new CodeExpressionStatement(inc); } } if (null == init) { init = new CodeSnippetStatement(); } if (null == incs) { incs = new CodeSnippetStatement(); } if (null == test) { test = new CodeSnippetExpression(); } var result = new CodeIterationStatement(init, test, incs); if (ST.lbrace == pc.SymbolId) { if (!pc.Advance()) { throw new ArgumentException("Unterminated for statement", "input"); } while (!pc.IsEnded && ST.rbrace != pc.SymbolId) { result.Statements.Add(_ParseStatement(pc, true)); } if (ST.rbrace != pc.SymbolId) { throw new ArgumentException("Unterminated for statement", "input"); } pc.Advance(); _SkipComments(pc); if (pc.IsEnded) { return(result); } } else { result.Statements.Add(_ParseStatement(pc)); } _SkipComments(pc); return(result); }
public void PublicGenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { ((ICodeGenerator)this).GenerateCodeFromStatement(e, w, o); }
private static void EmitBasicClassMembers(CodeTypeDeclaration srClass, String nameSpace, String baseName, String resourcesNamespace, bool internalClass, bool useStatic) { const String tmpVarName = "temp"; String resMgrCtorParam; if (resourcesNamespace != null) { if (resourcesNamespace.Length > 0) { resMgrCtorParam = resourcesNamespace + '.' + baseName; } else { resMgrCtorParam = baseName; } } else if (!string.IsNullOrEmpty(nameSpace)) { resMgrCtorParam = nameSpace + '.' + baseName; } else { resMgrCtorParam = baseName; } var suppressMessageAttrib = new CodeAttributeDeclaration(new CodeTypeReference(typeof(SuppressMessageAttribute))); suppressMessageAttrib.AttributeType.Options = CodeTypeReferenceOptions.GlobalReference; suppressMessageAttrib.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("Microsoft.Performance"))); suppressMessageAttrib.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("CA1811:AvoidUncalledPrivateCode"))); // Emit a constructor - make it protected even if it is a "static" class to allow subclassing CodeConstructor ctor = new CodeConstructor(); ctor.CustomAttributes.Add(suppressMessageAttrib); if (useStatic || internalClass) { ctor.Attributes = MemberAttributes.FamilyAndAssembly; } else { ctor.Attributes = MemberAttributes.Public; } srClass.Members.Add(ctor); // Emit _resMgr field. var ResMgrCodeTypeReference = new CodeTypeReference(typeof(ResourceManager), CodeTypeReferenceOptions.GlobalReference); var field = new CodeMemberField(ResMgrCodeTypeReference, ResMgrFieldName) { Attributes = MemberAttributes.Private }; if (useStatic) { field.Attributes |= MemberAttributes.Static; } srClass.Members.Add(field); // Emit _resCulture field, and leave it set to null. var CultureTypeReference = new CodeTypeReference(typeof(CultureInfo), CodeTypeReferenceOptions.GlobalReference); field = new CodeMemberField(CultureTypeReference, CultureInfoFieldName); field.Attributes = MemberAttributes.Private; if (useStatic) { field.Attributes |= MemberAttributes.Static; } srClass.Members.Add(field); // Emit ResMgr property CodeMemberProperty resMgr = new CodeMemberProperty(); srClass.Members.Add(resMgr); resMgr.Name = ResMgrPropertyName; resMgr.HasGet = true; resMgr.HasSet = false; resMgr.Type = ResMgrCodeTypeReference; if (internalClass) { resMgr.Attributes = MemberAttributes.Assembly; } else { resMgr.Attributes = MemberAttributes.Public; } if (useStatic) { resMgr.Attributes |= MemberAttributes.Static; } // Mark the ResMgr property as advanced var editorBrowsableStateTypeRef = new CodeTypeReference(typeof(System.ComponentModel.EditorBrowsableState)) { Options = CodeTypeReferenceOptions.GlobalReference }; var editorBrowsableStateAdvanced = new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(editorBrowsableStateTypeRef), "Advanced")); var editorBrowsableAdvancedAttribute = new CodeAttributeDeclaration("System.ComponentModel.EditorBrowsableAttribute", editorBrowsableStateAdvanced); editorBrowsableAdvancedAttribute.AttributeType.Options = CodeTypeReferenceOptions.GlobalReference; resMgr.CustomAttributes.Add(editorBrowsableAdvancedAttribute); // Emit the Culture property (read/write) var culture = new CodeMemberProperty(); srClass.Members.Add(culture); culture.Name = CultureInfoPropertyName; culture.HasGet = true; culture.HasSet = true; culture.Type = CultureTypeReference; if (internalClass) { culture.Attributes = MemberAttributes.Assembly; } else { culture.Attributes = MemberAttributes.Public; } if (useStatic) { culture.Attributes |= MemberAttributes.Static; } // Mark the Culture property as advanced culture.CustomAttributes.Add(editorBrowsableAdvancedAttribute); /* * // Here's what I'm trying to emit. Since not all languages support * // try/finally, we'll avoid our double lock pattern here. * // This will only hurt perf when we get two threads racing through * // this method the first time. Unfortunate, but not a big deal. * // Also, the .NET Compact Framework doesn't support * // Thread.MemoryBarrier (they only run on processors w/ a strong * // memory model, and who knows about IA64...) * // Once we have Interlocked.CompareExchange<T>, we should use it here. * if (_resMgr == null) { * ResourceManager tmp = new ResourceManager("<resources-name-with-namespace>", typeof("<class-name>").Assembly); * _resMgr = tmp; * } * return _resMgr; */ var field_resMgr = new CodeFieldReferenceExpression(null, ResMgrFieldName); var object_equalsMethod = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Object)), "ReferenceEquals"); var isResMgrNull = new CodeMethodInvokeExpression(object_equalsMethod, field_resMgr, new CodePrimitiveExpression(null)); // typeof(<class-name>).Assembly var getAssembly = new CodePropertyReferenceExpression(new CodeTypeOfExpression(new CodeTypeReference(srClass.Name)), "Assembly"); // new ResourceManager(resMgrCtorParam, typeof(<class-name>).Assembly); var newResMgr = new CodeObjectCreateExpression(ResMgrCodeTypeReference, new CodePrimitiveExpression(resMgrCtorParam), getAssembly); var init = new CodeStatement[2]; init[0] = new CodeVariableDeclarationStatement(ResMgrCodeTypeReference, tmpVarName, newResMgr); init[1] = new CodeAssignStatement(field_resMgr, new CodeVariableReferenceExpression(tmpVarName)); resMgr.GetStatements.Add(new CodeConditionStatement(isResMgrNull, init)); resMgr.GetStatements.Add(new CodeMethodReturnStatement(field_resMgr)); // Add a doc comment to the ResourceManager property resMgr.Comments.Add(new CodeCommentStatement(DocCommentSummaryStart, true)); resMgr.Comments.Add(new CodeCommentStatement(SR.GetString(SR.ResMgrPropertyComment), true)); resMgr.Comments.Add(new CodeCommentStatement(DocCommentSummaryEnd, true)); // Emit code for Culture property var field_resCulture = new CodeFieldReferenceExpression(null, CultureInfoFieldName); culture.GetStatements.Add(new CodeMethodReturnStatement(field_resCulture)); var newCulture = new CodePropertySetValueReferenceExpression(); culture.SetStatements.Add(new CodeAssignStatement(field_resCulture, newCulture)); // Add a doc comment to Culture property culture.Comments.Add(new CodeCommentStatement(DocCommentSummaryStart, true)); culture.Comments.Add(new CodeCommentStatement(SR.GetString(SR.CulturePropertyComment1), true)); culture.Comments.Add(new CodeCommentStatement(SR.GetString(SR.CulturePropertyComment2), true)); culture.Comments.Add(new CodeCommentStatement(DocCommentSummaryEnd, true)); }
public void Remove(CodeStatement value) {}
public void Ctor_NullObjectInStatements_ThrowsArgumentNullException() { CodeStatement[] statements = new CodeStatement[] { null }; AssertExtensions.Throws <ArgumentNullException>("value", () => new CodeIterationStatement(null, null, null, statements)); }
public CodeForEachStatement(CodeVariableReference id, CodeExpression container, CodeStatement statement) { Container = container; Id = id; Statement = statement; }
private static void AddStatementWithLinePragma(Block block, CodeStatementCollection statements, CodeStatement statement) { var lineNumber = (block.StartLine > 0) ? block.StartLine : 1; if (String.IsNullOrEmpty(block.Name)) { statements.Add(new CodeSnippetStatement("#line " + lineNumber)); } else { statement.LinePragma = new CodeLinePragma(block.Name, lineNumber); } statements.Add(statement); if (String.IsNullOrEmpty(block.Name)) { statements.Add(new CodeSnippetStatement("#line default")); } }
// Generate code from a CodeDom statement. void ICodeGenerator.GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { bool initialized = SetupForCodeGeneration(w, o); try { GenerateStatement(e); } finally { FinalizeCodeGeneration(initialized); } }
public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, CodeStatement[] statements) {}
private void GenerateMemberAssignment(CodeMemberMethod initComponentMethod, MemberNode member, CodeExpression targetExpression, CodeExpression valueExpression, CodeDomObjectNode targetObjectNode) { CodeStatement cs = null; //if (member.Member.IsUnknown) //{ // throw new Exception("Unknown member " + member.Member.Name); //} if (member.Member == XamlLanguage.Items) { var parentObjectNode = member.ParentObjectNode; XamlType parentType = null; if (parentObjectNode.IsGetObject) { parentType = parentObjectNode.ParentMemberNode.Member.Type; } else { parentType = parentObjectNode.Type; } if (parentType.IsDictionary) { if (!typeof(IDictionary).IsAssignableFrom(parentType.UnderlyingType)) { throw new NotImplementedException("Support non-IDictionary adds"); } CodeExpression keyExpression; if (targetObjectNode.XKeyNode != null) { keyExpression = new CodeSnippetExpression("\"" + ((ValueNode)targetObjectNode.XKeyNode.ItemNodes[0]).Value + "\""); } else { if (targetObjectNode.DictionaryKeyProperty == null) { throw new NotSupportedException("No key on dictionary entry"); } throw new NotImplementedException(); } cs = new CodeExpressionStatement( new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IDictionary), targetExpression), "Add", keyExpression, valueExpression)); } else { if (!typeof(IList).IsAssignableFrom(parentType.UnderlyingType)) { throw new NotImplementedException("Support non-IList adds"); } //TODO: calling Add directly is how I'll leave it for now... //cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IList), targetExpression), "Add", valueExpression)); cs = new CodeExpressionStatement(new CodeMethodInvokeExpression(targetExpression, "Add", valueExpression)); } } else if (member.Member.IsEvent) { throw new NotImplementedException(); } else { if (member.Member.IsAttachable) { cs = new CodeExpressionStatement(new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(member.Member.DeclaringType.UnderlyingType.Name), "Set" + member.Member.Name), targetExpression, valueExpression)); } else //normal property { cs = new CodeAssignStatement( new CodePropertyReferenceExpression(targetExpression, member.Member.Name), valueExpression); } } initComponentMethod.Statements.Add(cs); }
protected void GenerateStatement(CodeStatement s) { try { s.Accept(visitor); } catch (NotImplementedException) { throw new ArgumentException("Element type " + s.GetType() + " is not supported.", "s"); } }
void ICodeGenerator.GenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o) { bool setLocal = false; if (_output != null && w != _output.InnerWriter) { throw new InvalidOperationException(SR.CodeGenOutputWriter); } if (_output == null) { setLocal = true; _options = o ?? new CodeGeneratorOptions(); _output = new ExposedTabStringIndentedTextWriter(w, _options.IndentString); } try { GenerateStatement(e); } finally { if (setLocal) { _output = null; _options = null; } } }
public CodeLabeledStatement(string label, CodeStatement statement) { _label = label; Statement = statement; }
public CodeStatementCollection(CodeStatement[] value) {}
public CodeSwitchCase(CodeExpression condition, CodeStatement statement) { Condition = condition; Statement = statement; }
public void Insert(int index, CodeStatement value) {}
internal static CodeStatement ForLoop(CodeStatement initStmt, CodeExpression testExpression, CodeStatement incrementStmt, CodeStatement[] statements) { return(new CodeIterationStatement(initStmt, testExpression, incrementStmt, statements)); }
// Methods public int Add(CodeStatement value) {}
protected 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.Format(SR.InvalidElementType, e.GetType().FullName), nameof(e)); } if (e.LinePragma != null) { GenerateLinePragmaEnd(e.LinePragma); } if (e.EndDirectives.Count > 0) { GenerateDirectives(e.EndDirectives); } }
internal static CodeStatement If(CodeExpression cond, CodeStatement trueStm) { return(If(cond, new CodeStatement[] { trueStm })); }
public virtual void GenerateCodeFromStatement(CodeStatement statement, TextWriter writer, CodeGeneratorOptions options) { ICodeGenerator cg = CreateGenerator(); if (cg == null) throw GetNotImplemented(); cg.GenerateCodeFromStatement(statement, writer, options); }
internal static CodeStatement If(CodeExpression cond, CodeStatement trueStm, CodeStatement falseStm) { return(new CodeConditionStatement(cond, new CodeStatement[] { trueStm }, new CodeStatement[] { falseStm })); }