/** Parsing members means creating new members for definitions with more than one declarator. */ public void parse() { boolean clone_and_parse = true; if (extendVector == null) throw new RuntimeException("Compiler Error: extendVector not set!"); if (type_spec.typeSpec() instanceof ScopedName) { token = type_spec.typeSpec().get_token(); type_spec = ((ScopedName) type_spec.typeSpec()).resolvedTypeSpec(); clone_and_parse = false; if (type_spec instanceof ConstrTypeSpec) { if (((ConstrTypeSpec) type_spec.typeSpec()).c_type_spec instanceof StructType) { // System.out.println("Struct " + containing_struct.typeName() + " contains struct " + // ((ConstrTypeSpec)type_spec.typeSpec()).typeName()); if (((ConstrTypeSpec) type_spec.typeSpec()) .c_type_spec .typeName() .equals(containing_struct.typeName())) { parser.fatal_error( "Illegal recursion in struct (use sequence<" + containing_struct.typeName() + "> instead)", token); } } } } else if (type_spec.typeSpec() instanceof SequenceType) { TypeSpec ts = ((SequenceType) type_spec.typeSpec()).elementTypeSpec().typeSpec(); SequenceType seqTs = (SequenceType) type_spec.typeSpec(); while (ts instanceof SequenceType) { seqTs = (SequenceType) ts; ts = ((SequenceType) ts.typeSpec()).elementTypeSpec().typeSpec(); } // if( ts.typeName().equals( containing_struct.typeName()) || if (ScopedName.isRecursionScope(ts.typeName())) { seqTs.setRecursive(); } } else if (type_spec instanceof ConstrTypeSpec) { type_spec.parse(); } for (Enumeration e = declarators.v.elements(); e.hasMoreElements(); ) { Declarator d = (Declarator) e.nextElement(); // we don't parse the declarator itself // as that would result in its name getting defined // we define the declarator's name as a type name indirectly // through the cloned type specs. Member m = new Member(new_num()); m.declarator = d; TypeSpec ts = type_spec.typeSpec(); /* create a separate type spec copy for every declarator if the type spec is a new type definition, i.e. a struct, enum, union, sequence or the declarator is an array declarator */ // if( clone_and_parse && !(ts instanceof BaseType) ) if (clone_and_parse || d.d instanceof ArrayDeclarator) { /* arrays need special treatment */ if (d.d instanceof ArrayDeclarator) { ts = new ArrayTypeSpec(new_num(), ts, (ArrayDeclarator) d.d, pack_name); ts.parse(); } else if (!(ts instanceof BaseType)) { ts = (TypeSpec) ts.clone(); if (!(ts instanceof ConstrTypeSpec)) ts.set_name(d.name()); /* important: only parse type specs once (we do it for the last declarator only) */ if (!e.hasMoreElements()) ts.parse(); } } // else if (!(d.d instanceof ArrayDeclarator)) { try { NameTable.define(containing_struct + "." + d.name(), "declarator"); } catch (NameAlreadyDefined nad) { parser.error("Declarator " + d.name() + " already defined in scope.", token); } } /* if the type spec is a scoped name, it is already parsed and * the type name is defined */ // if( clone_and_parse ) // ts.parse(); m.type_spec = ts; m.pack_name = this.pack_name; m.name = this.name; extendVector.addElement(m); } declarators = null; }