public override void VisitIter(IterDefinition iter)
{
currentRoutine = currentIter = iter;
localVariableStack = new IterLocalVariableStack(iter.TypeBuilder);
localVariableStack.Push(iter.LocalVariables);
foreach (Argument arg in iter.Arguments) {
if (arg.Mode == ArgumentMode.Once)
localVariableStack.AddLocal(arg.Name, arg.NodeType);
}
temporallyCount = 0;
iter.StatementList.Accept(this);
currentRoutine = currentIter = null;
}
protected virtual void DefineIterTypeParameters(IterDefinition iter)
{
iter.TypeParameters =
(TypedNodeList) currentClass.TypeParameters.Clone();
if (iter.TypeParameters.Length > 0) {
string[] typeParamNames =
new string[iter.TypeParameters.Length];
int i = 0;
foreach (ParameterDeclaration pd in iter.TypeParameters) {
typeParamNames[i++] = pd.Name;
}
GenericTypeParameterBuilder[] typeParameters =
iter.TypeBuilder.DefineGenericParameters(typeParamNames);
i = 0;
foreach (ParameterDeclaration pd in iter.TypeParameters) {
GenericTypeParameterBuilder pb = typeParameters[i++];
if (pd.ConstrainingType.NodeType.IsAbstract) {
Type[] ifaces = new Type[] {
pd.ConstrainingType.RawType
};
pb.SetInterfaceConstraints(ifaces);
}
else {
Type baseType = pd.ConstrainingType.RawType;
if (baseType != typeof(object))
pb.SetBaseTypeConstraint(baseType);
}
pd.NodeType =
new TypeParameterData(typeManager, pb,
pd.ConstrainingType.NodeType);
typeManager.AddType(pd.NodeType);
pd.NodeType.Parents = new ArrayList();
pd.NodeType.Parents.Add(pd.ConstrainingType.NodeType);
}
}
}
public override void VisitIter(IterDefinition iter)
{
currentRoutine = currentIter = iter;
ilGenerator = iter.Constructor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Stfld, iter.Self);
int index = 2;
foreach (Argument arg in iter.Arguments) {
if (arg.Mode == ArgumentMode.Once) {
LocalVariable local =
(LocalVariable) iter.LocalVariables[arg.Name];
local.Declare(ilGenerator);
local.EmitStorePrefix(ilGenerator);
ilGenerator.Emit(OpCodes.Ldarg, index++);
local.EmitStore(ilGenerator);
}
}
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldc_I4_0);
ilGenerator.Emit(OpCodes.Stfld, iter.CurrentPosition);
ilGenerator.Emit(OpCodes.Ret);
ilGenerator = iter.Creator.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
index = 1;
foreach (Argument arg in iter.Arguments) {
if (arg.Mode == ArgumentMode.Once) {
ilGenerator.Emit(OpCodes.Ldarg, index++);
}
}
ConstructorData constructor =
(ConstructorData) iter.BoundType.Constructors[0];
ilGenerator.Emit(OpCodes.Newobj, constructor.ConstructorInfo);
ilGenerator.Emit(OpCodes.Ret);
ilGenerator = iter.MethodBuilder.GetILGenerator();
EmitVoid(iter.ReturnType.RawType);
ilGenerator.Emit(OpCodes.Ret);
foreach (MethodBuilder bridgeMethod in iter.BridgeMethods) {
ilGenerator = bridgeMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Jmp, iter.Creator);
}
ilGenerator = iter.MoveNext.GetILGenerator();
returnLabel = ilGenerator.DefineLabel();
localVariableStack = new IterLocalVariableStack(iter.TypeBuilder);
localVariableStack.Push(iter.LocalVariables);
foreach (Argument arg in iter.MoveNextArguments) {
if (arg.Mode == ArgumentMode.Out) {
ilGenerator.Emit(OpCodes.Ldarg, arg.Index);
Type argType = arg.RawType.GetElementType();
EmitVoid(argType);
EmitStind(argType);
}
}
Label[] resumePoints = new Label[iter.ResumePoints.Count];
int i = 0;
foreach (ResumePoint resumePoint in iter.ResumePoints) {
resumePoint.Label = ilGenerator.DefineLabel();
resumePoints[i++] = resumePoint.Label;
}
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, iter.CurrentPosition);
ilGenerator.Emit(OpCodes.Switch, resumePoints);
ilGenerator.MarkLabel(resumePoints[0]);
iter.StatementList.Accept(this);
ilGenerator.Emit(OpCodes.Ldc_I4_0);
ilGenerator.MarkLabel(returnLabel);
ilGenerator.Emit(OpCodes.Ret);
if (iter.GetCurrent != null) {
ilGenerator = iter.GetCurrent.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, iter.Current);
ilGenerator.Emit(OpCodes.Ret);
}
nestedTypes.Add(iter.TypeBuilder);
currentRoutine = currentIter = null;
}
public override void VisitIter(IterDefinition iter)
{
iter.Arguments.Accept(this);
iter.MoveNextArguments.Accept(this);
iter.ReturnType.Accept(this);
TypeBuilder typeBuilder = currentClass.TypeBuilder;
try {
CheckMethodConfliction(currentClass.TypeData, iter.Name,
iter.ReturnType.NodeType,
iter.Arguments);
}
catch (MethodConflictionException e) {
report.Error(iter.Location, e.Message);
return;
}
ArrayList conformableMethods =
CheckMethodConformance(currentClass.TypeData, iter.Name,
iter.ReturnType.NodeType,
iter.Arguments,
ancestorMethods);
string baseName = iter.Name.Substring(0, iter.Name.Length - 1);
string creatorName = "__itercreate" + iterCount + "_" + baseName;
Type[] iterTypeAncestors = new Type[conformableMethods.Count];
int i = 0;
foreach (MethodData m in conformableMethods) {
iterTypeAncestors[i++] = m.IterType.RawType;
}
iter.TypeBuilder =
typeBuilder.DefineNestedType("__itertype" + iterCount +
"_" + baseName,
TypeAttributes.Class |
TypeAttributes.NestedPublic,
typeof(object),
iterTypeAncestors);
DefineIterTypeParameters(iter);
TypeData iterType = typeManager.GetTypeData(iter.TypeBuilder);
if (currentClass.TypeParameters.Length > 0) {
TypeData td = iterType.GetGenericTypeDefinition();
iter.BoundType =
td.BindGenericParameters(currentClass.TypeParameters);
}
else
iter.BoundType = iterType;
TypeData boundReceiverType;
if (iter.TypeParameters.Length > 0) {
TypeData td = currentClass.TypeData;
boundReceiverType =
td.BindGenericParameters(iter.TypeParameters);
}
else {
boundReceiverType = currentClass.TypeData;
}
ArrayList list = new ArrayList();
list.Add(boundReceiverType.RawType);
foreach (Argument arg in iter.Arguments) {
if (arg.Mode == ArgumentMode.Once)
list.Add(arg.RawType);
}
Type[] constructorParams = new Type[list.Count];
list.CopyTo(constructorParams);
iter.Constructor =
DefineConstructor(iter.TypeBuilder,
MethodAttributes.Public,
CallingConventions.Standard,
constructorParams);
#if false
iter.Self =
iter.TypeBuilder.DefineField("__self",
boundReceiverType.RawType,
FieldAttributes.Private);
#else
iter.Self =
iter.TypeBuilder.DefineField("__self",
typeBuilder,
FieldAttributes.Private);
#endif
iter.CurrentPosition =
iter.TypeBuilder.DefineField("__currentPosition",
typeof(int),
FieldAttributes.Private);
iter.MoveNext =
DefineMethod(iter.TypeBuilder, "MoveNext",
MethodAttributes.Virtual |
MethodAttributes.HideBySig |
MethodAttributes.Public,
typeManager.BoolType,
iter.MoveNextArguments);
if (!iter.ReturnType.IsNull) {
iter.Current =
iter.TypeBuilder.DefineField("__current",
iter.ReturnType.RawType,
FieldAttributes.Private);
iter.GetCurrent =
DefineMethod(iter.TypeBuilder, "GetCurrent",
MethodAttributes.Virtual |
MethodAttributes.HideBySig |
MethodAttributes.Public,
iter.ReturnType.NodeType,
new TypedNodeList());
}
MethodAttributes attributes =
MethodAttributes.Virtual | MethodAttributes.HideBySig;
switch (iter.Modifier) {
case RoutineModifier.None:
attributes |= MethodAttributes.Public;
break;
case RoutineModifier.Private:
attributes |= MethodAttributes.Private;
break;
}
TypedNodeList creatorArguments =
GetIterCreatorArguments(iter.Arguments);
iter.Creator =
DefineMethod(typeBuilder, creatorName, attributes,
iter.BoundType, creatorArguments);
typeManager.AddIterCreator(iter.Creator);
iter.MethodBuilder =
DefineMethod(typeBuilder, "__iter_" + baseName, attributes,
iter.ReturnType.NodeType,
iter.Arguments);
typeManager.AddBabelName(iter.MethodBuilder, iter.Name);
typeManager.AddIterCreatorName(iter.MethodBuilder, creatorName);
foreach (MethodData m in conformableMethods) {
MethodData abstractCreator = m.IterCreator;
MethodBuilder bridgeMethod =
DefineMethod(typeBuilder,
m.DeclaringType.RawType.FullName + "." +
abstractCreator.Name,
attributes,
abstractCreator.ReturnType,
iter.Arguments);
typeBuilder.DefineMethodOverride(bridgeMethod, m.MethodInfo);
iter.BridgeMethods.Add(bridgeMethod);
}
iterCount++;
}
public virtual void VisitIter(IterDefinition iter)
{
}
