Type EmitPrimitive(CodePrimitiveExpression Primitive)
{
Type T;
if(Primitive.Value == null) T = null;
else T = Primitive.Value.GetType();
if(T != null && T.IsArray)
{
var Contents = Primitive.Value as object[];
Type Element = T.GetElementType();
Generator.Emit(OpCodes.Ldc_I4, Contents.Length);
Generator.Emit(OpCodes.Newarr, Element);
int i = 0;
foreach(var Value in Contents)
{
Generator.Emit(OpCodes.Dup);
Generator.Emit(OpCodes.Ldc_I4, i);
EmitLiteral(Element, Value);
Generator.Emit(OpCodes.Stelem_Ref);
i++;
}
return T;
}
else return EmitLiteral(T, Primitive.Value);
}
public void Constructor1_Deny_Unrestricted ()
{
object o = new object ();
CodePrimitiveExpression cpe = new CodePrimitiveExpression (o);
Assert.AreSame (o, cpe.Value, "Value");
cpe.Value = new object ();
}
private static CodeExpressionStatement getInvokeDetailStatement(RecordStep step, string dataClass)
{
CodeExpressionStatement statement = new CodeExpressionStatement();
CodeExpression[] paras;
if (step.ActionParams != null)
{
paras = new CodeExpression[step.ActionParams.Count];
///判断是否参数化函数代码
if(dataClass == null)
{
for (int i = 0; i < step.ActionParams.Count; i++)
{
paras[i] = new CodePrimitiveExpression(step.ActionParams[i].Value);
}
}
else
{
for (int i = 0; i < step.ActionParams.Count; i++)
{
paras[i] = step.ActionParams[i].GetVariableReference(dataClass);
}
}
}
else
{
paras = new CodeExpression[0];
}
CodeMethodInvokeExpression method = new CodeMethodInvokeExpression(step.CompInfo.FindMethod, step.ActionName, paras);
statement.Expression = method;
return statement;
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
if (!entry.Expression.Contains(","))
{
throw new ArgumentException("Must include two numbers separated by a comma.");
}
else
{
// get two numbers
string[] numbers = entry.Expression.Split(',');
if (numbers.Length != 2)
{
throw new ArgumentException("Only include two numbers");
}
else
{
int lowerLimit, upperLimit;
if (Int32.TryParse(numbers[0], out lowerLimit) && Int32.TryParse(numbers[1], out upperLimit))
{
CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());
CodeExpression[] methodParameters = new CodeExpression[2];
methodParameters[0] = new CodePrimitiveExpression(lowerLimit);
methodParameters[1] = new CodePrimitiveExpression(upperLimit);
return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters);
}
else
{
throw new ArgumentException("Use valid Integers");
}
}
}
}
protected CodeExpression ConvertTo(string value, Type type)
{
var valueExpression = new CodePrimitiveExpression(value);
var converter = TypeDescriptor.GetConverter(type);
if (type == typeof(string) || type == typeof(object))
return valueExpression;
if (type == typeof(double))
return new CodePrimitiveExpression(double.Parse(value, CultureInfo.InvariantCulture));
if (type == typeof(BindingBase))
{
var bindingParser = new BindingParser(State);
var bindingVariableName = bindingParser.Parse(value);
return new CodeVariableReferenceExpression(bindingVariableName);
}
// there is no conversion availabe, the generated code won't compile, but there is nothing we can do about that
if (converter == null)
return valueExpression;
var conversion = new CodeCastExpression(
type.Name,
new CodeMethodInvokeExpression(
new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("TypeDescriptor"), "GetConverter",
new CodeTypeOfExpression(type.Name)), "ConvertFromInvariantString",
new CodePrimitiveExpression(value)));
return conversion;
}
public void SetRow(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, IEnumerable<string> arguments, IEnumerable<string> tags, bool isIgnored)
{
var args = arguments.Select(
arg => new CodeAttributeArgument(new CodePrimitiveExpression(arg))).ToList();
// addressing ReSharper bug: TestCase attribute with empty string[] param causes inconclusive result - https://github.com/techtalk/SpecFlow/issues/116
bool hasExampleTags = tags.Any();
var exampleTagExpressionList = tags.Select(t => new CodePrimitiveExpression(t));
CodeExpression exampleTagsExpression = hasExampleTags ?
(CodeExpression)new CodePrimitiveExpression(null) :
new CodeArrayCreateExpression(typeof(string[]), exampleTagExpressionList.ToArray());
args.Add(new CodeAttributeArgument(exampleTagsExpression));
// adds 'Category' named parameter so that NUnit also understands that this test case belongs to the given categories
if (hasExampleTags)
{
CodeExpression exampleTagsStringExpr = new CodePrimitiveExpression(string.Join(",", tags.ToArray()));
args.Add(new CodeAttributeArgument("Category", exampleTagsStringExpr));
}
if (isIgnored)
args.Add(new CodeAttributeArgument("Ignored", new CodePrimitiveExpression(true)));
CodeDomHelper.AddAttribute(testMethod, ROW_ATTR, args.ToArray());
}
protected override void CreateConstructor (CodeStatementCollection localVars,
CodeStatementCollection trueStmt)
{
if (pageParser.ClientTarget != null) {
CodeExpression prop;
prop = new CodePropertyReferenceExpression (thisRef, "ClientTarget");
CodeExpression ct = new CodePrimitiveExpression (pageParser.ClientTarget);
if (localVars == null)
localVars = new CodeStatementCollection ();
localVars.Add (new CodeAssignStatement (prop, ct));
}
#if NET_2_0
if (pageParser.MasterPageFile != null) {
CodeExpression prop;
prop = new CodePropertyReferenceExpression (thisRef, "MasterPageFile");
CodeExpression ct = new CodePrimitiveExpression (pageParser.MasterPageFile);
if (localVars == null)
localVars = new CodeStatementCollection ();
localVars.Add (new CodeAssignStatement (prop, ct));
}
#endif
base.CreateConstructor (localVars, trueStmt);
}
private static string AppendCreateDictionaryLocalVariable(string dictionary, CodeDomClassBuilder builder)
{
var parser = new AttributeParser(dictionary);
parser.Parse();
var keyValuePairType = new CodeTypeReference(typeof(KeyValuePair<string,object>));
var createDictionaryMethod = new CodeMethodInvokeExpression();
foreach (var attribute in parser.Attributes)
{
var newKeyValueExpression = new CodeObjectCreateExpression {CreateType = keyValuePairType};
var keyExpression = new CodePrimitiveExpression {Value = attribute.Name};
newKeyValueExpression.Parameters.Add(keyExpression);
if (attribute.Type == ParsedAttributeType.String)
{
AppendStringDictValue(attribute, newKeyValueExpression);
}
else
{
newKeyValueExpression.Parameters.Add(new CodeSnippetExpression
{
Value = attribute.Value
});
}
createDictionaryMethod.Parameters.Add(newKeyValueExpression);
}
var getDictionaryMethod = new CodeMethodReferenceExpression
{
MethodName = "GetDictionaryFromKeyValue",
TargetObject =
new CodeVariableReferenceExpression
{
VariableName = "NHamlMonoRailView"
}
};
createDictionaryMethod.Method = getDictionaryMethod;
var variableName = string.Format("nhamlTempDictionary{0}", tempDictionaryCount);
tempDictionaryCount++;
var dictionaryDecleration = new CodeVariableDeclarationStatement
{
InitExpression = createDictionaryMethod,
Name = variableName,
Type = new CodeTypeReference(typeof (IDictionary<string, object>))
};
builder.RenderMethod.Statements.Add(dictionaryDecleration);
return variableName;
}
public TypescriptPrimitiveExpression(
CodePrimitiveExpression codeExpression,
CodeGeneratorOptions options)
{
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptPrimitiveExpression Created");
}
public static CodeAttributeArgument GetStringArrayAttributeArgument(string[] values)
{
CodeExpression[] initializers = new CodeExpression[values.Length];
for (int i = 0; i < values.Length; i++)
initializers[i] = new CodePrimitiveExpression(values[i]);
return new CodeAttributeArgument(new CodeArrayCreateExpression(typeof(string), initializers));
}
private static CodeExpression CreateDataArray(byte[] data)
{
CodeExpression[] initializers = new CodeExpression[data.Length];
for (int i = 0; i < data.Length; i++)
{
initializers[i] = new CodePrimitiveExpression(data[i]);
}
return new CodeArrayCreateExpression(typeof(byte), initializers);
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
string property = (string) parsedData;
CodePrimitiveExpression prim = new CodePrimitiveExpression(property);
CodeExpression[] args = new[] {prim};
CodeTypeReferenceExpression refType = new CodeTypeReferenceExpression(this.GetType());
return new CodeMethodInvokeExpression(refType, "GetProperty", args);
}
private static void AddXmlEnumAttribute(CodeTypeMember member)
{
CodeTypeReference attributeType = new CodeTypeReference(typeof (XmlEnumAttribute));
CodePrimitiveExpression argumentValue = new CodePrimitiveExpression(member.Name);
CodeAttributeArgument argument = new CodeAttributeArgument(argumentValue);
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(attributeType, argument);
member.CustomAttributes.Add(attribute);
}
private static void AddRootElementName(CodeTypeMember type)
{
foreach (CodeAttributeDeclaration attribute in type.CustomAttributes)
if (attribute.Name == typeof (XmlRootAttribute).FullName)
{
CodePrimitiveExpression value = new CodePrimitiveExpression(type.Name);
CodeAttributeArgument argument = new CodeAttributeArgument("", value);
attribute.Arguments.Insert(0, argument);
}
}
/// <summary>
/// When overridden in a derived class, returns code that is used during page execution to obtain the evaluated expression.
/// </summary>
/// <param name="entry">The object that represents information about the property bound to by the expression.</param>
/// <param name="parsedData">The object containing parsed data as returned by <see cref="M:System.Web.Compilation.ExpressionBuilder.ParseExpression(System.String,System.Type,System.Web.Compilation.ExpressionBuilderContext)" />.</param>
/// <param name="context">Contextual information for the evaluation of the expression.</param>
/// <returns>
/// A <see cref="T:System.CodeDom.CodeExpression" /> that is used for property assignment.
/// </returns>
public override CodeExpression GetCodeExpression( BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context )
{
// from http://msdn.microsoft.com/en-us/library/system.web.compilation.expressionbuilder.getcodeexpression.aspx
Type type1 = entry.DeclaringType;
PropertyDescriptor descriptor1 = TypeDescriptor.GetProperties( type1 )[entry.PropertyInfo.Name];
CodeExpression[] expressionArray1 = new CodeExpression[3];
expressionArray1[0] = new CodePrimitiveExpression( entry.Expression.Trim() );
expressionArray1[1] = new CodeTypeOfExpression( type1 );
expressionArray1[2] = new CodePrimitiveExpression( entry.Name );
return new CodeCastExpression( descriptor1.PropertyType, new CodeMethodInvokeExpression( new CodeTypeReferenceExpression( base.GetType() ), "GetEvalData", expressionArray1 ) );
}
/// <summary>Creates a code expression that creates a byte array of data.</summary>
/// <param name="data">The data to translate.</param>
/// <returns>The code expression representing the array.</returns>
private static CodeExpression CreateDataArray(byte [] data)
{
// Create an array of code expressions, each one a byte primitive
CodeExpression [] initializers = new CodeExpression[data.Length];
for(int i=0; i<data.Length; i++)
{
initializers[i] = new CodePrimitiveExpression(data[i]);
}
// Create the array of bytes used the created initialization list
return new CodeArrayCreateExpression(typeof(byte), initializers);
}
public override CodeExpression GetCodeExpression(System.Web.UI.BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
_log.Write(_id, SPTraceLogger.TraceSeverity.InformationEvent, "GetCodeExpression", "Info", "Called");
CodeTypeReferenceExpression thisType = new CodeTypeReferenceExpression(base.GetType());
CodePrimitiveExpression expression = new CodePrimitiveExpression(entry.Expression.Trim().ToString());
string evaluationMethod = "GetKeyValue";
return new CodeMethodInvokeExpression(thisType, evaluationMethod, new CodeExpression[] { expression });
}
internal static void GenerateConstructorStatements(CodeConstructor ctor, string url, string appSettingUrlKey, string appSettingBaseUrl, bool soap11)
{
bool flag = (url != null) && (url.Length > 0);
bool flag2 = (appSettingUrlKey != null) && (appSettingUrlKey.Length > 0);
CodeAssignStatement statement = null;
if (flag || flag2)
{
CodeExpression expression;
CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Url");
if (flag)
{
expression = new CodePrimitiveExpression(url);
statement = new CodeAssignStatement(left, expression);
}
if (flag && !flag2)
{
ctor.Statements.Add(statement);
}
else if (flag2)
{
CodeVariableReferenceExpression expression3 = new CodeVariableReferenceExpression("urlSetting");
CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(ConfigurationManager));
CodePropertyReferenceExpression expression5 = new CodePropertyReferenceExpression(targetObject, "AppSettings");
expression = new CodeIndexerExpression(expression5, new CodeExpression[] { new CodePrimitiveExpression(appSettingUrlKey) });
ctor.Statements.Add(new CodeVariableDeclarationStatement(typeof(string), "urlSetting", expression));
if ((appSettingBaseUrl == null) || (appSettingBaseUrl.Length == 0))
{
expression = expression3;
}
else
{
if ((url == null) || (url.Length == 0))
{
throw new ArgumentException(Res.GetString("IfAppSettingBaseUrlArgumentIsSpecifiedThen0"));
}
string str = new Uri(appSettingBaseUrl).MakeRelative(new Uri(url));
CodeExpression[] parameters = new CodeExpression[] { expression3, new CodePrimitiveExpression(str) };
expression = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)), "Concat", parameters);
}
CodeStatement[] trueStatements = new CodeStatement[] { new CodeAssignStatement(left, expression) };
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(expression3, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
if (flag)
{
ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[] { statement }));
}
else
{
ctor.Statements.Add(new CodeConditionStatement(condition, trueStatements));
}
}
}
}
public override CodeExpression GetCodeExpression(BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
{
var expression = new CodeExpression[3];
expression[0] = new CodePrimitiveExpression(entry.Expression.Trim());
expression[1] = new CodeTypeOfExpression(typeof(string));
expression[2] = new CodePrimitiveExpression(entry.Name);
return new CodeCastExpression(typeof(string),
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(GetType()), "GetEvalData",
expression));
}
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator,
CodeTypeMemberCollection members)
{
string type = (string)table["$key"];
string className = "TYPE_" + Guid.NewGuid().ToString("N");
CodeTypeDeclaration classCode = new CodeTypeDeclaration(className);
classCode.Comments.Add(new CodeCommentStatement("Descriptor of " + type));
classCode.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Descriptor of " + type));
classCode.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty));
classCode.TypeAttributes = System.Reflection.TypeAttributes.NestedPrivate | System.Reflection.TypeAttributes.Sealed;
classCode.BaseTypes.Add(typeof(HardwiredUserDataDescriptor));
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Assembly;
ctor.BaseConstructorArgs.Add(new CodeTypeOfExpression(type));
classCode.Members.Add(ctor);
generator.DispatchTablePairs(table.Get("members").Table,
classCode.Members, (key, exp) =>
{
var mname = new CodePrimitiveExpression(key);
ctor.Statements.Add(new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "AddMember", mname, exp));
});
generator.DispatchTablePairs(table.Get("metamembers").Table,
classCode.Members, (key, exp) =>
{
var mname = new CodePrimitiveExpression(key);
ctor.Statements.Add(new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "AddMetaMember", mname, exp));
});
members.Add(classCode);
return new CodeExpression[] {
new CodeObjectCreateExpression(className)
};
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression = new CodePrimitiveExpression(value);
if (value == null
|| value is bool
|| value is char
|| value is int
|| value is float
|| value is double)
{
// work aroundf for J#, since they don't support auto-boxing of value types yet.
CodeDomProvider codeProvider = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if (codeProvider != null && String.Equals(codeProvider.FileExtension, JSharpFileExtension))
{
// See if we are boxing - if so, insert a cast.
ExpressionContext cxt = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
//Debug.Assert(cxt != null, "No expression context on stack - J# boxing cast will not be inserted");
if (cxt != null)
{
if (cxt.ExpressionType == typeof(object))
{
expression = new CodeCastExpression(value.GetType(), expression);
expression.UserData.Add("CastIsBoxing", true);
}
}
}
return expression;
}
String stringValue = value as string;
if (stringValue != null)
{
// WinWS: The commented code breaks us when we have long strings
//if (stringValue.Length > 200)
//{
// return SerializeToResourceExpression(manager, stringValue);
//}
//else
return expression;
}
// generate a cast for non-int types because we won't parse them properly otherwise because we won't know to convert
// them to the narrow form.
//
return new CodeCastExpression(new CodeTypeReference(value.GetType()), expression);
}
internal static CodeMemberProperty GenerateStringConstantPropertyOverride(string propertyName,
string returnValue)
{
var property = new CodeMemberProperty();
property.Name = propertyName;
property.Type = new CodeTypeReference(typeof(string));
property.Attributes = MemberAttributes.Family | MemberAttributes.Override; // "protected".
property.HasGet = true;
// get { return "..."; }
var returnString = new CodePrimitiveExpression(returnValue);
property.GetStatements.Add(new CodeMethodReturnStatement(returnString));
return property;
}
/// <summary>Initializes the extension</summary>
/// <param name="parameters">Initialization parameters: This class expects following parameters:
/// <list type="table"><listheader><term>Parameter</term><description>Description</description></listheader>
/// <item><term><c>PropertyName</c></term><description>Name of property to add attribute to. Required.</description></item>
/// <item><term><c>TypeName</c></term><description>Name of type property <c>PropertyName</c> is property of. Required.</description></item>
/// <item><term><c>Name</c></term><description>Name of the attribute</description></item>
/// <item><term><c>p-<number></c></term><description>Positional attribute constructor parameter. Optional. See remarks.</description></item>
/// <item><term><c>p-<string></c></term><description>Named attribute parameter. Optional. See remarks.</description></item>
/// </list></param>
/// <remarks>
/// Positional and named parameters of constructor have name in form p-<number or name> and value in form "<TypeName> <value>".
/// TypeName can be one of supported attribute parameter types (<see cref="String"/>, <see cref="Byte"/>, <see cref="SByte"/>, <see cref="Int16"/>, <see cref="UInt16"/>, <see cref="Int32"/>, <see cref="UInt32"/>, <see cref="Int64"/>, <see cref="UInt64"/>, <see cref="Decimnal"/>, <see cref="Single"/>, <see cref="Double"/>, <see cref="Boolean"/>, <see cref="DateTime"/>, <see cref="Char"/>, <see cref="Type"/>).
/// If it is not one of them it's treated a name of enumeration type. For supported types value is parsed in invariant culture to that type using appropriate <c>Parse</c> method.
/// With exception of <see cref="String"/> which is used directly and <see cref="Type"/> where value part is treated as type name.
/// For enumerations value part is treated as name of enumeration memner of enumeration specified in type part.
/// <para>
/// Positional parameters are added as constuctor parameters in order of their position numbers. Missing position numbers are ignored. Skipped optional parameters are not supported.
/// Named parameters are added at the end of parameters list as named parameters.
/// </para></remarks>
/// <exception cref="KeyNotFoundException">A required parameter is not present in the <paramref name="parameters"/> dictionary.</exception>
/// <exception cref="FormatException">Value of numeric type cannot be parsed.</exception>
/// <exception cref="OverflowException">Value of numeric type is out of range of given numberic type.</exception>
public void Initialize(System.Collections.Generic.IDictionary<string, string> parameters)
{
propertyName = parameters["PropertyName"];
typeName = parameters["TypeName"];
attributeName = parameters["Name"];
//Params in arguments name p-Name or p-Number
//Content typename-space-value (typename cannot contain space)
List<CodeAttributeArgument> namedParams = new List<CodeAttributeArgument>();
Dictionary<int, CodeAttributeArgument> posParams = new Dictionary<int, CodeAttributeArgument>();
foreach (var item in parameters) {
if (item.Key.StartsWith("p-")) {
string pName = item.Key.Substring(2);
CodeExpression pValue;
int pnum;
string TypeName = item.Value.Substring(0, item.Value.IndexOf(' '));
string valuePart = item.Value.Substring(item.Value.IndexOf(' ') + 1);
switch (TypeName) {
case "System.String": pValue = new CodePrimitiveExpression(valuePart); break;
case "System.Byte": pValue = new CodePrimitiveExpression(byte.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.SByte": pValue = new CodePrimitiveExpression(SByte.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Int16": pValue = new CodePrimitiveExpression(Int16.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.UInt16": pValue = new CodePrimitiveExpression(UInt16.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Int32": pValue = new CodePrimitiveExpression(Int32.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.UInt32": pValue = new CodePrimitiveExpression(UInt32.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Int64": pValue = new CodePrimitiveExpression(Int64.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.UInt64": pValue = new CodePrimitiveExpression(UInt64.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Decimal": pValue = new CodePrimitiveExpression(Decimal.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Single": pValue = new CodePrimitiveExpression(Single.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Double": pValue = new CodePrimitiveExpression(Double.Parse(valuePart, System.Globalization.CultureInfo.InvariantCulture)); break;
case "System.Boolean": pValue = new CodePrimitiveExpression(bool.Parse(valuePart)); break;
case "System.DateTime": pValue = new CodePrimitiveExpression((DateTime)new XAttribute("x", valuePart)); break;
case "System.Char": pValue = new CodePrimitiveExpression(valuePart[0]); break;
case "System.Type": pValue = new CodeTypeOfExpression(valuePart); break;
default://Enum
pValue = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(TypeName), valuePart); break;
}
if (int.TryParse(pName, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out pnum)) {
posParams.Add(pnum, new CodeAttributeArgument(pValue));
} else {
namedParams.Add(new CodeAttributeArgument(pName, pValue));
}
}
}
attrParams.AddRange(from itm in posParams orderby itm.Key select itm.Value);
attrParams.AddRange(namedParams);
}
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);
}
private static void LoadFieldElement(XmlElement element, CodeTypeDeclaration codeType,
out CodeMemberProperty codeProperty)
{
XmlAttributeCollection attr = element.Attributes;
string type = element.GetAttribute("type"), name = element.GetAttribute("name");
if(type == "string") type = "System.String";
else if(type == "int") type = "System.Int32";
CodeExpression defaultValue = null;
if(element.HasAttribute("default")) {
string defaultString = element.GetAttribute("default");
if(type == "System.String")
defaultValue = new CodePrimitiveExpression(defaultString);
if(type == "System.Int32")
defaultValue = new CodePrimitiveExpression(int.Parse(defaultString));
}
GenerateProperty(codeType, type, name, out codeProperty, defaultValue);
}
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator,
CodeTypeMemberCollection members)
{
List<CodeExpression> initializers = new List<CodeExpression>();
generator.DispatchTablePairs(table.Get("overloads").Table, members, exp =>
{
initializers.Add(exp);
});
var name = new CodePrimitiveExpression((table["name"] as string));
var type = new CodeTypeOfExpression(table["decltype"] as string);
var array = new CodeArrayCreateExpression(typeof(IOverloadableMemberDescriptor), initializers.ToArray());
return new CodeExpression[] {
new CodeObjectCreateExpression(typeof(OverloadedMethodMemberDescriptor), name, type, array)
};
}
public static System.CodeDom.CodeCompileUnit BuildGraph()
{
System.CodeDom.CodeCompileUnit CompileUnit = new System.CodeDom.CodeCompileUnit();
System.CodeDom.CodeNamespace nSpace = new System.CodeDom.CodeNamespace("HelloWorldViaCodeDOM");
CompileUnit.Namespaces.Add(nSpace);
nSpace.Imports.Add(new System.CodeDom.CodeNamespaceImport("System"));
System.CodeDom.CodeTypeDeclaration clsStartup = new System.CodeDom.CodeTypeDeclaration("Startup");
nSpace.Types.Add(clsStartup);
System.CodeDom.CodeEntryPointMethod main = new System.CodeDom.CodeEntryPointMethod();
System.CodeDom.CodePrimitiveExpression exp = new System.CodeDom.CodePrimitiveExpression("Hello World!");
System.CodeDom.CodeTypeReferenceExpression refExp = new System.CodeDom.CodeTypeReferenceExpression("System.Console");
System.CodeDom.CodeMethodInvokeExpression invoke = new System.CodeDom.CodeMethodInvokeExpression(refExp, "WriteLine", exp);
main.Statements.Add(new System.CodeDom.CodeExpressionStatement(invoke));
clsStartup.Members.Add(main);
return(CompileUnit);
}
public override object Serialize(IDesignerSerializationManager manager, object value)
{
CodeExpression expression = new CodePrimitiveExpression(value);
if ((((value == null) || (value is bool)) || ((value is char) || (value is int))) || ((value is float) || (value is double)))
{
CodeDomProvider service = manager.GetService(typeof(CodeDomProvider)) as CodeDomProvider;
if ((service != null) && string.Equals(service.FileExtension, JSharpFileExtension))
{
ExpressionContext context = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if ((context != null) && (context.ExpressionType == typeof(object)))
{
expression = new CodeCastExpression(value.GetType(), expression);
expression.UserData.Add("CastIsBoxing", true);
}
}
return expression;
}
if (value is string)
{
return expression;
}
return new CodeCastExpression(new CodeTypeReference(value.GetType()), expression);
}
public HardwireParameterDescriptor(Table tpar)
{
CodeExpression ename = new CodePrimitiveExpression(tpar.Get("name").String);
CodeExpression etype = new CodeTypeOfExpression(tpar.Get("origtype").String);
CodeExpression hasDefaultValue = new CodePrimitiveExpression(tpar.Get("default").Boolean);
CodeExpression defaultValue = tpar.Get("default").Boolean ? (CodeExpression)(new CodeObjectCreateExpression(typeof(DefaultValue))) :
(CodeExpression)(new CodePrimitiveExpression(null));
CodeExpression isOut = new CodePrimitiveExpression(tpar.Get("out").Boolean);
CodeExpression isRef = new CodePrimitiveExpression(tpar.Get("ref").Boolean);
CodeExpression isVarArg = new CodePrimitiveExpression(tpar.Get("varargs").Boolean);
CodeExpression restrictType = tpar.Get("restricted").Boolean ? (CodeExpression)(new CodeTypeOfExpression(tpar.Get("type").String)) :
(CodeExpression)(new CodePrimitiveExpression(null));
Expression = new CodeObjectCreateExpression(typeof(ParameterDescriptor), new CodeExpression[] {
ename, etype, hasDefaultValue, defaultValue, isOut, isRef,
isVarArg }
);
ParamType = tpar.Get("origtype").String;
HasDefaultValue = tpar.Get("default").Boolean;
IsOut = tpar.Get("out").Boolean;
IsRef = tpar.Get("ref").Boolean;
}
CodeExpression[] GetExpressionList(ArrayList expressionList)
{
if (expressionList == null) {
return new CodeExpression[0];
}
CodeExpression[] list = new CodeExpression[expressionList.Count];
for (int i = 0; i < expressionList.Count; ++i) {
list[i] = (CodeExpression)((Expression)expressionList[i]).AcceptVisitor(this, null);
if (list[i] == null) {
list[i] = new CodePrimitiveExpression(0);
}
}
return list;
}
private void GenerateCodeFromPrimitiveExpression(CodePrimitiveExpression e, TextWriter w, CodeGeneratorOptions o)
{
if (e.Value is string)
{
w.Write("'{0}'", e.Value);
}
else if (e.Value is bool)
{
w.Write(((bool)e.Value) ? "$true" : "$false");
}
else
{
w.Write("{0}", e.Value);
}
}
//System.CodeDom.CodeVariableDeclarationStatement mVecVariableDeclaration = new System.CodeDom.CodeVariableDeclarationStatement();
public override async System.Threading.Tasks.Task GCode_CodeDom_GenerateCode(CodeTypeDeclaration codeClass, CodeStatementCollection codeStatementCollection, CodeGenerateSystem.Base.LinkPinControl element, CodeGenerateSystem.Base.GenerateCodeContext_Method context)
{
var strValueName = GCode_GetValueName(null, context);
if (!context.Method.Statements.Contains(mVarDec))
{
mVarDec = new CodeAssignStatement(new CodeSnippetExpression(mValueType.FullName + " " + strValueName), CodeGenerateSystem.Program.GetDefaultValueExpressionFromType(mValueType));//, paramCodeName, CodeGenerateSystem.Program.GetDefaultValueExpressionFromType(ParamType));
context.Method.Statements.Insert(0, mVarDec);
}
if (mCtrlvalue_VectorIn.HasLink)
{
if (!mCtrlvalue_VectorIn.GetLinkedObject(0, true).IsOnlyReturnValue)
{
await mCtrlvalue_VectorIn.GetLinkedObject(0, true).GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, mCtrlvalue_VectorIn.GetLinkedPinControl(0, true), context);
}
if (!codeStatementCollection.Contains(mAssignCode))
{
mAssignCode = new CodeAssignStatement(new System.CodeDom.CodeVariableReferenceExpression(strValueName), mCtrlvalue_VectorIn.GetLinkedObject(0, true).GCode_CodeDom_GetValue(mCtrlvalue_VectorIn.GetLinkedPinControl(0, true), context));
codeStatementCollection.Add(mAssignCode);
}
}
else
{
if (!codeStatementCollection.Contains(mAssignCode))
{
mAssignCode = new CodeAssignStatement();
mAssignCode.Left = new System.CodeDom.CodeVariableReferenceExpression(strValueName);
var paramExp = new System.CodeDom.CodeExpression[mLinkInDic.Count];
var param = CSParam as AixConstructionParams;
if (param != null)
{
for (int i = 0; i < mLinkInDic.Count; i++)
{
paramExp[i] = new System.CodeDom.CodePrimitiveExpression(param.Value[i]);
}
}
mAssignCode.Right = new CodeObjectCreateExpression(mValueType, paramExp);
codeStatementCollection.Add(mAssignCode);
}
}
foreach (var data in mLinkInDic)
{
var linkOI = data.Element;
if (linkOI.HasLink)
{
if (!linkOI.GetLinkedObject(0, true).IsOnlyReturnValue)
{
await linkOI.GetLinkedObject(0, true).GCode_CodeDom_GenerateCode(codeClass, codeStatementCollection, linkOI.GetLinkedPinControl(0, true), context);
}
var fieldRef = new System.CodeDom.CodeFieldReferenceExpression();
fieldRef.TargetObject = new CodeVariableReferenceExpression(strValueName);
fieldRef.FieldName = data.KeyName;
var statValAss = new System.CodeDom.CodeAssignStatement();
statValAss.Left = fieldRef;
statValAss.Right = new CodeGenerateSystem.CodeDom.CodeCastExpression(typeof(float), linkOI.GetLinkedObject(0, true).GCode_CodeDom_GetValue(linkOI.GetLinkedPinControl(0, true), context));
codeStatementCollection.Add(statValAss);
}
}
}
