protected MethodImpl(LexicalInfo lexicalInfo, TypeReference returnType) : base(lexicalInfo) { _parameters = new ParameterDeclarationCollection(this); _returnTypeAttributes = new AttributeCollection(this); Body = new Block(); ReturnType = returnType; }
protected MethodImpl(TypeReference returnType) { _parameters = new ParameterDeclarationCollection(this); _returnTypeAttributes = new AttributeCollection(this); Body = new Block(); ReturnType = returnType; }
private void CompleteOmittedParameterType(CallableDefinition node) { ParameterDeclarationCollection parameters = node.Parameters; if (0 == parameters.Count) { return; } ParameterDeclaration last = parameters[-1]; foreach (ParameterDeclaration parameter in parameters) { if (null == parameter.Type) { if (parameters.VariableNumber && last == parameter) { parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectArrayType); } else { parameter.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ObjectType); } } } }
public DefinitionClassCompilerStep(ParameterDeclarationCollection parameters) : base(typeof(Definition), "RunImpl", parameters, typeof(MetaMethods).Namespace, typeof(Definition).Namespace ) { }
Method CreateBeginInvokeExtension(ICallableType anonymousType, Method beginInvoke, out MethodInvocationExpression mie) { InternalMethod beginInvokeEntity = (InternalMethod)beginInvoke.Entity; Method extension = CodeBuilder.CreateMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)), TypeMemberModifiers.Public | TypeMemberModifiers.Static); extension.Attributes.Add(CodeBuilder.CreateAttribute(Types.ExtensionAttribute)); ParameterDeclaration self = CodeBuilder.CreateParameterDeclaration(0, "self", beginInvokeEntity.DeclaringType); extension.Parameters.Add(self); CodeBuilder.DeclareParameters(extension, 1, anonymousType.GetSignature().Parameters); mie = CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(self), beginInvokeEntity); ParameterDeclarationCollection parameters = extension.Parameters; for (int i = 1; i < parameters.Count; ++i) { mie.Arguments.Add(CodeBuilder.CreateReference(parameters[i])); } extension.Body.Add(new ReturnStatement(mie)); return(extension); }
public IParameter[] Map(ParameterDeclarationCollection parameters) { IParameter[] mapped = new IParameter[parameters.Count]; for (int i = 0; i < mapped.Length; ++i) { mapped[i] = (IParameter)GetEntity(parameters[i]); } return(mapped); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { ParameterDeclarationCollection parameters = new ParameterDeclarationCollection(); ParameterDeclaration newParameterDeclaration = new ParameterDeclaration("input", new SimpleTypeReference("System.String")); parameters.Add(newParameterDeclaration); pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(MyClassWithParams), "Hello", parameters, "System")); }
void WriteParameterList(ParameterDeclarationCollection items, string st, string ed) { Write(st); int last = items.Count - 1; for (int i = 0; i < items.Count; ++i) { if (i > 0) { Write(", "); } if (i == last && items.VariableNumber) { Write("*"); } Visit(items.GetNodeAt(i)); } Write(ed); }
void WriteParameterList(ParameterDeclarationCollection items, string st, string ed) { Write(st); int last = items.Count - 1; int i = 0; foreach (ParameterDeclaration item in items) { if (i > 0) { Write(", "); } if (i == last && items.VariableNumber) { Write("*"); } Visit(item); ++i; } Write(ed); }
private void CompleteOmittedParameterTypes(CallableDefinition node) { ParameterDeclarationCollection parameters = node.Parameters; if (parameters.Count == 0) { return; } foreach (ParameterDeclaration parameter in parameters) { if (parameter.Type != null) { continue; } parameter.Type = CodeBuilder.CreateTypeReference( parameter.IsParamArray ? TypeSystemServices.ObjectArrayType : TypeSystemServices.ObjectType); } }
public void BindParameterDeclarations(bool isStatic, INodeWithParameters node) { // arg0 is the this pointer when member is not static int delta = isStatic ? 0 : 1; ParameterDeclarationCollection parameters = node.Parameters; for (int i = 0; i < parameters.Count; ++i) { ParameterDeclaration parameter = parameters[i]; if (null == parameter.Type) { if (parameter.IsParamArray) { parameter.Type = CreateTypeReference(TypeSystemServices.ObjectArrayType); } else { parameter.Type = CreateTypeReference(TypeSystemServices.ObjectType); } } parameter.Entity = new InternalParameter(parameter, i + delta); } }
public void BindParameterDeclarations(bool isStatic, INodeWithParameters node) { // arg0 is the this pointer when member is not static int delta = isStatic ? 0 : 1; ParameterDeclarationCollection parameters = node.Parameters; int last = parameters.Count - 1; for (int i = 0; i < parameters.Count; ++i) { ParameterDeclaration parameter = parameters[i]; if (null == parameter.Type) { if (last == i && parameters.VariableNumber) { parameter.Type = CreateTypeReference(_tss.ObjectArrayType); } else { parameter.Type = CreateTypeReference(_tss.ObjectType); } } parameter.Entity = new InternalParameter(parameter, i + delta); } }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n) { return Compare<ParameterDeclaration>(source,n); }
void WriteParameterList(ParameterDeclarationCollection items) { WriteParameterList(items, "(", ")"); }
/// <summary> /// Create new instance of <seealso cref="ImplicitBaseClassCompilerStep"/> /// </summary> /// <param name="baseClass">The base class that will be used</param> /// <param name="methodName">The name of the method that will get all the code from globals moved to it.</param> /// <param name="parameters">The parameters of this method</param> /// <param name="namespaces">Namespaces that would be automatically imported into all modules</param> public ImplicitBaseClassCompilerStep(Type baseClass, string methodName, ParameterDeclarationCollection parameters, params string[] namespaces) : base(baseClass, namespaces) { this.methodName = methodName; this.parameters = parameters; }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n) { return(Compare <ParameterDeclaration>(source, n)); }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n, Func <ParameterDeclaration, ParameterDeclaration, bool> checkitem) { return(Compare <ParameterDeclaration>(source, n, checkitem)); }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n, Func<ParameterDeclaration, ParameterDeclaration, Action<string, string>, bool> checkitem, Action<string, string> errAct) { return Compare<ParameterDeclaration>(source,n,checkitem,errAct); }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n, Func<ParameterDeclaration, ParameterDeclaration, bool> checkitem) { return Compare<ParameterDeclaration>(source,n,checkitem); }
public static bool Compare(this ParameterDeclarationCollection source, ParameterDeclarationCollection n, Func <ParameterDeclaration, ParameterDeclaration, Action <string, string>, bool> checkitem, Action <string, string> errAct) { return(Compare <ParameterDeclaration>(source, n, checkitem, errAct)); }
public ClassDefinition GetContextFieldDeclaration() { Field field; Field field2; ParameterDeclaration declaration; MemberReferenceExpression expression; ReferenceExpression expression2; BinaryExpression expression3; ReferenceExpression expression4; ReferenceExpression expression5; MemberReferenceExpression expression6; BinaryExpression expression7; Block block; Constructor constructor; ClassDefinition definition; Type type = this._evaluationContext.GetType(); Type type2 = this._evaluationContext.ScriptContainer.GetType(); ClassDefinition definition1 = definition = new ClassDefinition(LexicalInfo.Empty); string text1 = definition.Name = "_"; TypeMember[] items = new TypeMember[3]; Field field1 = field = new Field(LexicalInfo.Empty); int num1 = (int)(field.Modifiers = TypeMemberModifiers.Static | TypeMemberModifiers.Public); string text2 = field.Name = "ScriptContainer"; TypeReference reference1 = field.Type = TypeReference.Lift(type2); int num2 = (int)(field.IsVolatile = false); items[0] = field; Field field3 = field2 = new Field(LexicalInfo.Empty); string text3 = field2.Name = "EvaluationContext"; TypeReference reference4 = field2.Type = TypeReference.Lift(type); int num3 = (int)(field2.IsVolatile = false); items[1] = field2; Constructor constructor1 = constructor = new Constructor(LexicalInfo.Empty); string text4 = constructor.Name = "constructor"; ParameterDeclaration[] parameters = new ParameterDeclaration[1]; ParameterDeclaration declaration1 = declaration = new ParameterDeclaration(LexicalInfo.Empty); string text5 = declaration.Name = "context"; TypeReference reference5 = declaration.Type = TypeReference.Lift(type); parameters[0] = declaration; ParameterDeclarationCollection collection1 = constructor.Parameters = ParameterDeclarationCollection.FromArray(false, parameters); Block block1 = block = new Block(LexicalInfo.Empty); Statement[] statementArray1 = new Statement[2]; BinaryExpression expression1 = expression3 = new BinaryExpression(LexicalInfo.Empty); int num4 = (int)(expression3.Operator = BinaryOperatorType.Assign); MemberReferenceExpression expression14 = expression = new MemberReferenceExpression(LexicalInfo.Empty); string text6 = expression.Name = "EvaluationContext"; SelfLiteralExpression expression15 = expression.Target = new SelfLiteralExpression(LexicalInfo.Empty); MemberReferenceExpression expression16 = expression3.Left = expression; ReferenceExpression expression17 = expression2 = new ReferenceExpression(LexicalInfo.Empty); string text7 = expression2.Name = "context"; ReferenceExpression expression18 = expression3.Right = expression2; statementArray1[0] = Statement.Lift(expression3); BinaryExpression expression19 = expression7 = new BinaryExpression(LexicalInfo.Empty); int num5 = (int)(expression7.Operator = BinaryOperatorType.Assign); ReferenceExpression expression20 = expression4 = new ReferenceExpression(LexicalInfo.Empty); string text8 = expression4.Name = "ScriptContainer"; ReferenceExpression expression21 = expression7.Left = expression4; MemberReferenceExpression expression22 = expression6 = new MemberReferenceExpression(LexicalInfo.Empty); string text9 = expression6.Name = "ScriptContainer"; ReferenceExpression expression23 = expression5 = new ReferenceExpression(LexicalInfo.Empty); string text10 = expression5.Name = "context"; ReferenceExpression expression24 = expression6.Target = expression5; MemberReferenceExpression expression25 = expression7.Right = expression6; statementArray1[1] = Statement.Lift(expression7); StatementCollection collection2 = block.Statements = StatementCollection.FromArray(statementArray1); Block block3 = constructor.Body = block; items[2] = constructor; TypeMemberCollection collection3 = definition.Members = TypeMemberCollection.FromArray(items); return(definition); }
public virtual IParameterDeclarationCollection TransformParameterDeclarationCollection(IParameterDeclarationCollection parameters) { IParameterDeclaration[] array = new IParameterDeclaration[parameters.Count]; for (int i = 0; i < parameters.Count; i++) { array[i] = this.TransformParameterDeclaration(parameters[i]); } IParameterDeclarationCollection target = new ParameterDeclarationCollection(); target.AddRange(array); return target; }