public SwitchCase(TypeContainer elemType, string elemName, object[] discriminatorValues,
FieldBuilder elemField) {
m_elemType = elemType;
m_elemName = elemName;
m_elemField = elemField;
m_discriminatorValues = discriminatorValues;
}
/// <summary>
/// reefines a prameter; not possible for return parameter, ...? TODO: refact ...
/// </summary>
/// <param name="methodBuild"></param>
/// <param name="spec"></param>
/// <param name="paramNr"></param>
private void DefineParameter(MethodBuilder methodBuild, ParameterSpec spec, int paramNr)
{
ParameterAttributes paramAttr = ParameterAttributes.None;
if (spec.IsOut())
{
paramAttr = paramAttr | ParameterAttributes.Out;
}
ParameterBuilder paramBuild = methodBuild.DefineParameter(paramNr, paramAttr, spec.GetPramName());
// custom attribute spec
TypeContainer specType = spec.GetParamType();
for (int i = 0; i < specType.GetSeparatedAttrs().Length; i++)
{
paramBuild.SetCustomAttribute(specType.GetSeparatedAttrs()[i]);
}
}
private MethodBuilder AddPropertyGetterInternal(TypeBuilder builder, string propertyName,
string forIdlGetterName,
TypeContainer propertyType, MethodAttributes attrs)
{
Type propTypeCls = propertyType.GetSeparatedClsType();
MethodBuilder getAccessor = builder.DefineMethod("get_" + propertyName,
attrs | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
propTypeCls, System.Type.EmptyTypes);
ParameterBuilder retParamGet = CreateParamBuilderForRetParam(getAccessor);
// add custom attributes
for (int j = 0; j < propertyType.GetSeparatedAttrs().Length; j++)
{
retParamGet.SetCustomAttribute(propertyType.GetSeparatedAttrs()[j]);
}
if (forIdlGetterName != null)
{
AddFromIdlNameAttribute(getAccessor, forIdlGetterName);
}
return(getAccessor);
}
/// <summary>creates a ParameterSpec for a ParameterInfo</summary>
public ParameterSpec(ParameterInfo forParamInfo)
{
if (forParamInfo.IsOut)
{
m_direction = ParameterDirection.s_out;
}
else if (forParamInfo.ParameterType.IsByRef)
{
m_direction = ParameterDirection.s_inout;
}
else
{
m_direction = ParameterDirection.s_in;
}
m_paramName = forParamInfo.Name;
// custom attributes
System.Object[] attrs = forParamInfo.GetCustomAttributes(false);
m_paramType = new TypeContainer(forParamInfo.ParameterType,
AttributeExtCollection.
ConvertToAttributeCollection(attrs),
true);
}
/// <summary>
/// adds a property to a type, including the custom attributes needed.
/// </summary>
public PropertyBuilder AddProperty(TypeBuilder builder, string propertyName,
TypeContainer propertyType,
MethodBuilder getAccessor, MethodBuilder setAccessor)
{
Type propTypeCls = propertyType.GetSeparatedClsType();
PropertyBuilder propBuild = builder.DefineProperty(propertyName, PropertyAttributes.None,
propTypeCls, System.Type.EmptyTypes);
// add accessor methods
if (getAccessor != null)
{
propBuild.SetGetMethod(getAccessor);
}
if (setAccessor != null)
{
propBuild.SetSetMethod(setAccessor);
}
// define custom attributes
for (int j = 0; j < propertyType.GetSeparatedAttrs().Length; j++)
{
propBuild.SetCustomAttribute(propertyType.GetSeparatedAttrs()[j]);
}
return(propBuild);
}
/// <summary>
/// Like <see cref="Ch.Elca.Iiop.Idl.IlEmitHelper.AddProperty(TypeBuilder, string, TypeContainer, MethodBuilder, MethodBuilder)"/>,
/// but adds additionally a FromIdlName attribute to the property
/// </summary>
public PropertyBuilder AddProperty(TypeBuilder builder, string clsPropertyName,
string forIdlAttributeName,
TypeContainer propertyType,
MethodBuilder getAccessor, MethodBuilder setAccessor) {
PropertyBuilder propBuild = AddProperty(builder, clsPropertyName,
propertyType,
getAccessor, setAccessor);
AddFromIdlNameAttribute(propBuild, forIdlAttributeName);
return propBuild;
}
/**
* @see parser.IDLParserVisitor#visit(ASTwide_string_type, Object)
* @param data unsed
* @return a TypeContainer for the wideString-Type
*/
public Object visit(ASTwide_string_type node, Object data) {
AttributeExtCollection attrs = new AttributeExtCollection(
new Attribute[] { new StringValueAttribute(), new WideCharAttribute(true) });
TypeContainer containter = new TypeContainer(typeof(System.String), attrs);
return containter;
}
public ElementCase(string elemName, TypeContainer elemType)
{
ElemName = elemName;
ElemType = elemType;
discriminatorValues = new ArrayList();
}
public void GenerateSwitchCase(TypeContainer elemType, string elemDeclIdent, object[] discriminatorValues) {
// generate val-field for this switch-case
FieldBuilder elemField = m_ilEmitHelper.AddFieldWithCustomAttrs(m_builder, "m_" + elemDeclIdent,
elemType, FieldAttributes.Private);
SwitchCase switchCase = new SwitchCase(elemType, elemDeclIdent, discriminatorValues,
elemField);
// AMELIORATION possiblity: check range conflict with existing cases, before adding case
m_switchCases.Add(switchCase);
// generate accessor and modifier methods
GenerateAccessorMethod(switchCase);
GenerateModifierMethod(switchCase);
}
private void InitalizePredefinedSymbolMappings(SymbolTable symTable) {
Symbol abstrBase = symTable.ResolveScopedNameToSymbol(symTable.getTopScope(),
new ArrayList(new string[] { "omg.org", "CORBA", "AbstractBase" }));
m_completeTypeTable[abstrBase] =
new TypeContainer(ReflectionHelper.ObjectType,
new AttributeExtCollection(new Attribute[] { new ObjectIdlTypeAttribute(IdlTypeObject.AbstractBase) }));
}
/**
* @see parser.IDLParserVisitor#visit(ASTop_type_spec, Object)
* @param data the active buildinfo for the current scope
* @return the TypeContainer for this op_type_spec
*/
public Object visit(ASTop_type_spec node, Object data) {
TypeContainer returnType;
if (node.jjtGetNumChildren() == 0) {
// void
returnType = new TypeContainer(typeof(void));
} else {
// <parameter type spec>
returnType = (TypeContainer) node.jjtGetChild(0).jjtAccept(this, data);
if (returnType == null) {
throw new InvalidIdlException(
String.Format("type {0} not (yet) defined for {1}",
((SimpleNode)node.jjtGetChild(0)).GetIdentification(),
node.GetIdentification()));
}
returnType = ReplaceByCustomMappedIfNeeded(returnType);
}
return returnType;
}
///<summary>add abstract methods for all implemented interfaces to the abstract class,
///add properties for all implemented interfaces to the abstrct class</summary>
private void AddInheritedMembersAbstractDeclToClassForIf(TypeBuilder classBuilder,
System.Type[] interfaces) {
if (!(classBuilder.IsClass)) {
return;
} // only needed for classes
// make sure to include interfaces inherited by the direct implemented interfaces are also considered here
interfaces = FlattenInterfaceHierarchy(interfaces);
for (int i = 0; i < interfaces.Length; i++) {
Type ifType = interfaces[i];
// methods
MethodInfo[] methods = ifType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
for (int j = 0; j < methods.Length; j++) {
if (methods[j].IsSpecialName) {
continue; // do not add methods with special name, e.g. property accessor methods
}
if (ReflectionHelper.IsMethodDefinedOnType(methods[j], classBuilder.BaseType,
BindingFlags.Instance | BindingFlags.Public)) {
continue; // method is already defined on a baseclass -> do not re-add
}
// normal parameters
ParameterInfo[] parameters = methods[j].GetParameters();
ParameterSpec[] paramSpecs = new ParameterSpec[parameters.Length];
for (int k = 0; k < parameters.Length; k++) {
paramSpecs[k] = new ParameterSpec(parameters[k]);
}
m_ilEmitHelper.AddMethod(classBuilder, methods[j].Name, paramSpecs,
new TypeContainer(methods[j].ReturnType,
AttributeExtCollection.ConvertToAttributeCollection(
methods[j].ReturnTypeCustomAttributes.GetCustomAttributes(false)),
true),
MethodAttributes.Abstract | MethodAttributes.Public |
MethodAttributes.Virtual | MethodAttributes.NewSlot |
MethodAttributes.HideBySig);
}
// properties
PropertyInfo[] properties = ifType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
for (int j = 0; j < properties.Length; j++) {
if (ReflectionHelper.IsPropertyDefinedOnType(properties[j], classBuilder.BaseType,
BindingFlags.Instance | BindingFlags.Public)) {
continue; // property is already defined on a baseclass -> do not re-add
}
TypeContainer propType = new TypeContainer(properties[j].PropertyType,
AttributeExtCollection.ConvertToAttributeCollection(
properties[j].GetCustomAttributes(true)), true);
MethodBuilder getAccessor =
m_ilEmitHelper.AddPropertyGetter(classBuilder, properties[j].Name,
propType, MethodAttributes.Virtual | MethodAttributes.Abstract |
MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.SpecialName | MethodAttributes.NewSlot);
MethodBuilder setAccessor = null;
if (properties[j].CanWrite) {
setAccessor =
m_ilEmitHelper.AddPropertySetter(classBuilder, properties[j].Name,
propType, MethodAttributes.Virtual | MethodAttributes.Abstract |
MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.SpecialName | MethodAttributes.NewSlot);
}
m_ilEmitHelper.AddProperty(classBuilder, properties[j].Name,
propType,
getAccessor, setAccessor);
}
}
}
/// <summary>
/// adds a property getter method.
/// </summary>
/// <param name="attrs">MethodAttributes, automatically adds HideBySig and SpecialName</param>
public MethodBuilder AddPropertyGetter(TypeBuilder builder, string propertyName,
TypeContainer propertyType, MethodAttributes attrs)
{
return(AddPropertyGetterInternal(builder, propertyName, null, propertyType, attrs));
}
/// <summary>creates a ParameterSpec for a ParameterInfo</summary>
public ParameterSpec(ParameterInfo forParamInfo) {
if (forParamInfo.IsOut) {
m_direction = ParameterDirection.s_out;
} else if (forParamInfo.ParameterType.IsByRef) {
m_direction = ParameterDirection.s_inout;
} else {
m_direction = ParameterDirection.s_in;
}
m_paramName = forParamInfo.Name;
// custom attributes
System.Object[] attrs = forParamInfo.GetCustomAttributes(false);
m_paramType = new TypeContainer(forParamInfo.ParameterType,
AttributeExtCollection.
ConvertToAttributeCollection(attrs),
true);
}
/// <summary>creates an in parameterspec</summary>
public ParameterSpec(String paramName, Type clsType) {
m_paramName = paramName;
m_paramType = new TypeContainer(clsType);
m_direction = ParameterDirection.s_in;
}
public ParameterSpec(String paramName, TypeContainer paramType,
ParameterDirection direction) {
m_paramName = paramName;
m_paramType = paramType;
m_direction = direction;
}
public bool IsAssignableTo(TypeContainer type) {
return type.GetCompactClsType().IsEnum;
}
public bool IsAssignableTo(TypeContainer type) {
return type.GetCompactClsType().Equals(ReflectionHelper.BooleanType);
}
public bool IsAssignableTo(TypeContainer type) {
if (type.GetCompactClsType().Equals(ReflectionHelper.ByteType)) {
return m_value >= SByte.MinValue && m_value <= Byte.MaxValue;
} else if (type.GetCompactClsType().Equals(ReflectionHelper.Int16Type)) {
if (type.GetAssignableFromType().Equals(typeof(UInt16))) {
return m_value >= UInt16.MinValue && m_value <= UInt16.MaxValue;
} else {
return m_value >= Int16.MinValue && m_value <= Int16.MaxValue;
}
} else if (type.GetCompactClsType().Equals(ReflectionHelper.Int32Type)) {
if (type.GetAssignableFromType().Equals(typeof(UInt32))) {
return m_value >= UInt32.MinValue && m_value <= UInt32.MaxValue;
} else {
return m_value >= Int32.MinValue && m_value <= Int32.MaxValue;
}
} else if (type.GetCompactClsType().Equals(ReflectionHelper.Int64Type)) {
if (type.GetAssignableFromType().Equals(typeof(UInt64))) {
return m_value >= UInt64.MinValue && m_value <= UInt64.MaxValue;
} else {
return m_value >= Int64.MinValue && m_value <= Int64.MaxValue;
}
} else {
return false;
}
}
/// <summary>creates an in parameterspec</summary>
public ParameterSpec(String paramName, Type clsType)
{
m_paramName = paramName;
m_paramType = new TypeContainer(clsType);
m_direction = ParameterDirection.s_in;
}
/// <summary>adds a method to a type, setting the attributes on the parameters</summary>
/// <remarks>forgeign method: should be better on TypeBuilder, but not possible</remarks>
/// <returns>the MethodBuilder for the method created</returns>
public MethodBuilder AddMethod(TypeBuilder builder, string methodName, ParameterSpec[] parameters,
TypeContainer returnType, MethodAttributes attrs) {
Type[] paramTypes = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++) {
paramTypes[i] = parameters[i].GetParamTypeMergedDirection();
}
MethodBuilder methodBuild = builder.DefineMethod(methodName, attrs,
returnType.GetSeparatedClsType(),
paramTypes);
// define the paramter-names / attributes
for (int i = 0; i < parameters.Length; i++) {
DefineParameter(methodBuild, parameters[i], i+1);
}
// add custom attributes for the return type
ParameterBuilder paramBuild = CreateParamBuilderForRetParam(methodBuild);
for (int i = 0; i < returnType.GetSeparatedAttrs().Length; i++) {
paramBuild.SetCustomAttribute(returnType.GetSeparatedAttrs()[i]);
}
return methodBuild;
}
/**
* @see parser.IDLParserVisitor#visit(ASTvalue_base_type, Object)
* @return a Type Container for the Corba type ValueBase
*/
public Object visit(ASTvalue_base_type node, Object data) {
AttributeExtCollection attrs = new AttributeExtCollection(
new Attribute[] { new ObjectIdlTypeAttribute(IdlTypeObject.ValueBase) });
TypeContainer container = new TypeContainer(typeof(System.Object), attrs);
return container;
}
/// <summary>add a fully defined type to the known types</summary>
private void AddCompleteTypeDefinition(Symbol typeSymbol, TypeContainer fullDecl) {
if (m_typesInCreation.ContainsKey(typeSymbol)) {
throw new InternalCompilerException("type can't be registered, an incomplete declaration exists; symbol: " + typeSymbol); // should not occur, check by sym table
}
if (m_completeTypeTable.ContainsKey(typeSymbol)) {
throw new InternalCompilerException("type already defined; symbol: " + typeSymbol); // should not occur, checked by sym table
}
m_completeTypeTable[typeSymbol] = fullDecl;
}
/// <summary>
/// register a resolved typedef
/// </summary>
public void RegisterTypeDef(TypeContainer fullDecl, Symbol forSymbol) {
AddCompleteTypeDefinition(forSymbol, fullDecl);
}
/// <summary>
/// Like <see cref="Ch.Elca.Iiop.Idl.IlEmitHelper.AddMethod(TypeBuilder, string, ParameterSpec[], TypeContainer, MethodAttributes)"/>,
/// but adds additionally a FromIdlName attribute to the method
/// </summary>
public MethodBuilder AddMethod(TypeBuilder builder, string clsMethodName,
string forIdlMethodName,
ParameterSpec[] parameters,
TypeContainer returnType, MethodAttributes attrs) {
MethodBuilder methodBuild = AddMethod(builder, clsMethodName, parameters,
returnType, attrs);
AddFromIdlNameAttribute(methodBuild, forIdlMethodName);
return methodBuild;
}
/**
* replaces a TypeContainer with the one for the custom mapped type, if a custom mapped type is
* present. Else Returns the unmodified one.
**/
internal static TypeContainer ReplaceByCustomMappedIfNeeded(TypeContainer specType) {
Type clsType = specType.GetCompactClsType(); // do the mapping on the fusioned type!
// check for custom Mapping here:
CompilerMappingPlugin plugin = CompilerMappingPlugin.GetSingleton();
if (plugin.IsCustomMappingPresentForIdl(clsType.FullName)) {
Type mappedType = plugin.GetMappingForIdl(clsType.FullName);
return new TypeContainer(mappedType);
} else {
return specType;
}
}
/// <summary>
/// get the full defined Type or the fwd decl
/// </summary>
public TypeContainer GetKnownType(Symbol forSymbol) {
// search in all complete types from this run, also typesdefs, ...
TypeContainer result = (TypeContainer)m_completeTypeTable[forSymbol];
if (result == null) {
result = (TypeContainer)m_typesInCreation[forSymbol];
}
if (result == null) {
// search in build-module to get also types from a run over a previous root idl-file (one specified on the command line)
Type fromBuildMod = GetTypeFromBuildModule(forSymbol);
if (fromBuildMod != null) {
result = new CompileTimeTypeContainer(this, fromBuildMod);
}
}
if (result == null) {
// check in types, which are defined in referenced assemblies
Type fromAsm = GetTypeFromRefAssemblies(forSymbol);
if (fromAsm != null) {
// remark: all types in ref assemblies are fully completed -> no need for compileTimeTypeContainer
result = new TypeContainer(fromAsm);
}
}
if ((result == null) && (m_sequenceRecursionAllowedType != null) &&
m_sequenceRecursionAllowedType.SymbolPart.Equals(forSymbol)) {
result = m_sequenceRecursionAllowedType.TypePart;
}
return result;
}
/// <summary>adds a field to a type, including the custom attributes needed</summary>
/// <remarks>forgeign method: should be better on TypeBuilder, but not possible</remarks>
/// <returns>the FieldBuilder for the field created</returns>
public FieldBuilder AddFieldWithCustomAttrs(TypeBuilder builder, string fieldName,
TypeContainer fieldType, FieldAttributes attrs) {
// consider custom mappings
Type clsType = fieldType.GetSeparatedClsType();
FieldBuilder fieldBuild = builder.DefineField(fieldName, clsType, attrs);
// add custom attributes
for (int j = 0; j < fieldType.GetSeparatedAttrs().Length; j++) {
fieldBuild.SetCustomAttribute(fieldType.GetSeparatedAttrs()[j]);
}
return fieldBuild;
}
public TypeSymbolPair(Symbol symbolPart, TypeContainer typePart) {
SymbolPart = symbolPart;
TypePart = typePart;
}
/// <summary>
/// adds a property setter method; optinally adds a FromIdlNameAttribute,
/// if forIdlAttributeName is != null.
/// </summary>
private MethodBuilder AddPropertySetterInternal(TypeBuilder builder,
string propertyName,
string forIdlSetterName,
TypeContainer propertyType,
MethodAttributes attrs) {
Type propTypeCls = propertyType.GetSeparatedClsType();
MethodBuilder setAccessor = builder.DefineMethod("set_" + propertyName,
attrs | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
null, new System.Type[] { propTypeCls });
ParameterBuilder valParam = setAccessor.DefineParameter(1, ParameterAttributes.None, "value");
// add custom attributes
for (int j = 0; j < propertyType.GetSeparatedAttrs().Length; j++) {
valParam.SetCustomAttribute(propertyType.GetSeparatedAttrs()[j]);
}
if (forIdlSetterName != null) {
AddFromIdlNameAttribute(setAccessor, forIdlSetterName);
}
return setAccessor;
}
public void AddDiscriminatorFieldAndProperty(TypeContainer discrType, ArrayList coveredDiscrRange) {
if ((m_discrType != null) || (m_coveredDiscrs == null)) {
throw new INTERNAL(899, CompletionStatus.Completed_MayBe);
}
m_discrType = discrType;
m_coveredDiscrs = coveredDiscrRange;
m_discrField = m_ilEmitHelper.AddFieldWithCustomAttrs(m_builder, DISCR_FIELD_NAME, m_discrType,
FieldAttributes.Private);
// Property for discriminiator
String propName = DISCR_PROPERTY_NAME;
// set the methods for the property
MethodBuilder getAccessor = m_ilEmitHelper.AddPropertyGetter(m_builder, propName, m_discrType,
MethodAttributes.Public);
ILGenerator gen = getAccessor.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldfld, m_discrField);
gen.Emit(OpCodes.Ret);
MethodBuilder setAccessor = null;
m_ilEmitHelper.AddProperty(m_builder, propName, m_discrType, getAccessor, setAccessor);
// add a method, which returns an array of covered discriminators
AddCoveredDiscrsGetter();
}
/// <summary>
/// adds a property getter method with a FromIdlName attribute
/// (based on the name of the property, this setter is defined for)
/// </summary>
/// <param name="attrs">MethodAttributes, automatically adds HideBySig and SpecialName</param>
public MethodBuilder AddPropertyGetter(TypeBuilder builder, string propertyName,
string forIdlGetterName,
TypeContainer propertyType, MethodAttributes attrs) {
return AddPropertyGetterInternal(builder, propertyName, forIdlGetterName,
propertyType, attrs);
}
private MethodBuilder AddPropertyGetterInternal(TypeBuilder builder, string propertyName,
string forIdlGetterName,
TypeContainer propertyType, MethodAttributes attrs) {
Type propTypeCls = propertyType.GetSeparatedClsType();
MethodBuilder getAccessor = builder.DefineMethod("get_" + propertyName,
attrs | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
propTypeCls, System.Type.EmptyTypes);
ParameterBuilder retParamGet = CreateParamBuilderForRetParam(getAccessor);
// add custom attributes
for (int j = 0; j < propertyType.GetSeparatedAttrs().Length; j++) {
retParamGet.SetCustomAttribute(propertyType.GetSeparatedAttrs()[j]);
}
if (forIdlGetterName != null) {
AddFromIdlNameAttribute(getAccessor, forIdlGetterName);
}
return getAccessor;
}
/// <summary>
/// adds a property to a type, including the custom attributes needed.
/// </summary>
public PropertyBuilder AddProperty(TypeBuilder builder, string propertyName,
TypeContainer propertyType,
MethodBuilder getAccessor, MethodBuilder setAccessor) {
Type propTypeCls = propertyType.GetSeparatedClsType();
PropertyBuilder propBuild = builder.DefineProperty(propertyName, PropertyAttributes.None,
propTypeCls, System.Type.EmptyTypes);
// add accessor methods
if (getAccessor != null) {
propBuild.SetGetMethod(getAccessor);
}
if (setAccessor != null) {
propBuild.SetSetMethod(setAccessor);
}
// define custom attributes
for (int j = 0; j < propertyType.GetSeparatedAttrs().Length; j++) {
propBuild.SetCustomAttribute(propertyType.GetSeparatedAttrs()[j]);
}
return propBuild;
}
internal override Type CreateType(ModuleBuilder modBuilder, string fullTypeName)
{
UnionGenerationHelper genHelper = new UnionGenerationHelper(modBuilder, fullTypeName,
TypeAttributes.Public);
TypeContainer discrType = new TypeContainer(((TypeCodeImpl)m_discriminatorType).GetClsForTypeCode(),
((TypeCodeImpl)m_discriminatorType).GetClsAttributesForTypeCode());
// extract covered discr range from m_members
ArrayList coveredDiscriminatorRange = CoveredDiscriminatorRange();
genHelper.AddDiscriminatorFieldAndProperty(discrType, coveredDiscriminatorRange);
Hashtable cases = CollectCases();
foreach (ElementCase elemCase in cases.Values)
{
genHelper.GenerateSwitchCase(elemCase.ElemType, elemCase.ElemName,
elemCase.GetDiscriminatorValues());
}
// add rep-id Attr
IlEmitHelper.GetSingleton().AddRepositoryIDAttribute(genHelper.Builder, m_id);
// create the resulting type
return genHelper.FinalizeType();
}
/**
* @see parser.IDLParserVisitor#visit(ASTsequence_type, Object)
* @param data the buildinfo in use for the current scope
* @return the type container for the IDLSequence type
*/
public Object visit(ASTsequence_type node, Object data) {
CheckParameterForBuildInfo(data, node);
BuildInfo containerInfo = (BuildInfo) data;
SimpleNode elemTypeNode = (SimpleNode)node.jjtGetChild(0);
if (containerInfo.GetContainterType() != null) {
// inform the type-manager of structs/unions in creation, because
// recursion using seuqneces is the only allowed recursion for structs/unions
m_typeManager.PublishTypeForSequenceRecursion(containerInfo.GetContainerSymbol(),
containerInfo.GetContainterType());
}
Debug.WriteLine("determine element type of IDLSequence");
TypeContainer elemType = (TypeContainer)elemTypeNode.jjtAccept(this, data);
// disallow further recursive use of union/struct (before next seq recursion)
m_typeManager.UnpublishTypeForSequenceRecursion();
if (elemType == null) {
throw new InvalidIdlException(
String.Format("sequence element type not defined for {0}",
node.GetIdentification()));
}
elemType = ReplaceByCustomMappedIfNeeded(elemType);
// use here the fusioned type as element type; potential unboxing of element type
// should be done by users of TypeContainer (if needed)!
Debug.WriteLine("seq type determined: " + elemType.GetCompactClsType());
// create CLS array type with the help of GetType(), otherwise not possible
Type arrayType;
// because not fully defined types are possible, use module and not assembly to get type from
Module declModule = elemType.GetCompactClsType().Module;
arrayType = declModule.GetType(elemType.GetCompactClsType().FullName + "[]"); // not nice, better solution ?
Debug.WriteLine("created array type: " + arrayType);
// determin if sequence is bounded or unbounded
long bound = 0;
if (node.jjtGetNumChildren() > 1) {
// bounded sequnece
bound = (long) node.jjtGetChild(1).jjtAccept(this, data);
}
// determine the needed attributes: IdlSequence is required by the sequence itself;
// combine with the attribute from the element type
// possible are: IdlSequence (for sequence of sequence), ObjectIdlType,
// WideChar, StringValue
// invariant: boxed value attribute is not among them, because elem type
// is in the compact form
AttributeExtCollection elemAttributes = elemType.GetCompactTypeAttrInstances();
long seqAttrOrderNr = IdlSequenceAttribute.DetermineSequenceAttributeOrderNr(elemAttributes);
IdlSequenceAttribute seqAttr = new IdlSequenceAttribute(seqAttrOrderNr, bound);
AttributeExtCollection sequenceAttributes =
new AttributeExtCollection(elemAttributes);
sequenceAttributes = sequenceAttributes.MergeAttribute(seqAttr);
TypeContainer result = new TypeContainer(arrayType,
sequenceAttributes );
return result;
}
