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;
}
