public void CodeAssignStatementTest () { CodeSnippetExpression cse1 = new CodeSnippetExpression("A"); CodeSnippetExpression cse2 = new CodeSnippetExpression("B"); CodeAssignStatement assignStatement = new CodeAssignStatement (cse1, cse2); statement = assignStatement; Assert.AreEqual (string.Format (CultureInfo.InvariantCulture, "A = B;{0}", NewLine), Generate (), "#1"); assignStatement.Left = null; try { Generate (); Assert.Fail ("#2"); } catch (ArgumentNullException) { } assignStatement.Left = cse1; Generate (); assignStatement.Right = null; try { Generate (); Assert.Fail ("#3"); } catch (ArgumentNullException) { } assignStatement.Right = cse2; Generate (); }
public void Constructor1 () { string value = "mono"; CodeSnippetExpression cse = new CodeSnippetExpression (value); Assert.IsNotNull (cse.Value, "#1"); Assert.AreSame (value, cse.Value, "#2"); }
public TypescriptSnippetExpression( CodeSnippetExpression codeExpression, CodeGeneratorOptions options) { _codeExpression = codeExpression; _options = options; System.Diagnostics.Debug.WriteLine("TypescriptSnippetExpression Created"); }
public void Constructor0 () { CodeSnippetExpression cse = new CodeSnippetExpression (); Assert.IsNotNull (cse.Value, "#1"); Assert.AreEqual (string.Empty, cse.Value, "#2"); string value = "mono"; cse.Value = value; Assert.IsNotNull (cse.Value, "#3"); Assert.AreSame (value, cse.Value, "#4"); cse.Value = null; Assert.IsNotNull (cse.Value, "#5"); Assert.AreEqual (string.Empty, cse.Value, "#6"); }
private static void LoadEnumElement(XmlElement element, CodeTypeDeclaration codeType, out CodeMemberProperty codeProperty) { codeProperty = new CodeMemberProperty(); string name = element.GetAttribute("name"); CodeTypeDeclaration codeEnum = new CodeTypeDeclaration(ToPublicName(name) + "Enum"); codeEnum.IsEnum = true; codeEnum.Members.Add(new CodeSnippetTypeMember(element.InnerText)); codeType.Members.Add(codeEnum); CodeExpression defaultValue = null; if(element.HasAttribute("default")) defaultValue = new CodeSnippetExpression( JoinNames(codeEnum.Name, element.GetAttribute("default"))); GenerateProperty(codeType, codeEnum.Name, name, out codeProperty, defaultValue); }
/// <summary> /// Creates a reference to a collection based member field and initializes it with a new instance of the /// specified parameter type and adds a collection item to it. /// Sample values are used as the initializing expression. /// </summary> /// <param name="memberCollectionField">Name of the referenced collection field.</param> /// <param name="collectionInitializers">Defines the types of the new object list.</param> /// <returns> /// An assignment statement for the specified collection member field. /// </returns> /// <remarks> /// With a custom Type, this method produces a statement with a initializer like: /// <code>this.paths = new[] { pathsItem };</code>. /// where the item is defined like: /// <code>this.pathsItem = new PathItemType();</code>. /// myType of type System.Type: /// <code>this.pathsItem = "An Item";</code>. /// </remarks> public static CodeAssignStatement CreateAndInitializeCollectionField( //Type type, string memberCollectionField, params string[] collectionInitializers) { /*if (type == typeof(object)) { }*/ var fieldRef1 = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberCollectionField); //CodeExpression assignExpr = CreateExpressionByType(type, memberCollectionField); var para = collectionInitializers.Aggregate((x, y) => x += "," + y); CodeExpression assignExpr = new CodeSnippetExpression("new[] { " + para + " }"); return new CodeAssignStatement(fieldRef1, assignExpr); }
public static void AddArgument(this CodeAttributeDeclaration attribute, string name, string value) { if (value == null) throw new ArgumentNullException("value"); CodeExpression expression; // Use convention that if string starts with $ its a const if (value.StartsWith(SnippetIndicator.ToString())) { expression = new CodeSnippetExpression(value.TrimStart(SnippetIndicator)); } else { expression = new CodePrimitiveExpression(value); } attribute.AddArgument(name, expression); }
public static CodeStatement[] CreateMappingStatements(ClassMappingDescriptor descriptor, CodeGeneratorContext context) { Dictionary<string, List<MemberMappingDescriptor>> aggregateGroups = new Dictionary<string, List<MemberMappingDescriptor>>(); List<CodeStatement> statements = new List<CodeStatement>(20); foreach (MemberMappingDescriptor member in descriptor.MemberDescriptors) { if (member.IsAggregateExpression) { // group all agregates by expression to avoid multiple traversals over same path //string path = GetPath(member.Expression); string path = GetPath(descriptor, member); if(!aggregateGroups.ContainsKey(path)) aggregateGroups[path] = new List<MemberMappingDescriptor>(1); aggregateGroups[path].Add(member); } else { CodeStatement[] st = CreateNonAggregateMappingStatements(descriptor, member, context); if(member.HasNullValue) { CodeStatement[] falseStatements = st; CodeStatement[] trueStatements = new CodeStatement[1]; trueStatements[0] = new CodeAssignStatement( new CodeVariableReferenceExpression("target." + member.Member), new CodeSnippetExpression(member.NullValue.ToString())); string checkExpression = GetNullablePartsCheckExpression(member); CodeExpression ifExpression = new CodeSnippetExpression(checkExpression); st = new CodeStatement[1]; st[0] = new CodeConditionStatement(ifExpression, trueStatements, falseStatements); } statements.AddRange(st); } } foreach (List<MemberMappingDescriptor> group in aggregateGroups.Values) { CodeStatement[] st = CreateAggregateMappingStatements(descriptor, group, context); statements.AddRange(st); } return statements.ToArray(); }
//Create main method private void CreateEntryPoint(List<string> statements) { //Create an object and assign the name as "Main" CodeEntryPointMethod mymain = new CodeEntryPointMethod(); mymain.Name = "Main"; //Mark the access modifier for the main method as Public and //static mymain.Attributes = MemberAttributes.Public | MemberAttributes.Static; //Change string to statements if(statements != null){ foreach (string item in statements) { if (item != null) { CodeSnippetExpression exp1 = new CodeSnippetExpression(@item); CodeExpressionStatement ces1 = new CodeExpressionStatement(exp1); mymain.Statements.Add(ces1); } } } myclass.Members.Add(mymain); }
/// <summary> /// if (string.IsNullOrEmpty(APIKey) == false) /// request = request.WithAPIKey(APIKey) /// </summary> /// <returns></returns> internal CodeConditionStatement CreateWithApiKey() { // !string.IsNullOrEmpty(Key) var condition = new CodeSnippetExpression("!string.IsNullOrEmpty(" + ApiKeyServiceDecorator.PropertyName + ")"); // if (...) { var block = new CodeConditionStatement(condition); // request = request.WithKey(APIKey) var getProperty = new CodePropertyReferenceExpression( new CodeThisReferenceExpression(), ApiKeyServiceDecorator.PropertyName); var request = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("request"), "WithKey", getProperty); var trueCase = new CodeAssignStatement(new CodeVariableReferenceExpression("request"), request); // } block.TrueStatements.Add(trueCase); return block; }
public void Constructor1 () { CodeSnippetExpression expression = new CodeSnippetExpression("exp"); CodeEventReferenceExpression cere = new CodeEventReferenceExpression ( expression, "mono"); Assert.AreEqual ("mono", cere.EventName, "#1"); Assert.IsNotNull (cere.TargetObject, "#2"); Assert.AreSame (expression, cere.TargetObject, "#3"); cere.EventName = null; Assert.IsNotNull (cere.EventName, "#4"); Assert.AreEqual (string.Empty, cere.EventName, "#5"); cere.TargetObject = null; Assert.IsNull (cere.TargetObject, "#6"); cere = new CodeEventReferenceExpression ((CodeExpression) null, (string) null); Assert.IsNotNull (cere.EventName, "#7"); Assert.AreEqual (string.Empty, cere.EventName, "#8"); Assert.IsNull (cere.TargetObject, "#9"); }
public void CreateEntryPoint(ref CodeTypeDeclaration customClass) { //Create an object and assign the name as “Main” CodeEntryPointMethod main = new CodeEntryPointMethod(); main.Name = "Main"; //Mark the access modifier for the main method as Public and //static main.Attributes = MemberAttributes.Public | MemberAttributes.Static; //Provide defenition to the main method. //Create an object of the “Cmyclass” and invoke the method //by passing the required parameters. CodeSnippetExpression exp = new CodeSnippetExpression(CallingMethod(customClass)); //Create expression statements for the snippets CodeExpressionStatement ces = new CodeExpressionStatement(exp); //Add the expression statements to the main method. main.Statements.Add(ces); //Add the main method to the class customClass.Members.Add(main); }
protected override void GenerateSnippetExpression(CodeSnippetExpression e) { base.Output.Write(e.Value); }
private void GenerateStrings(Property property, CodeMemberProperty propertyName) { this.GenerateCommon(property, propertyName, "String", typeof(string), "Value"); string referencedProperty = null; if (property.Values.Count > 0) { CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement("System.String[][]", "switchMap"); List<CodeExpression> list = new List<CodeExpression>(); int num = 0; CodeTypeReference createType = new CodeTypeReference(typeof(string)); foreach (Value value2 in property.Values) { if (this.ContainsCurrentPlatform(value2.SwitchName)) { CodeSnippetExpression[] initializers = new CodeSnippetExpression[2]; initializers[0] = new CodeSnippetExpression(this.SurroundWithQuotes(value2.Name)); if (value2.SwitchName != string.Empty) { initializers[1] = new CodeSnippetExpression(this.SurroundWithQuotes(value2.Prefix + value2.SwitchName)); } else { initializers[1] = new CodeSnippetExpression(this.SurroundWithQuotes("")); } CodeArrayCreateExpression item = new CodeArrayCreateExpression(createType, initializers); list.Add(item); num++; } } CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression("System.String[][]", list.ToArray()); statement.InitExpression = expression2; propertyName.SetStatements.Add(statement); CodeAssignStatement statement2 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "SwitchValue"), new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "ReadSwitchMap", new CodeExpression[] { new CodeSnippetExpression(this.SurroundWithQuotes(property.Name)), new CodeVariableReferenceExpression("switchMap"), new CodeVariableReferenceExpression("value") })); propertyName.SetStatements.Add(statement2); CodeAssignStatement statement3 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "Name"), new CodeSnippetExpression(this.SurroundWithQuotes(property.Name))); propertyName.SetStatements.Add(statement3); referencedProperty = "Value"; this.GenerateAssignPropertyToValue(propertyName, "AllowMultipleValues", new CodeSnippetExpression("true")); } else { CodeAssignStatement statement4 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "Name"), new CodeSnippetExpression(this.SurroundWithQuotes(property.Name))); propertyName.SetStatements.Add(statement4); referencedProperty = "Value"; CodeAssignStatement statement5 = new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("switchToAdd"), "SwitchValue"), (property.SwitchName != string.Empty) ? new CodeSnippetExpression(this.SurroundWithQuotes(property.Prefix + property.SwitchName)) : new CodeSnippetExpression(this.SurroundWithQuotes(""))); propertyName.SetStatements.Add(statement5); this.GenerateAssignToolSwitch(propertyName, "ReverseSwitchValue", property.Prefix, property.ReverseSwitchName); } this.GenerateCommonSetStatements(property, propertyName, referencedProperty); }
private void GenerateConstructor(CodeTypeDeclaration taskClass) { CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public }; CodeTypeReference createType = new CodeTypeReference("System.Resources.ResourceManager"); CodeSnippetExpression expression = new CodeSnippetExpression(this.SurroundWithQuotes(this.taskParser.ResourceNamespace)); CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression("System.Reflection.Assembly"); CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(targetObject, "GetExecutingAssembly"); CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(method, new CodeExpression[0]); CodeObjectCreateExpression expression5 = new CodeObjectCreateExpression(createType, new CodeExpression[] { expression, expression4 }); CodeTypeReference reference2 = new CodeTypeReference(new CodeTypeReference("System.String"), 1); List<CodeExpression> list = new List<CodeExpression>(); foreach (string str in this.taskParser.SwitchOrderList) { list.Add(new CodeSnippetExpression(this.SurroundWithQuotes(str))); } CodeArrayCreateExpression expression6 = new CodeArrayCreateExpression(reference2, list.ToArray()); constructor.BaseConstructorArgs.Add(expression6); constructor.BaseConstructorArgs.Add(expression5); taskClass.Members.Add(constructor); if (this.GenerateComments) { constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("StartSummary", new object[0]), true)); string text = Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ConstructorDescription", new object[0]); constructor.Comments.Add(new CodeCommentStatement(text, true)); constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("EndSummary", new object[0]), true)); } }
protected override void GenerateSnippetExpression (CodeSnippetExpression e) { }
protected override void GenerateSnippetExpression (CodeSnippetExpression expression) { Output.Write (expression.Value); }
protected abstract void GenerateSnippetExpression (CodeSnippetExpression e);
public void Visit (CodeSnippetExpression o) { g.GenerateSnippetExpression (o); }
private CodeStatement[] MakeWriteMethodBody(Type type) { List<CodeStatement> statements = new List<CodeStatement>(); CodeExpression objExpr = new CodeArgumentReferenceExpression("obj"); CodeExpression writerExpr = new CodeArgumentReferenceExpression("writer"); if (type.IsArray) { if (type.GetElementType() == typeof(object)) { throw new DryadLinqException(DryadLinqErrorCode.CannotHandleObjectFields, String.Format(SR.CannotHandleObjectFields, type.FullName)); } int rank = type.GetArrayRank(); for (int i = 0; i < rank; i++) { CodeExpression lenExpr = new CodeMethodInvokeExpression(objExpr, "GetLength", new CodePrimitiveExpression(i)); CodeExpression lenCall = new CodeMethodInvokeExpression(writerExpr, "Write", lenExpr); statements.Add(new CodeExpressionStatement(lenCall)); } // Generate the writing code if (type.GetElementType().IsPrimitive) { // Use a single WriteRawBytes for primitive array string lenStr = "sizeof(" + type.GetElementType() + ")"; for (int i = 0; i < rank; i++) { lenStr += "*obj.GetLength(" + i + ")"; } string writeBytes = " unsafe { fixed (void *p = obj) writer.WriteRawBytes((byte*)p, " + lenStr + "); }"; statements.Add(new CodeSnippetStatement(writeBytes)); } else { CodeVariableReferenceExpression[] indexExprs = new CodeVariableReferenceExpression[rank]; for (int i = 0; i < rank; i++) { indexExprs[i] = new CodeVariableReferenceExpression("i" + i); } bool canBeNull = StaticConfig.AllowNullArrayElements && !type.GetElementType().IsValueType; if (canBeNull) { string lenString = "obj.GetLength(0)"; for (int i = 1; i < rank; i++) { lenString += "*obj.GetLength(" + i + ")"; } CodeExpression lenExpr = new CodeSnippetExpression(lenString); CodeExpression bvExpr = new CodeObjectCreateExpression(typeof(BitVector), lenExpr); CodeStatement bvStmt = new CodeVariableDeclarationStatement("BitVector", "bv", bvExpr); statements.Add(bvStmt); } CodeStmtPair pair = this.MakeWriteFieldStatements(type.GetElementType(), objExpr, null, indexExprs); CodeStatement[] writeStmts = pair.Key; if (writeStmts != null) { for (int i = rank - 1; i >= 0; i--) { CodeVariableDeclarationStatement initStmt = new CodeVariableDeclarationStatement( typeof(int), indexExprs[i].VariableName, ZeroExpr); CodeExpression lenExpr = new CodeMethodInvokeExpression( objExpr, "GetLength", new CodePrimitiveExpression(i)); CodeExpression testExpr = new CodeBinaryOperatorExpression( indexExprs[i], CodeBinaryOperatorType.LessThan, lenExpr); CodeStatement incStmt = new CodeAssignStatement( indexExprs[i], new CodeBinaryOperatorExpression( indexExprs[i], CodeBinaryOperatorType.Add, OneExpr)); writeStmts = new CodeStatement[] { new CodeIterationStatement(initStmt, testExpr, incStmt, writeStmts) }; } statements.AddRange(writeStmts); } if (canBeNull) { CodeExpression bvWriteExpr = new CodeSnippetExpression("BitVector.Write(writer, bv)"); statements.Add(new CodeExpressionStatement(bvWriteExpr)); } writeStmts = pair.Value; for (int i = rank - 1; i >= 0; i--) { CodeVariableDeclarationStatement initStmt = new CodeVariableDeclarationStatement( typeof(int), indexExprs[i].VariableName, ZeroExpr); CodeExpression lenExpr = new CodeMethodInvokeExpression( objExpr, "GetLength", new CodePrimitiveExpression(i)); CodeExpression testExpr = new CodeBinaryOperatorExpression( indexExprs[i], CodeBinaryOperatorType.LessThan, lenExpr); CodeStatement incStmt = new CodeAssignStatement( indexExprs[i], new CodeBinaryOperatorExpression( indexExprs[i], CodeBinaryOperatorType.Add, OneExpr)); writeStmts = new CodeStatement[] { new CodeIterationStatement(initStmt, testExpr, incStmt, writeStmts) }; } statements.AddRange(writeStmts); } } else { FieldInfo[] fields = TypeSystem.GetAllFields(type); System.Array.Sort(fields, (x, y) => x.MetadataToken.CompareTo(y.MetadataToken)); bool canBeNull = fields.Any(x => !x.FieldType.IsValueType && AttributeSystem.FieldCanBeNull(x)); if (canBeNull) { CodeExpression lenExpr = new CodePrimitiveExpression(fields.Length); CodeExpression bvExpr = new CodeObjectCreateExpression(typeof(BitVector), lenExpr); CodeStatement bvStmt = new CodeVariableDeclarationStatement("BitVector", "bv", bvExpr); statements.Add(bvStmt); } // For each field of type, generate its serialization code CodeStatement[][] stmtArray = new CodeStatement[fields.Length][]; for (int i = 0; i < fields.Length; i++) { FieldInfo finfo = fields[i]; if (TypeSystem.IsFieldSerialized(finfo)) { if (finfo.FieldType == typeof(object)) { throw new DryadLinqException(DryadLinqErrorCode.CannotHandleObjectFields, String.Format(SR.CannotHandleObjectFields, type.FullName)); } CodeVariableReferenceExpression[] indexExprs = new CodeVariableReferenceExpression[] { new CodeVariableReferenceExpression(i.ToString()) }; CodeStmtPair pair = this.MakeWriteFieldStatements(finfo.FieldType, objExpr, finfo, indexExprs); stmtArray[i] = pair.Value; if (pair.Key != null) { statements.AddRange(pair.Key); } } } if (canBeNull) { CodeExpression bvWriteExpr = new CodeSnippetExpression("BitVector.Write(writer, bv)"); statements.Add(new CodeExpressionStatement(bvWriteExpr)); } for (int i = 0; i < stmtArray.Length; i++) { if (stmtArray[i] != null) { statements.AddRange(stmtArray[i]); } } } return statements.ToArray(); }
private CodeStatement[] MakeReadMethodBody(Type type) { List<CodeStatement> statements = new List<CodeStatement>(); CodeExpression objExpr = new CodeArgumentReferenceExpression("obj"); if (type.IsArray) { if (type.GetElementType() == typeof(object)) { throw new DryadLinqException(DryadLinqErrorCode.CannotHandleObjectFields, String.Format(SR.CannotHandleObjectFields, type.FullName)); } // Generate obj = new MyType[reader.ReadInt32()] int rank = type.GetArrayRank(); Type baseType = type.GetElementType(); while (baseType.IsArray) { baseType = baseType.GetElementType(); } string[] lenNames = new string[rank]; for (int i = 0; i < rank; i++) { lenNames[i] = MakeUniqueName("len"); CodeExpression lenExpr = new CodeSnippetExpression("reader.ReadInt32()"); var lenStmt = new CodeVariableDeclarationStatement(typeof(int), lenNames[i], lenExpr); statements.Add(lenStmt); } string newCallString = "new " + TypeSystem.TypeName(baseType, this.AnonymousTypeToName); newCallString += "["; for (int i = 0; i < rank; i++) { if (i != 0) { newCallString += ","; } newCallString += lenNames[i]; } newCallString += "]"; Type elemType = type.GetElementType(); while (elemType.IsArray) { int elemRank = elemType.GetArrayRank(); newCallString += "["; for (int i = 1; i < elemRank; i++) { newCallString += ','; } newCallString += "]"; elemType = elemType.GetElementType(); } CodeExpression newCall = new CodeSnippetExpression(newCallString); statements.Add(new CodeVariableDeclarationStatement(type, "obj", newCall)); // Generate reading code if (type.GetElementType().IsPrimitive) { // Use a single ReadRawBytes for primitive array string lenStr = "sizeof(" + type.GetElementType() + ")"; for (int i = 0; i < rank; i++) { lenStr += "*obj.GetLength(" + i + ")"; } string readBytes = " unsafe { fixed (void *p = obj) reader.ReadRawBytes((byte*)p, " + lenStr + "); }"; statements.Add(new CodeSnippetStatement(readBytes)); } else { if (StaticConfig.AllowNullArrayElements && !type.GetElementType().IsValueType) { CodeExpression bvReadExpr = new CodeSnippetExpression("BitVector.Read(reader)"); CodeStatement stmt = new CodeVariableDeclarationStatement(typeof(BitVector), "bv", bvReadExpr); statements.Add(stmt); } CodeVariableReferenceExpression[] indexExprs = new CodeVariableReferenceExpression[lenNames.Length]; for (int i = 0; i < lenNames.Length; i++) { indexExprs[i] = new CodeVariableReferenceExpression("i" + i); } CodeStatement[] readStmts = this.MakeReadFieldStatements(type.GetElementType(), objExpr, null, indexExprs); for (int i = lenNames.Length - 1; i >= 0; i--) { CodeVariableDeclarationStatement initStmt = new CodeVariableDeclarationStatement( typeof(int), indexExprs[i].VariableName, ZeroExpr); CodeExpression testExpr = new CodeBinaryOperatorExpression(indexExprs[i], CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(lenNames[i])); CodeStatement incStmt = new CodeAssignStatement( indexExprs[i], new CodeBinaryOperatorExpression(indexExprs[i], CodeBinaryOperatorType.Add, OneExpr)); readStmts = new CodeStatement[] { new CodeIterationStatement(initStmt, testExpr, incStmt, readStmts) }; } statements.AddRange(readStmts); } } else { CodeExpression newObjectCall; if (type.IsValueType) { // default(type) newObjectCall = new CodeObjectCreateExpression(type); } else { // FormatterServices.GetUninitializedObject(type) newObjectCall = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("FormatterServices"), "GetUninitializedObject", new CodeTypeOfExpression(type)); newObjectCall = new CodeCastExpression(type, newObjectCall); } statements.Add(new CodeVariableDeclarationStatement(type, "obj", newObjectCall)); // For each field of type, generate its deserialization code. FieldInfo[] fields = TypeSystem.GetAllFields(type); System.Array.Sort(fields, (x, y) => x.MetadataToken.CompareTo(y.MetadataToken)); bool canBeNull = fields.Any(x => !x.FieldType.IsValueType && AttributeSystem.FieldCanBeNull(x)); if (canBeNull) { CodeExpression bvReadExpr = new CodeSnippetExpression("BitVector.Read(reader)"); CodeStatement stmt = new CodeVariableDeclarationStatement(typeof(BitVector), "bv", bvReadExpr); statements.Add(stmt); } for (int i = 0; i < fields.Length; i++) { FieldInfo finfo = fields[i]; if (TypeSystem.IsFieldSerialized(finfo)) { if (finfo.FieldType == typeof(object)) { throw new DryadLinqException(DryadLinqErrorCode.CannotHandleObjectFields, String.Format(SR.CannotHandleObjectFields, type.FullName)); } CodeVariableReferenceExpression[] indexExprs = new CodeVariableReferenceExpression[] { new CodeVariableReferenceExpression(i.ToString()) }; CodeStatement[] stmts = this.MakeReadFieldStatements(finfo.FieldType, objExpr, finfo, indexExprs); statements.AddRange(stmts); } } } statements.Add(new CodeMethodReturnStatement(objExpr)); return statements.ToArray(); }
public void Constructor1_Deny_Unrestricted () { CodeSnippetExpression cse = new CodeSnippetExpression ("mono"); Assert.AreEqual ("mono", cse.Value, "Value"); cse.Value = String.Empty; }
private static void AddEntityOptionSetEnumDeclaration(CodeTypeDeclarationCollection types) { var enumClass = new CodeTypeDeclaration("EntityOptionSetEnum") { IsClass = true, TypeAttributes = TypeAttributes.Sealed | TypeAttributes.NotPublic, }; // public static int? GetEnum(Microsoft.Xrm.Sdk.Entity entity, string attributeLogicalName) var get = new CodeMemberMethod { Name = "GetEnum", ReturnType = new CodeTypeReference(typeof(int?)), // ReSharper disable once BitwiseOperatorOnEnumWithoutFlags Attributes = System.CodeDom.MemberAttributes.Static | System.CodeDom.MemberAttributes.Public, }; get.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Microsoft.Xrm.Sdk.Entity), "entity")); get.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "attributeLogicalName")); // entity.Attributes.ContainsKey(attributeLogicalName) var entityAttributesContainsKey = new CodeMethodReferenceExpression( new CodePropertyReferenceExpression( new CodeArgumentReferenceExpression("entity"), "Attributes"), "ContainsKey"); var invokeContainsKey = new CodeMethodInvokeExpression(entityAttributesContainsKey, new CodeArgumentReferenceExpression("attributeLogicalName")); // Microsoft.Xrm.Sdk.OptionSetValue value = entity.GetAttributeValue<Microsoft.Xrm.Sdk.OptionSetValue>(attributeLogicalName).Value; var declareAndSetValue = new CodeVariableDeclarationStatement { Type = new CodeTypeReference(typeof(OptionSetValue)), Name = "value", InitExpression = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeArgumentReferenceExpression("entity"), "GetAttributeValue", new CodeTypeReference(typeof(OptionSetValue))), new CodeArgumentReferenceExpression("attributeLogicalName")) }; // value != null var valueNeNull = new CodeSnippetExpression("value != null"); // value.Value var invokeValueGetValue = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("value"), "Value"); // if(invokeContainsKey){return invokeGetAttributeValue;}else{return null} get.Statements.Add(new CodeConditionStatement(invokeContainsKey, declareAndSetValue, new CodeConditionStatement(valueNeNull, new CodeMethodReturnStatement(invokeValueGetValue)))); // return null; get.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); enumClass.Members.Add(get); types.Add(enumClass); }
public override CodeExpression CreateMultidimensionalArray(string type, CodeExpression[] args) { var idxexp = new CodeSnippetExpression(string.Join(", ", args.Select(e => ExpressionToString(e)).ToArray())); return new CodeArrayCreateExpression(type, idxexp); }
protected override void GenerateSnippetExpression(System.CodeDom.CodeSnippetExpression e) { throw new Exception("The method or operation is not implemented."); }
CodeMethodInvokeExpression GetRegisterMethod(string method, string member, CodeTypeReference type) { var helper = new CodeTypeReferenceExpression("RecordHelper"); var name = new CodeSnippetExpression("\"" + member + "\""); var getter = new CodeSnippetExpression( string.Format("obj => obj.{0}", member) ); var setter = new CodeSnippetExpression( string.Format("(obj, val) => obj.{0} = val", member) ); var bl = new CodeMethodReferenceExpression(helper, method, new CodeTypeReference(this.Name.Substring(0, this.Name.Length - 1)), type); var g = new CodeMethodInvokeExpression(bl, name, getter, setter); return g; }
// Add a new vertex method to the DryadLinq vertex class internal CodeMemberMethod AddVertexMethod(DLinqQueryNode node) { CodeMemberMethod vertexMethod = new CodeMemberMethod(); vertexMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; vertexMethod.ReturnType = new CodeTypeReference(typeof(int)); vertexMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "args")); vertexMethod.Name = MakeUniqueName(node.NodeType.ToString()); CodeTryCatchFinallyStatement tryBlock = new CodeTryCatchFinallyStatement(); string startedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name + " started at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))"; vertexMethod.Statements.Add(new CodeSnippetExpression(startedMsg)); // We need to add a call to CopyResources() vertexMethod.Statements.Add(new CodeSnippetExpression("CopyResources()")); if (StaticConfig.LaunchDebugger) { // If static config requests it, we do an unconditional Debugger.Launch() at vertex entry. // Currently this isn't used because StaticConfig.LaunchDebugger is hardcoded to false System.Console.WriteLine("Launch debugger: may block application"); CodeExpression launchExpr = new CodeSnippetExpression("System.Diagnostics.Debugger.Launch()"); vertexMethod.Statements.Add(new CodeExpressionStatement(launchExpr)); } else { // Otherwise (the default behavior), we check an environment variable to decide whether // to launch the debugger, wait for a manual attach or simply skip straigt into vertex code. CodeMethodInvokeExpression debuggerCheckExpr = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(HelperClassName), DebugHelperMethodName)); vertexMethod.Statements.Add(new CodeExpressionStatement(debuggerCheckExpr)); } vertexMethod.Statements.Add(MakeVertexParamsDecl(node)); vertexMethod.Statements.Add(SetVertexParamField("VertexStageName", vertexMethod.Name)); vertexMethod.Statements.Add(SetVertexParamField("UseLargeBuffer", node.UseLargeWriteBuffer)); Int32[] portCountArray = node.InputPortCounts(); bool[] keepPortOrderArray = node.KeepInputPortOrders(); for (int i = 0; i < node.InputArity; i++) { CodeExpression setParamsExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(VertexParamName), "SetInputParams", new CodePrimitiveExpression(i), new CodePrimitiveExpression(portCountArray[i]), new CodePrimitiveExpression(keepPortOrderArray[i])); vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr)); } // YY: We could probably do better here. for (int i = 0; i < node.GetReferencedQueries().Count; i++) { CodeExpression setParamsExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(VertexParamName), "SetInputParams", new CodePrimitiveExpression(i + node.InputArity), new CodePrimitiveExpression(1), new CodePrimitiveExpression(false)); vertexMethod.Statements.Add(new CodeExpressionStatement(setParamsExpr)); } // Push the parallel-code settings into DryadLinqVertex bool multiThreading = this.m_context.EnableMultiThreadingInVertex; vertexMethod.Statements.Add(SetVertexParamField("MultiThreading", multiThreading)); vertexMethod.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression(DLVTypeExpr, "s_multiThreading"), new CodePrimitiveExpression(multiThreading))); vertexMethod.Statements.Add(MakeVertexEnvDecl(node)); Type[] outputTypes = node.OutputTypes; string[] writerNames = new string[outputTypes.Length]; for (int i = 0; i < outputTypes.Length; i++) { CodeVariableDeclarationStatement writerDecl = MakeVertexWriterDecl(outputTypes[i], this.GetStaticFactoryName(outputTypes[i])); vertexMethod.Statements.Add(writerDecl); writerNames[i] = writerDecl.Name; } // Add side readers: node.AddSideReaders(vertexMethod); // Generate code based on the node type: switch (node.NodeType) { case QueryNodeType.Where: case QueryNodeType.OrderBy: case QueryNodeType.Distinct: case QueryNodeType.Skip: case QueryNodeType.SkipWhile: case QueryNodeType.Take: case QueryNodeType.TakeWhile: case QueryNodeType.Merge: case QueryNodeType.Select: case QueryNodeType.SelectMany: case QueryNodeType.Zip: case QueryNodeType.GroupBy: case QueryNodeType.BasicAggregate: case QueryNodeType.Aggregate: case QueryNodeType.Contains: case QueryNodeType.Join: case QueryNodeType.GroupJoin: case QueryNodeType.Union: case QueryNodeType.Intersect: case QueryNodeType.Except: case QueryNodeType.RangePartition: case QueryNodeType.HashPartition: case QueryNodeType.Apply: case QueryNodeType.Fork: case QueryNodeType.Dynamic: { Type[] inputTypes = node.InputTypes; string[] sourceNames = new string[inputTypes.Length]; for (int i = 0; i < inputTypes.Length; i++) { CodeVariableDeclarationStatement readerDecl = MakeVertexReaderDecl(inputTypes[i], this.GetStaticFactoryName(inputTypes[i])); vertexMethod.Statements.Add(readerDecl); sourceNames[i] = readerDecl.Name; } string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, sourceNames, writerNames); if (sourceToSink != null) { CodeExpression sinkExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(writerNames[0]), "WriteItemSequence", new CodeVariableReferenceExpression(sourceToSink)); vertexMethod.Statements.Add(sinkExpr); } break; } case QueryNodeType.Super: { string sourceToSink = this.m_vertexCodeGen.AddVertexCode(node, vertexMethod, null, writerNames); if (sourceToSink != null) { CodeExpression sinkExpr = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(writerNames[0]), "WriteItemSequence", new CodeVariableReferenceExpression(sourceToSink)); vertexMethod.Statements.Add(sinkExpr); } break; } default: { //@@TODO: this should not be reachable. could change to Assert/InvalidOpEx throw new DryadLinqException(DryadLinqErrorCode.Internal, String.Format(SR.AddVertexNotHandled, node.NodeType)); } } string completedMsg = "DryadLinqLog.AddInfo(\"Vertex " + vertexMethod.Name + " completed at {0}\", DateTime.Now.ToString(\"MM/dd/yyyy HH:mm:ss.fff\"))"; vertexMethod.Statements.Add(new CodeSnippetExpression(completedMsg)); // add a catch block CodeCatchClause catchBlock = new CodeCatchClause("e"); CodeTypeReferenceExpression errorReportClass = new CodeTypeReferenceExpression("VertexEnv"); CodeMethodReferenceExpression errorReportMethod = new CodeMethodReferenceExpression(errorReportClass, "ReportVertexError"); CodeVariableReferenceExpression exRef = new CodeVariableReferenceExpression(catchBlock.LocalName); catchBlock.Statements.Add(new CodeMethodInvokeExpression(errorReportMethod, exRef)); tryBlock.CatchClauses.Add(catchBlock); // wrap the entire vertex method in a try/catch block tryBlock.TryStatements.AddRange(vertexMethod.Statements); vertexMethod.Statements.Clear(); vertexMethod.Statements.Add(tryBlock); // Always add "return 0", to make CLR hosting happy... vertexMethod.Statements.Add(new CodeMethodReturnStatement(ZeroExpr)); this.m_dryadVertexClass.Members.Add(vertexMethod); return vertexMethod; }
protected override void GenerateSnippetExpression(CodeSnippetExpression e) { Output.Write("[CodeSnippetExpression: {0}]", e.ToString()); }
// Copy user resources to the vertex working directory private void AddCopyResourcesMethod() { CodeMemberMethod copyResourcesMethod = new CodeMemberMethod(); copyResourcesMethod.Name = CopyResourcesMethodName; copyResourcesMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static; IEnumerable<string> resourcesToExclude = this.m_context.ResourcesToRemove; foreach (string res in this.m_context.ResourcesToAdd) { if (!resourcesToExclude.Contains(res)) { string fname = Path.GetFileName(res); string stmt = @"System.IO.File.Copy(@""" + Path.Combine("..", fname) + "\", @\"" + fname + "\")"; CodeExpression stmtExpr = new CodeSnippetExpression(stmt); copyResourcesMethod.Statements.Add(new CodeExpressionStatement(stmtExpr)); } } this.m_dryadVertexClass.Members.Add(copyResourcesMethod); }
/// <summary> /// Creates a class declaration /// </summary> /// <param name="schema">record schema</param> /// <param name="ns">namespace</param> /// <returns></returns> protected virtual CodeTypeDeclaration processRecord(Schema schema) { RecordSchema recordSchema = schema as RecordSchema; if (null == recordSchema) throw new CodeGenException("Unable to cast schema into a record"); // declare the class var ctd = new CodeTypeDeclaration(CodeGenUtil.Instance.Mangle(recordSchema.Name)); ctd.BaseTypes.Add("ISpecificRecord"); ctd.Attributes = MemberAttributes.Public; ctd.IsClass = true; ctd.IsPartial = true; createSchemaField(schema, ctd, false); // declare Get() to be used by the Writer classes var cmmGet = new CodeMemberMethod(); cmmGet.Name = "Get"; cmmGet.Attributes = MemberAttributes.Public; cmmGet.ReturnType = new CodeTypeReference("System.Object"); cmmGet.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "fieldPos")); StringBuilder getFieldStmt = new StringBuilder("switch (fieldPos)\n\t\t\t{\n"); // declare Put() to be used by the Reader classes var cmmPut = new CodeMemberMethod(); cmmPut.Name = "Put"; cmmPut.Attributes = MemberAttributes.Public; cmmPut.ReturnType = new CodeTypeReference(typeof(void)); cmmPut.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "fieldPos")); cmmPut.Parameters.Add(new CodeParameterDeclarationExpression("System.Object", "fieldValue")); var putFieldStmt = new StringBuilder("switch (fieldPos)\n\t\t\t{\n"); foreach (Field field in recordSchema.Fields) { // Determine type of field bool nullibleEnum = false; string baseType = getType(field.Schema, false, ref nullibleEnum); var ctrfield = new CodeTypeReference(baseType); // Create field string privFieldName = string.Concat("_", field.Name); var codeField = new CodeMemberField(ctrfield, privFieldName); codeField.Attributes = MemberAttributes.Private; // Process field documentation if it exist and add to the field CodeCommentStatement propertyComment = null; if (!string.IsNullOrEmpty(field.Documentation)) { propertyComment = createDocComment(field.Documentation); if (null != propertyComment) codeField.Comments.Add(propertyComment); } // Add field to class ctd.Members.Add(codeField); // Create reference to the field - this.fieldname var fieldRef = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), privFieldName); var mangledName = CodeGenUtil.Instance.Mangle(field.Name); // Create field property with get and set methods var property = new CodeMemberProperty(); property.Attributes = MemberAttributes.Public | MemberAttributes.Final; property.Name = mangledName; property.Type = ctrfield; property.GetStatements.Add(new CodeMethodReturnStatement(fieldRef)); property.SetStatements.Add(new CodeAssignStatement(fieldRef, new CodePropertySetValueReferenceExpression())); if (null != propertyComment) property.Comments.Add(propertyComment); // Add field property to class ctd.Members.Add(property); // add to Get() getFieldStmt.Append("\t\t\tcase "); getFieldStmt.Append(field.Pos); getFieldStmt.Append(": return this."); getFieldStmt.Append(mangledName); getFieldStmt.Append(";\n"); // add to Put() putFieldStmt.Append("\t\t\tcase "); putFieldStmt.Append(field.Pos); putFieldStmt.Append(": this."); putFieldStmt.Append(mangledName); if (nullibleEnum) { putFieldStmt.Append(" = fieldValue == null ? ("); putFieldStmt.Append(baseType); putFieldStmt.Append(")null : ("); string type = baseType.Remove(0, 16); // remove System.Nullable< type = type.Remove(type.Length - 1); // remove > putFieldStmt.Append(type); putFieldStmt.Append(")fieldValue; break;\n"); } else { putFieldStmt.Append(" = ("); putFieldStmt.Append(baseType); putFieldStmt.Append(")fieldValue; break;\n"); } } // end switch block for Get() getFieldStmt.Append("\t\t\tdefault: throw new AvroRuntimeException(\"Bad index \" + fieldPos + \" in Get()\");\n\t\t\t}"); var cseGet = new CodeSnippetExpression(getFieldStmt.ToString()); cmmGet.Statements.Add(cseGet); ctd.Members.Add(cmmGet); // end switch block for Put() putFieldStmt.Append("\t\t\tdefault: throw new AvroRuntimeException(\"Bad index \" + fieldPos + \" in Put()\");\n\t\t\t}"); var csePut = new CodeSnippetExpression(putFieldStmt.ToString()); cmmPut.Statements.Add(csePut); ctd.Members.Add(cmmPut); string nspace = recordSchema.Namespace; if (string.IsNullOrEmpty(nspace)) throw new CodeGenException("Namespace required for record schema " + recordSchema.Name); CodeNamespace codens = addNamespace(nspace); codens.Types.Add(ctd); return ctd; }
// Add an anonymous class internal bool AddAnonymousClass(Type type) { if (!TypeSystem.IsAnonymousType(type)) return false; if (this.m_anonymousTypeToName.ContainsKey(type)) return true; string className = AnonymousClassName(type); this.m_anonymousTypeToName.Add(type, className); CodeTypeDeclaration anonymousClass = new CodeTypeDeclaration(className); anonymousClass.IsClass = true; anonymousClass.TypeAttributes = TypeAttributes.Public; // Add the fields, the constructor, and properties: CodeConstructor con = new CodeConstructor(); con.Attributes = MemberAttributes.Public | MemberAttributes.Final; PropertyInfo[] props = type.GetProperties(); System.Array.Sort(props, (x, y) => x.MetadataToken.CompareTo(y.MetadataToken)); string[] fieldNames = new string[props.Length]; for (int i = 0; i < props.Length; i++) { fieldNames[i] = "_" + props[i].Name; CodeParameterDeclarationExpression paramExpr; CodeMemberField memberField; if (this.AddAnonymousClass(props[i].PropertyType)) { string typeName = this.AnonymousTypeToName[props[i].PropertyType]; memberField = new CodeMemberField(typeName, fieldNames[i]); paramExpr = new CodeParameterDeclarationExpression(typeName, props[i].Name); } else { memberField = new CodeMemberField(props[i].PropertyType, fieldNames[i]); paramExpr = new CodeParameterDeclarationExpression(props[i].PropertyType, props[i].Name); } memberField.Attributes = MemberAttributes.Public; anonymousClass.Members.Add(memberField); con.Parameters.Add(paramExpr); CodeExpression fieldExpr = new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), fieldNames[i]); con.Statements.Add(new CodeAssignStatement( fieldExpr, new CodeVariableReferenceExpression(paramExpr.Name))); CodeMemberProperty p = new CodeMemberProperty(); p.Attributes = MemberAttributes.Public | MemberAttributes.Final; p.Name = props[i].Name; p.Type = paramExpr.Type; p.GetStatements.Add(new CodeMethodReturnStatement(fieldExpr)); anonymousClass.Members.Add(p); } anonymousClass.Members.Add(con); // Add Equals method: CodeMemberMethod equalsMethod = new CodeMemberMethod(); equalsMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; equalsMethod.Name = "Equals"; equalsMethod.Parameters.Add(new CodeParameterDeclarationExpression("Object", "obj")); equalsMethod.ReturnType = new CodeTypeReference(typeof(bool)); CodeExpression initExpr = new CodeSnippetExpression("obj as " + className); equalsMethod.Statements.Add( new CodeVariableDeclarationStatement(className, "myObj", initExpr)); CodeStatement ifStmt = new CodeConditionStatement( new CodeSnippetExpression("myObj == null"), new CodeMethodReturnStatement(new CodePrimitiveExpression(false))); equalsMethod.Statements.Add(ifStmt); string equalsCode = ""; for (int i = 0; i < props.Length; i++) { string fieldTypeName; // we must use the proxy-type for anonymous-types. if (m_anonymousTypeToName.ContainsKey(props[i].PropertyType)) { fieldTypeName = m_anonymousTypeToName[props[i].PropertyType]; } else { fieldTypeName = TypeSystem.TypeName(props[i].PropertyType); } if (i > 0) equalsCode += " && "; equalsCode += String.Format("EqualityComparer<{0}>.Default.Equals(this.{1}, myObj.{1})", fieldTypeName, props[i].Name); } CodeExpression returnExpr = new CodeSnippetExpression(equalsCode); equalsMethod.Statements.Add(new CodeMethodReturnStatement(returnExpr)); anonymousClass.Members.Add(equalsMethod); // Add GetHashCode method: CodeMemberMethod getHashCodeMethod = new CodeMemberMethod(); getHashCodeMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; getHashCodeMethod.Name = "GetHashCode"; getHashCodeMethod.ReturnType = new CodeTypeReference(typeof(int)); CodeVariableDeclarationStatement hashDecl = new CodeVariableDeclarationStatement(typeof(int), "num", ZeroExpr); getHashCodeMethod.Statements.Add(hashDecl); CodeExpression numExpr = new CodeArgumentReferenceExpression(hashDecl.Name); for (int i = 0; i < props.Length; i++) { if (props[i].PropertyType.IsValueType) { CodeExpression hashExpr = new CodeSnippetExpression( "(-1521134295 * num) + this." + props[i].Name + ".GetHashCode()"); getHashCodeMethod.Statements.Add(new CodeAssignStatement(numExpr, hashExpr)); } else { CodeExpression hashExpr = new CodeSnippetExpression( String.Format("(-1521134295 * num) + (this.{0} != null ? this.{0}.GetHashCode() : 0)", props[i].Name)); getHashCodeMethod.Statements.Add(new CodeAssignStatement(numExpr, hashExpr)); } } getHashCodeMethod.Statements.Add(new CodeMethodReturnStatement(numExpr)); anonymousClass.Members.Add(getHashCodeMethod); // Add ToString method: CodeMemberMethod toStringMethod = new CodeMemberMethod(); toStringMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; toStringMethod.Name = "ToString"; toStringMethod.ReturnType = new CodeTypeReference(typeof(string)); StringBuilder toStringCode = new StringBuilder(); toStringCode.Append("\"{ \""); for (int i = 0; i < props.Length; i++) { if (i > 0) toStringCode.Append(" + \", \""); toStringCode.Append(" + \""); toStringCode.Append(props[i].Name); toStringCode.Append(" = \" + this."); toStringCode.Append(props[i].Name); toStringCode.Append(".ToString()"); } toStringCode.Append(" + \" }\""); returnExpr = new CodeSnippetExpression(toStringCode.ToString()); toStringMethod.Statements.Add(new CodeMethodReturnStatement(returnExpr)); anonymousClass.Members.Add(toStringMethod); this.m_dryadCodeSpace.Types.Add(anonymousClass); return true; }