static  void addMinusPointlessParticles(List list,
    SchemaParticle part,
    int parentParticleType) 
{
        if (part == null)
            return;
        switch (part.getParticleType())
        {
            case SchemaParticle.SEQUENCE:
                if (parentParticleType == SchemaParticle.SEQUENCE && part.isSingleton())
                {
                    // emitDBG("dropping redundant sequence");
                    list.addAll(Arrays.asList(part.getParticleChildren()));
                    return;
                }
                break;
            case SchemaParticle.CHOICE:
                if (parentParticleType == SchemaParticle.CHOICE && part.isSingleton())
                {
                    // emitDBG("dropping redundant choice");
                    list.addAll(Arrays.asList(part.getParticleChildren()));
                    return;
                }
                break;
            case SchemaParticle.ALL:
            default:                
        }
        list.add(part);
}

 static Map buildAttributePropertyModelByQName(SchemaAttributeModel attrModel,
    SchemaType owner) 
{
        Map result = new LinkedHashMap();
        SchemaLocalAttribute[] attruses = attrModel.getAttributes();
        for (int i = 0; i <  attruses.length; i++)
            result.put(attruses[i].getName(), buildUseProperty(attruses[i], owner));
        return result;
}

 static Map buildContentPropertyModelByQName(SchemaParticle part,
    SchemaType owner) 
{
        if (part == null)
            return Collections.EMPTY_MAP;
        boolean asSequence = false;
        Map model = null;
        switch (part.getParticleType())
        {
            case SchemaParticle.ALL:
            case SchemaParticle.SEQUENCE:
                asSequence = true;
                break;
            case SchemaParticle.CHOICE:
                asSequence = false;
                break;
            case SchemaParticle.ELEMENT:
                model = buildElementPropertyModel((SchemaLocalElement)part, owner);
                break;
            case SchemaParticle.WILDCARD:
                model = Collections.EMPTY_MAP;
                break;
            default:
                assert(false);
                throw new IllegalStateException();
        }
        if (model == null)
        {
            // build model for children
            model = new LinkedHashMap();
            SchemaParticle[] children = part.getParticleChildren();
            for (int i = 0; i <  children.length; i++)
            {
                // indentDBG();
                Map childModel = buildContentPropertyModelByQName(children[i], owner);
                // outdentDBG();
                for (Iterator j = childModel.values().iterator(); j.hasNext(); )
                {
                    SchemaProperty iProp = (SchemaProperty)j.next();
                    SchemaPropertyImpl oProp = (SchemaPropertyImpl)model.get(iProp.getName());
                    if (oProp == null)
                    {
                        if (!asSequence)
                            ((SchemaPropertyImpl)iProp).setMinOccurs(BigInteger.ZERO);
                        model.put(iProp.getName(), iProp);
                        continue;
                    }
                    // consistency verified in an earlier step
                    assert(oProp.getType().equals(iProp.getType()));
                    mergeProperties(oProp, iProp, asSequence);
                }
            }
            // finally deal with minOccurs, maxOccurs over whole group
            BigInteger min = part.getMinOccurs();
            BigInteger max = part.getMaxOccurs();
            for (Iterator j = model.values().iterator(); j.hasNext(); )
            {
                SchemaProperty oProp = (SchemaProperty)j.next();
                BigInteger minOccurs = oProp.getMinOccurs();
                BigInteger maxOccurs = oProp.getMaxOccurs();
                minOccurs = minOccurs.multiply(min);
                if (max != null && max.equals(BigInteger.ZERO))
                    maxOccurs = BigInteger.ZERO;
                else if (maxOccurs != null && !maxOccurs.equals(BigInteger.ZERO))
                    maxOccurs = max == null ? null : maxOccurs.multiply(max);
                ((SchemaPropertyImpl)oProp).setMinOccurs(minOccurs);
                ((SchemaPropertyImpl)oProp).setMaxOccurs(maxOccurs);
            }
        }
        return model;
}

 static Map buildElementPropertyModel(SchemaLocalElement epart,
    SchemaType owner) 
{
        Map result = new HashMap(1);
        SchemaProperty sProp = buildUseProperty(epart, owner);
        result.put(sProp.getName(), sProp);
        return result;
}

 static  void buildStateMachine(SchemaParticle contentModel) 
{
        if (contentModel == null)
            return;
        SchemaParticleImpl partImpl = (SchemaParticleImpl)contentModel;
        if (partImpl.hasTransitionNotes())
            return;
        QNameSetBuilder start = new QNameSetBuilder();
        QNameSetBuilder excludenext = new QNameSetBuilder();
        boolean deterministic = true;
        SchemaParticle[] children = null;
        boolean canskip = (partImpl.getMinOccurs().signum() == 0);
        switch (partImpl.getParticleType())
        {
            case SchemaParticle.ELEMENT:
                // compute start and excludeNext; canskip is already correct
                if (partImpl.hasTransitionRules())
                    start.addAll(partImpl.acceptedStartNames());
                else
                    start.add(partImpl.getName());
                break;
            case SchemaParticle.WILDCARD:
                // compute start and excludeNext; canskip is already correct
                start.addAll(partImpl.getWildcardSet());
                break;
            case SchemaParticle.SEQUENCE:
                children = ensureStateMachine(partImpl.getParticleChildren());
                // adjust canskip if all children are skippable
                canskip = true;
                for (int i = 0; canskip && i <  children.length; i++)
                {
                    if (!(children[i]).isSkippable())
                        canskip = false;
                }
                // bubble up nondeterministic bit
                for (int i = 0; deterministic && i <  children.length; i++)
                {
                    if (!((SchemaParticleImpl)children[i]).isDeterministic())
                        deterministic = false;
                }
                // verify deterministic and compute excludeNext set
                for (int i = 1; i <  children.length; i++)
                {
                    excludenext.addAll(((SchemaParticleImpl)children[i - 1]).getExcludeNextSet());
                    if (deterministic && !excludenext.isDisjoint((children[i]).acceptedStartNames()))
                        deterministic = false;
                    if ((children[i]).isSkippable())
                        excludenext.addAll((children[i]).acceptedStartNames());
                    else
                        excludenext.clear();
                }
                // next, compute start set
                for (int i = 0; i <  children.length; i++)
                {
                    start.addAll((children[i]).acceptedStartNames());
                    if (!(children[i]).isSkippable())
                        break;
                }
                break;
            case SchemaParticle.CHOICE:
                children = ensureStateMachine(partImpl.getParticleChildren());
                // adjust canskip if any children are skippable
                canskip = false;
                for (int i = 0; !canskip && i <  children.length; i++)
                {
                    if ((children[i]).isSkippable())
                        canskip = true;
                }
                // bubble up nondeterministic bit
                for (int i = 0; deterministic && i <  children.length; i++)
                {
                    if (!((SchemaParticleImpl)children[i]).isDeterministic())
                        deterministic = false;
                }
                // compute start and excludeNext sets, verify deterministic
                for (int i = 0; i <  children.length; i++)
                {
                    if (deterministic && !start.isDisjoint((children[i]).acceptedStartNames()))
                        deterministic = false;
                    start.addAll((children[i]).acceptedStartNames());
                    excludenext.addAll(((SchemaParticleImpl)children[i]).getExcludeNextSet());
                }
                break;
            case SchemaParticle.ALL:
                children = ensureStateMachine(partImpl.getParticleChildren());
                // adjust canskip if all children are skippable
                canskip = true;
                for (int i = 0; !canskip && i <  children.length; i++)
                {
                    if (!(children[i]).isSkippable())
                        canskip = false;
                }
                // bubble up nondeterministic bit
                for (int i = 0; deterministic && i <  children.length; i++)
                {
                    if (!((SchemaParticleImpl)children[i]).isDeterministic())
                        deterministic = false;
                }
                // compute start and excludeNext sets, verify deterministic
                for (int i = 0; i <  children.length; i++)
                {
                    if (deterministic && !start.isDisjoint((children[i]).acceptedStartNames()))
                        deterministic = false;
                    start.addAll((children[i]).acceptedStartNames());
                    excludenext.addAll(((SchemaParticleImpl)children[i]).getExcludeNextSet());
                }
                if (canskip)
                    excludenext.addAll(start);
                break;
            default:
                throw new IllegalStateException("Unrecognized schema particle");
        }
        // apply looping logic
        BigInteger minOccurs = partImpl.getMinOccurs();
        BigInteger maxOccurs = partImpl.getMaxOccurs();
        boolean canloop = (maxOccurs == null || maxOccurs.compareTo(BigInteger.ONE)  > 0);
        boolean varloop = (maxOccurs == null || minOccurs.compareTo(maxOccurs) <  0);
        if (canloop && deterministic && !excludenext.isDisjoint(start))
        {
            // we have a possible looping nondeterminism.
            // let's take some time now to see if it's actually caused
            // by non-unique-particle-attribute or not.
            QNameSet suspectSet = excludenext.intersect(start);
            // compute the set of all particles that could start this group
            Map startMap = new HashMap();
            particlesMatchingStart(partImpl, suspectSet, startMap, new QNameSetBuilder());
            // compute the set of all particles that could have been repeated rather than ending this group
            Map afterMap = new HashMap();
            particlesMatchingAfter(partImpl, suspectSet, afterMap, new QNameSetBuilder(), true);
            // see if we can find a member of after that is not a member of start
            // if we can, then particle attribution is not unique
            deterministic = afterMapSubsumedByStartMap(startMap, afterMap);
        }
        if (varloop)
            excludenext.addAll(start);
        canskip = canskip || minOccurs.signum() == 0;
        partImpl.setTransitionRules(start.toQNameSet(), canskip);
        partImpl.setTransitionNotes(excludenext.toQNameSet(), deterministic);
}

 static SchemaProperty buildUseProperty(SchemaField use,
    SchemaType owner) 
{
        SchemaPropertyImpl sPropImpl = new SchemaPropertyImpl();
        sPropImpl.setName(use.getName());
        sPropImpl.setContainerTypeRef(owner.getRef());
        sPropImpl.setTypeRef(use.getType().getRef());
        sPropImpl.setAttribute(use.isAttribute());
        sPropImpl.setDefault(use.isDefault() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER);
        sPropImpl.setFixed(use.isFixed() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER);
        sPropImpl.setNillable(use.isNillable() ? SchemaProperty.CONSISTENTLY : SchemaProperty.NEVER);
        sPropImpl.setDefaultText(use.getDefaultText());
        sPropImpl.setMinOccurs(use.getMinOccurs());
        sPropImpl.setMaxOccurs(use.getMaxOccurs());
        if (use instanceof SchemaLocalElementImpl)
        {
            SchemaLocalElementImpl elt = (SchemaLocalElementImpl)use;
            sPropImpl.setAcceptedNames(elt.acceptedStartNames());
        }
        return sPropImpl;
}

 static SchemaParticle[] ensureStateMachine(SchemaParticle[] children) 
{
        for (int i = 0; i <  children.length; i++)
        {
            buildStateMachine(children[i]);
        }
        return children;
}

 static SchemaParticle extendContentModel(SchemaParticle baseContentModel,
    SchemaParticle extendedContentModel,
    XmlObject parseTree) 
{
        // http://www.w3.org/TR/xmlschema-1/#element-complexContent::extension
        // 2.1 If the �explicit content� is empty, then the {content type} of the type definition �resolved� to by the �actual value� of the base [attribute]
        if (extendedContentModel == null)
            return baseContentModel;
        // 2.2 If the type definition �resolved� to by the �actual value� of the base [attribute] has a {content type} of empty, then a pair of mixed or elementOnly (determined as per clause 1.2.1 above) and the �explicit content� itself;
        if (baseContentModel == null)
            return extendedContentModel;
        // 2.3 otherwise a pair of mixed or elementOnly (determined as per clause 1.2.1 above) and a particle whose properties are as follows:
        SchemaParticleImpl sPart = new SchemaParticleImpl();
        sPart.setParticleType(SchemaParticle.SEQUENCE);
        List accumulate = new ArrayList();
        addMinusPointlessParticles(accumulate, baseContentModel, SchemaParticle.SEQUENCE);
        addMinusPointlessParticles(accumulate, extendedContentModel, SchemaParticle.SEQUENCE);
        sPart.setMinOccurs(BigInteger.ONE);
        sPart.setMaxOccurs(BigInteger.ONE);
        sPart.setParticleChildren((SchemaParticle[])
                accumulate.toArray(new SchemaParticle[accumulate.size()]));
        return filterPointlessParticlesAndVerifyAllParticles(sPart, parseTree);
}

 static Map extractElementModel(SchemaType sType) 
{
        Map elementModel = new HashMap();
        if (sType != null)
        {
            SchemaProperty[] sProps = sType.getProperties();
            for (int i = 0; i <  sProps.length; i++)
            {
                if (sProps[i].isAttribute())
                    continue;
                elementModel.put(sProps[i].getName(),
                                 sProps[i].getType());
            }
        }
        return elementModel;
}

 static BigInteger extractMaxOccurs(AllNNI allNNI) 
{
        if (allNNI == null)
            return BigInteger.ONE;
        if (allNNI.instanceType().getPrimitiveType().getBuiltinTypeCode() == SchemaType.BTC_DECIMAL)
            return ((XmlInteger)allNNI).getBigIntegerValue();
        else
            return null;
}

 static BigInteger extractMinOccurs(XmlNonNegativeInteger nni) 
{
        if (nni == null)
            return BigInteger.ONE;
        BigInteger result = nni.getBigIntegerValue();
        if (result == null)
            return BigInteger.ONE;
        return result;
}

 static SchemaParticle filterPointlessParticlesAndVerifyAllParticles(SchemaParticle part,
    XmlObject parseTree) 
{
        if (part.getMaxOccurs() != null && part.getMaxOccurs().signum() == 0)
            return null;
        switch (part.getParticleType())
        {
            case SchemaParticle.SEQUENCE:
            case SchemaParticle.ALL:
                if (part.getParticleChildren().length == 0)
                    return null;
                if (part.isSingleton() && part.countOfParticleChild() == 1)
                    return part.getParticleChild(0);
                break;
            case SchemaParticle.CHOICE:
                if (part.getParticleChildren().length == 0 &&
                    part.getMinOccurs().compareTo(BigInteger.ZERO) == 0)
                    return null;
                if (part.isSingleton() && part.countOfParticleChild() == 1)
                    return part.getParticleChild(0);
                break;
            case SchemaParticle.ELEMENT:
            case SchemaParticle.WILDCARD:
                return part;
            default:
                assert(false);
                throw new IllegalStateException();
        }
        boolean isAll = part.getParticleType() == SchemaParticle.ALL;
        if (isAll)
        {
            // http://www.w3.org/TR/xmlschema-1/#cos-all-limited
            if (part.getMaxOccurs() == null || part.getMaxOccurs().compareTo(BigInteger.ONE)  > 0)
            {
                // An all group must have maxOccurs < = 1
                // KHK: review
                StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$IN_MIN_MAX_1_PARTICLE, null, parseTree);
            }
        }
        for (int i = 0; i <  part.countOfParticleChild(); i++)
        {
            SchemaParticle child = part.getParticleChild(i);
            if (child.getParticleType() == SchemaParticle.ALL)
            {
                // An all group is only allowed at the top level of the content model
                // KHK: review
                StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$IN_COMPLEX_TYPE_DEF_PARTICLE, null, parseTree);
            }
            else if (isAll && (child.getParticleType() != SchemaParticle.ELEMENT || child.getMaxOccurs() == null || child.getMaxOccurs().compareTo(BigInteger.ONE)  > 0))
            {
                // An all group can contain only element particles with maxOccurs < = 1
                // KHK: review
                StscState.get().error(XmlErrorCodes.ALL_GROUP_LIMITED$CHILD_PARTICLES_MAX_LTE_1, null, parseTree);
            }
        }
        return part;
}

 public static Group getContentModel(ComplexType parseCt) 
{
        if (parseCt.getAll() != null)
            return parseCt.getAll();
        if (parseCt.getSequence() != null)
            return parseCt.getSequence();
        if (parseCt.getChoice() != null)
            return parseCt.getChoice();
        if (parseCt.getGroup() != null)
            return parseCt.getGroup();
        return null;
}

 public static Group getContentModel(ComplexRestrictionType parseRest) 
{
        if (parseRest.getAll() != null)
            return parseRest.getAll();
        if (parseRest.getSequence() != null)
            return parseRest.getSequence();
        if (parseRest.getChoice() != null)
            return parseRest.getChoice();
        if (parseRest.getGroup() != null)
            return parseRest.getGroup();
        return null;
}

 public static Group getContentModel(ExtensionType parseExt) 
{
        if (parseExt.getAll() != null)
            return parseExt.getAll();
        if (parseExt.getSequence() != null)
            return parseExt.getSequence();
        if (parseExt.getChoice() != null)
            return parseExt.getChoice();
        if (parseExt.getGroup() != null)
            return parseExt.getGroup();
        return null;
}

 static Schema getSchema(XmlObject o) 
{
        XmlCursor c = o.newCursor();
        try
        {
            while ( c.toParent() )
            {
                o = c.getObject();
                if (o.schemaType().equals(Schema.type))
                    return (Schema) o;
            }
        }
        finally
        {
            c.dispose();
        }
        return null;
}

 static  void mergeProperties(SchemaPropertyImpl into,
    SchemaProperty from,
    boolean asSequence) 
{
        // minoccur, maxoccur
        BigInteger minOccurs = into.getMinOccurs();
        BigInteger maxOccurs = into.getMaxOccurs();
        if (asSequence)
        {
            minOccurs = minOccurs.add(from.getMinOccurs());
            if (maxOccurs != null)
                maxOccurs = (from.getMaxOccurs() == null ? null :
                                  maxOccurs.add(from.getMaxOccurs()));
        }
        else
        {
            minOccurs = minOccurs.min(from.getMinOccurs());
            if (maxOccurs != null)
                maxOccurs = (from.getMaxOccurs() == null ? null :
                                maxOccurs.max(from.getMaxOccurs()));
        }
        into.setMinOccurs(minOccurs);
        into.setMaxOccurs(maxOccurs);
        // nillable, default, fixed
        if (from.hasNillable() != into.hasNillable())
            into.setNillable(SchemaProperty.VARIABLE);
        if (from.hasDefault() != into.hasDefault())
            into.setDefault(SchemaProperty.VARIABLE);
        if (from.hasFixed() != into.hasFixed())
            into.setFixed(SchemaProperty.VARIABLE);
        // default value
        if (into.getDefaultText() != null)
        {
            if (from.getDefaultText() == null ||
                !into.getDefaultText().equals(from.getDefaultText()))
                into.setDefaultText(null);
        }
}

 static  void resolveBasicComplexType(SchemaTypeImpl sImpl) 
{
        List anonymousTypes = new ArrayList();
        ComplexType parseTree = (ComplexType)sImpl.getParseObject();
        String targetNamespace = sImpl.getTargetNamespace();
        boolean chameleon = (sImpl.getChameleonNamespace() != null);
        Group parseGroup = getContentModel(parseTree);
        if (sImpl.isRedefinition())
        {
            StscState.get().error(XmlErrorCodes.SCHEMA_REDEFINE$EXTEND_OR_RESTRICT,
                new Object[] { "< complexType >" }, parseTree);
            // recovery: oh well.
        }
        int particleCode = translateParticleCode(parseGroup);
        // used to ensure consistency (doesn't become part of the result)
        Map elementModel = new LinkedHashMap();
        // build content model and anonymous types
        SchemaParticle contentModel = translateContentModel(sImpl,
            parseGroup, targetNamespace, chameleon,
            sImpl.getElemFormDefault(), sImpl.getAttFormDefault(),
            particleCode, anonymousTypes, elementModel, false, null);
        // detect the nonempty "all" case (empty < all > doesn't count - it needs to be eliminated to match XSD test cases)
        boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL;
        // build attr model and anonymous types
        SchemaAttributeModelImpl attrModel = new SchemaAttributeModelImpl();
        translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(),
            anonymousTypes, sImpl, null, attrModel, null, true, null);
        // summarize wildcard information
        WildcardResult wcElt = summarizeEltWildcards(contentModel);
        WildcardResult wcAttr = summarizeAttrWildcards(attrModel);
        // build state machine and verify that content model is deterministic
        if (contentModel != null)
        {
            buildStateMachine(contentModel);
            if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic())
                StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseGroup);
        }
        // build property model
        // emitDBG("Building content Model for " + sImpl);
        Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl);
        // add attribute property model
        Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl);
        // figure out content type
        int complexVariety =
            parseTree.getMixed()
                ? SchemaType.MIXED_CONTENT
                : contentModel == null
                    ? SchemaType.EMPTY_CONTENT
                    : SchemaType.ELEMENT_CONTENT;
        // now fill in the actual schema type implementation
        sImpl.setBaseTypeRef(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef());
        sImpl.setBaseDepth(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getBaseDepth() + 1);
        sImpl.setDerivationType(SchemaType.DT_EXTENSION);
        sImpl.setComplexTypeVariety(complexVariety);
        sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll);
        sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes));
        sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards);
}

 static  void resolveCcExtension(SchemaTypeImpl sImpl,
    ExtensionType parseTree,
    boolean mixed) 
{
        SchemaType baseType;
        StscState state = StscState.get();
        String targetNamespace = sImpl.getTargetNamespace();
        boolean chameleon = (sImpl.getChameleonNamespace() != null);
        if (parseTree.getBase() == null)
        {
            // KHK: s4s
            state.error("A complexContent must define a base type", XmlErrorCodes.MISSING_BASE, parseTree);
            baseType = null; // recovery: no inheritance.
        }
        else
        {
            if (sImpl.isRedefinition())
            {
                baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl);
                if (baseType != null && !baseType.getName().equals(sImpl.getName()))
                {
                    state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE,
                        new Object[] { "< complexType >",
                                       QNameHelper.pretty(baseType.getName()),
                                       QNameHelper.pretty(sImpl.getName())
                        },
                        parseTree);
                }
            }
            else
            {
                baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace);
            }
            if (baseType == null)
                state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true);
        }
        // Recursion
        if (baseType != null)
        {
            if (!StscResolver.resolveType((SchemaTypeImpl)baseType))
                baseType = null; // circular dependency: no inheritance
        }
        if (baseType != null && baseType.isSimpleType())
        {
            state.recover(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$COMPLEX_CONTENT,
                new Object[] { QNameHelper.pretty(baseType.getName()) },
                parseTree.xgetBase());
            baseType = null; // recovery: no inheritance.
        }
        if (baseType != null && baseType.finalExtension())
        {
            state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$FINAL,
                new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) },
                parseTree.xgetBase());
            // recovery: just keep going
        }
        // get base content model
        SchemaParticle baseContentModel = (baseType == null ? null : baseType.getContentModel());
        // TODO: attribute model also
        List anonymousTypes = new ArrayList();
        Map baseElementModel = extractElementModel(baseType);
        Group parseEg = getContentModel(parseTree);
        if (baseType != null &&
            (baseType.getContentType() == SchemaType.SIMPLE_CONTENT))
        if (parseEg != null)
        {
            // if this type has complexContent, baseType is complexType
            // but with non-empty simpleContent then this type cannot
            // add extra elements
            state.recover(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$EXTENDING_SIMPLE_CONTENT,
                new Object[] { QNameHelper.pretty(baseType.getName()) },
                parseTree.xgetBase());
            baseType = null; // recovery: no inheritance.
        }
        else
        {
            // No extra elements, the type is a complex type with simple content
            resolveScExtensionPart2(sImpl, baseType, parseTree, targetNamespace, chameleon);
            return;
        }
        // build extension model
        SchemaParticle extensionModel = translateContentModel(sImpl,
            parseEg, targetNamespace, chameleon,
            sImpl.getElemFormDefault(), sImpl.getAttFormDefault(),
            translateParticleCode(parseEg), anonymousTypes, baseElementModel, false, null);
        // apply rule #2 near http://www.w3.org/TR/xmlschema-1/#c-mve: empty ext model - > mixed taken from base
        if (extensionModel == null && !mixed)
            mixed = (baseType != null && baseType.getContentType() == SchemaType.MIXED_CONTENT);
        // apply Derivation Valid (Extension) rule 1.4.2.2
        if (baseType != null && (baseType.getContentType() != SchemaType.EMPTY_CONTENT) &&
                ((baseType.getContentType() == SchemaType.MIXED_CONTENT) != mixed))
        {
            state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$BOTH_ELEMEMENT_OR_MIXED, null, parseTree.xgetBase());
            // recovery: just keep going
        }
        // detect the "all" base case
        if (baseType != null && baseType.hasAllContent() && extensionModel != null)
        {
            // KHK: which rule? cos-particle-extend.2 or cos-all-limited.1.2.  I think the limited one.
            state.error("Cannot extend a type with 'all' content model", XmlErrorCodes.CANNOT_EXTEND_ALL, parseTree.xgetBase());
            extensionModel = null; // recovery: drop extension
        }
        // build content model and anonymous types
        SchemaParticle contentModel = extendContentModel(baseContentModel, extensionModel, parseTree);
        // detect the nonempty "all" case (empty < all > doesn't count - it needs to be eliminated to match XSD test cases)
        boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL;
        // build attr model and anonymous types
        SchemaAttributeModelImpl attrModel;
        if (baseType == null)
            attrModel = new SchemaAttributeModelImpl();
        else
            attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel());
        translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(),
            anonymousTypes, sImpl, null, attrModel, baseType, true, null);
        // summarize wildcard information
        WildcardResult wcElt = summarizeEltWildcards(contentModel);
        WildcardResult wcAttr = summarizeAttrWildcards(attrModel);
        // build state machine and verify that content model is deterministic
        if (contentModel != null)
        {
            buildStateMachine(contentModel);
            if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic())
                StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseEg);
        }
        // build property model
        // emitDBG("Building content Model for " + sImpl);
        Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl);
        // add attribute property model
        Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl);
        // compute empty/element/mixed
        int complexVariety;
        if (contentModel == null && baseType != null &&
            baseType.getContentType() == SchemaType.SIMPLE_CONTENT)
        {
            complexVariety = SchemaType.SIMPLE_CONTENT;
            sImpl.setContentBasedOnTypeRef(baseType.getContentBasedOnType().getRef());
        }
        else
            complexVariety = ( mixed ? SchemaType.MIXED_CONTENT :
            (contentModel == null ? SchemaType.EMPTY_CONTENT : SchemaType.ELEMENT_CONTENT));
        // now fill in the actual schema type implementation
        if (baseType == null)
            baseType = XmlObject.type;
        sImpl.setBaseTypeRef(baseType.getRef());
        sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1);
        sImpl.setDerivationType(SchemaType.DT_EXTENSION);
        sImpl.setComplexTypeVariety(complexVariety);
        sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll);
        sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes));
        sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards);
}

 static  void resolveCcRestriction(SchemaTypeImpl sImpl,
    ComplexRestrictionType parseTree,
    boolean mixed) 
{
        StscState state = StscState.get();
        String targetNamespace = sImpl.getTargetNamespace();
        boolean chameleon = (sImpl.getChameleonNamespace() != null);
        // BUGBUG: NOT YET REALLY IMPLEMENTED
        // throw new RuntimeException("Not yet implemented.");
        SchemaType baseType;
        if (parseTree.getBase() == null)
        {
            // KHK: s4s
            state.error("A complexContent must define a base type", XmlErrorCodes.MISSING_BASE, parseTree);
            baseType = null; // recovery: no inheritance.
        }
        else
        {
            if (sImpl.isRedefinition())
            {
                baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl);
                if (baseType != null && !baseType.getName().equals(sImpl.getName()))
                {
                    state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE,
                        new Object[] { "< complexType >",
                                       QNameHelper.pretty(baseType.getName()),
                                       QNameHelper.pretty(sImpl.getName())
                        },
                        parseTree);
                }
            }
            else
            {
                baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace);
            }
            if (baseType == null)
                state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true);
        }
        if (baseType == null)
            baseType = BuiltinSchemaTypeSystem.ST_ANY_TYPE;
        if (baseType != null && baseType.finalRestriction())
        {
            state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$FINAL,
                new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) },
                parseTree.xgetBase());
            // recovery: just keep going
        }
        // Recursion
        if (baseType != null)
        {
            if (!StscResolver.resolveType((SchemaTypeImpl)baseType))
                baseType = null; // circular dependency: no inheritance
        }
        List anonymousTypes = new ArrayList();
        Group parseEg = getContentModel(parseTree);
        // detect the "all" case
        int particleCode = translateParticleCode(parseEg);
        // used to ensure consistency (doesn't become part of the result)
        Map elementModel = new LinkedHashMap();
        // build content model and anonymous types
        SchemaParticle contentModel = translateContentModel( sImpl,
            parseEg, targetNamespace, chameleon,
            sImpl.getElemFormDefault(), sImpl.getAttFormDefault(),
            particleCode, anonymousTypes, elementModel, false, null);
        // detect the nonempty "all" case (empty < all > doesn't count - it needs to be eliminated to match XSD test cases)
        boolean isAll = contentModel != null && contentModel.getParticleType() == SchemaParticle.ALL;
        // build attr model and anonymous types
        SchemaAttributeModelImpl attrModel;
        if (baseType == null)
            attrModel = new SchemaAttributeModelImpl();
        else
            attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel());
        translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(),
            anonymousTypes, sImpl, null, attrModel, baseType, false, null);
        // summarize wildcard information
        WildcardResult wcElt = summarizeEltWildcards(contentModel);
        WildcardResult wcAttr = summarizeAttrWildcards(attrModel);
        // build state machine and verify that content model is deterministic
        if (contentModel != null)
        {
            buildStateMachine(contentModel);
            if (!StscState.get().noUpa() && !((SchemaParticleImpl)contentModel).isDeterministic())
                StscState.get().error(XmlErrorCodes.UNIQUE_PARTICLE_ATTRIBUTION, null, parseEg);
        }
        // build property model
        // emitDBG("Building content Model for " + sImpl);
        Map elementPropertyModel = buildContentPropertyModelByQName(contentModel, sImpl);
        // add attribute property model
        Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl);
        // compute empty/element/mixed
        int complexVariety = (contentModel == null ? SchemaType.EMPTY_CONTENT :
            (mixed ? SchemaType.MIXED_CONTENT : SchemaType.ELEMENT_CONTENT));
        // now fill in the actual schema type implementation
        sImpl.setBaseTypeRef(baseType.getRef());
        sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1);
        sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
        sImpl.setComplexTypeVariety(complexVariety);
        sImpl.setContentModel(contentModel, attrModel, elementPropertyModel, attributePropertyModel, isAll);
        sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes));
        sImpl.setWildcardSummary(wcElt.typedWildcards, wcElt.hasWildcards, wcAttr.typedWildcards, wcAttr.hasWildcards);
}

 public static  void resolveComplexType(SchemaTypeImpl sImpl) 
{
        ComplexType parseCt = (ComplexType)sImpl.getParseObject();
        StscState state = StscState.get();
        Schema schema = getSchema(parseCt);
        // Set abstract & final flags
        boolean abs = parseCt.isSetAbstract() ? parseCt.getAbstract() : false;
        boolean finalExt = false;
        boolean finalRest = false;
        boolean finalList = false;
        boolean finalUnion = false;
        Object ds = null;
        if (parseCt.isSetFinal())
        {
            ds = parseCt.getFinal();
        }
        // Inspect the final default attribute on the schema
        else if (schema != null && schema.isSetFinalDefault())
        {
            ds = schema.getFinalDefault();
        }
        if (ds != null)
        {
            if (ds instanceof String && ds.equals("#all"))
            {
                // #ALL value
                finalExt = finalRest = finalList = finalUnion = true;
            }
            else if (ds instanceof List)
            {
                if (((List)ds).contains("extension"))
                    finalExt = true;
                if (((List)ds).contains("restriction"))
                    finalRest = true;
// Since complex types don't participate in list and unions, these can remain
// false.  Perhaps we should throw an error.
//                if (((List)ds).contains("list"))
//                    finalList = true;
//
//                if (((List)ds).contains("union"))
//                    finalUnion = true;
            }
        }
        sImpl.setAbstractFinal(abs, finalExt, finalRest, finalList, finalUnion);
        // Set block flags
        boolean blockExt = false;
        boolean blockRest = false;
        Object block = null;
        if (parseCt.isSetBlock())
            block = parseCt.getBlock();
        else if (schema != null && schema.isSetBlockDefault())
            block = schema.getBlockDefault();
        if (block != null)
        {
            if (block instanceof String && block.equals("#all"))
            {
                // #ALL value
                blockExt = blockRest = true;
            }
            else if (block instanceof List)
            {
                if (((List)block).contains("extension"))
                    blockExt = true;
                if (((List)block).contains("restriction"))
                    blockRest = true;
            }
        }
        sImpl.setBlock(blockExt, blockRest);
        // Verify: have simpleContent, complexContent, or direct stuff
        ComplexContentDocument.ComplexContent parseCc = parseCt.getComplexContent();
        SimpleContentDocument.SimpleContent parseSc = parseCt.getSimpleContent();
        Group parseGroup = getContentModel(parseCt);
        int count =
                (parseCc != null ? 1 : 0) +
                (parseSc != null ? 1 : 0) +
                (parseGroup != null ? 1 : 0);
        if (count  > 1)
        {
            // KHK: s4s should catch this?
            state.error("A complex type must define either a content model, " +
                      "or a simpleContent or complexContent derivation: " +
                      "more than one found.",
                    XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseCt);
            // recovery: treat it as the first of complexContent, simpleContent, model
            parseGroup = null;
            if (parseCc != null && parseSc != null)
                parseSc = null;
        }
        if (parseCc != null)
        {
            // KHK: s4s should catch this?
            if (parseCc.getExtension() != null && parseCc.getRestriction() != null)
                state.error("Restriction conflicts with extension", XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseCc.getRestriction());
            // Mixed can be specified in two places: the rules are that Cc wins over Ct if present
            // http://www.w3.org/TR/xmlschema-1/#c-mve
            boolean mixed = parseCc.isSetMixed() ? parseCc.getMixed() : parseCt.getMixed();
            if (parseCc.getExtension() != null)
                resolveCcExtension(sImpl, parseCc.getExtension(), mixed);
            else if (parseCc.getRestriction() != null)
                resolveCcRestriction(sImpl, parseCc.getRestriction(), mixed);
            else
            {
                // KHK: s4s should catch this?
                state.error("Missing restriction or extension", XmlErrorCodes.MISSING_RESTRICTION_OR_EXTENSION, parseCc);
                resolveErrorType(sImpl);
            }
            return;
        }
        else if (parseSc != null)
        {
            // KHK: s4s should catch this?
            if (parseSc.getExtension() != null && parseSc.getRestriction() != null)
                state.error("Restriction conflicts with extension", XmlErrorCodes.REDUNDANT_CONTENT_MODEL, parseSc.getRestriction());
            if (parseSc.getExtension() != null)
                resolveScExtension(sImpl, parseSc.getExtension());
            else if (parseSc.getRestriction() != null)
                resolveScRestriction(sImpl, parseSc.getRestriction());
            else
            {
                // KHK: s4s should catch this?
                state.error("Missing restriction or extension", XmlErrorCodes.MISSING_RESTRICTION_OR_EXTENSION, parseSc);
                resolveErrorType(sImpl);
            }
            return;
        }
        else
            resolveBasicComplexType(sImpl);
}

 static  void resolveErrorType(SchemaTypeImpl sImpl) 
{
        throw new RuntimeException("This type of error recovery not yet implemented.");
}

 static  void resolveScExtension(SchemaTypeImpl sImpl,
    SimpleExtensionType parseTree) 
{
        SchemaType baseType;
        StscState state = StscState.get();
        String targetNamespace = sImpl.getTargetNamespace();
        boolean chameleon = (sImpl.getChameleonNamespace() != null);
        if (parseTree.getBase() == null)
        {
            state.error("A simpleContent extension must define a base type", XmlErrorCodes.MISSING_BASE, parseTree);
            // recovery: extends ANY_SIMPLE type
            baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
        }
        else
        {
            if (sImpl.isRedefinition())
            {
                baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl);
                if (baseType != null && !baseType.getName().equals(sImpl.getName()))
                {
                    state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE,
                        new Object[] { "< simpleType >",
                                       QNameHelper.pretty(baseType.getName()),
                                       QNameHelper.pretty(sImpl.getName())
                        },
                        parseTree);
                }
            }
            else
            {
                baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace);
            }
            if (baseType == null)
            {
                state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true);
                // recovery: extends ANY_SIMPLE type
                baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
            }
        }
        // Recursion
        StscResolver.resolveType((SchemaTypeImpl)baseType);
        if (!baseType.isSimpleType() && baseType.getContentType() != SchemaType.SIMPLE_CONTENT)
        {
            // src-ct.2: complex types with simple content can only extend simple types
            state.error(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$SIMPLE_CONTENT,
                new Object[] { QNameHelper.pretty(baseType.getName()) } ,
                parseTree);
            // recovery: extends ANY_SIMPLE type
            baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
        }
        if (baseType != null && baseType.finalExtension())
        {
            state.error(XmlErrorCodes.COMPLEX_TYPE_EXTENSION$FINAL,
                    new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) },
                    parseTree.xgetBase());
            // recovery: just keep going
        }
        resolveScExtensionPart2(sImpl, baseType, parseTree, targetNamespace, chameleon);
}

 static  void resolveScExtensionPart2(SchemaTypeImpl sImpl,
    SchemaType baseType,
    ExtensionType parseTree,
    String targetNamespace,
    boolean chameleon) 
{
        // build attr model and anonymous types
        List anonymousTypes = new ArrayList();
        SchemaAttributeModelImpl attrModel;
        attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel());
        translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(), anonymousTypes, sImpl, null, attrModel, baseType, true, null);
        // summarize wildcard information
        WildcardResult wcAttr = summarizeAttrWildcards(attrModel);
        // add attribute property model
        Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl);
        // now fill in the actual schema type implementation
        sImpl.setBaseTypeRef(baseType.getRef());
        sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1);
        sImpl.setContentBasedOnTypeRef(baseType.getRef());
        sImpl.setDerivationType(SchemaType.DT_EXTENSION);
        sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes));
        sImpl.setWildcardSummary(QNameSet.EMPTY, false, wcAttr.typedWildcards, wcAttr.hasWildcards);
        sImpl.setComplexTypeVariety(SchemaType.SIMPLE_CONTENT);
        sImpl.setContentModel(null, attrModel, null, attributePropertyModel, false);
        sImpl.setSimpleTypeVariety(baseType.getSimpleVariety());
        sImpl.setPrimitiveTypeRef(baseType.getPrimitiveType() == null ? null : baseType.getPrimitiveType().getRef());
        switch (sImpl.getSimpleVariety())
        {
            case SchemaType.LIST:
                sImpl.setListItemTypeRef(baseType.getListItemType().getRef());
                break;
            case SchemaType.UNION:
                sImpl.setUnionMemberTypeRefs(makeRefArray(Arrays.asList(baseType.getUnionMemberTypes())));
                break;
        }
        // deal with facets
        StscSimpleTypeResolver.resolveFacets(sImpl, null, (SchemaTypeImpl)baseType);
        // now compute our intrinsic properties
        StscSimpleTypeResolver.resolveFundamentalFacets(sImpl);
}

 static  void resolveScRestriction(SchemaTypeImpl sImpl,
    SimpleRestrictionType parseTree) 
{
        SchemaType baseType;
        SchemaType contentType = null;
        StscState state = StscState.get();
        String targetNamespace = sImpl.getTargetNamespace();
        boolean chameleon = (sImpl.getChameleonNamespace() != null);
        List anonymousTypes = new ArrayList();
        if (parseTree.getSimpleType() != null)
        {
            LocalSimpleType typedef = parseTree.getSimpleType();
            SchemaTypeImpl anonType = StscTranslator.
                translateAnonymousSimpleType(typedef, targetNamespace, chameleon,
                    sImpl.getElemFormDefault(), sImpl.getAttFormDefault(),
                    anonymousTypes, sImpl);
            contentType = anonType;
        }
        if (parseTree.getBase() == null)
        {
            state.error("A simpleContent restriction must define a base type", XmlErrorCodes.MISSING_BASE, parseTree);
            // recovery: extends ANY_SIMPLE type
            baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
        }
        else
        {
            if (sImpl.isRedefinition())
            {
                baseType = state.findRedefinedGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), sImpl);
                if (baseType != null && !baseType.getName().equals(sImpl.getName()))
                {
                    state.error(XmlErrorCodes.SCHEMA_REDEFINE$SAME_TYPE,
                        new Object[] { "< simpleType >",
                                       QNameHelper.pretty(baseType.getName()),
                                       QNameHelper.pretty(sImpl.getName())
                        },
                        parseTree);
                }
            }
            else
            {
                baseType = state.findGlobalType(parseTree.getBase(), sImpl.getChameleonNamespace(), targetNamespace);
            }
            if (baseType == null)
            {
                state.notFoundError(parseTree.getBase(), SchemaType.TYPE, parseTree.xgetBase(), true);
                // recovery: extends ANY_SIMPLE type
                baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
            }
        }
        // Recursion
        StscResolver.resolveType((SchemaTypeImpl)baseType);
        if (contentType != null)
            StscResolver.resolveType((SchemaTypeImpl)contentType);
        else
            contentType = baseType;
        if (baseType.isSimpleType())
        {
            // src-ct.2: complex types with simple content cannot restrict simple types
            state.recover(XmlErrorCodes.COMPLEX_TYPE_PROPERTIES$SIMPLE_TYPE_EXTENSION,
                new Object[] { QNameHelper.pretty(baseType.getName()) },
                parseTree);
            // recovery: extends ANY_SIMPLE type
            baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
        }
        else if (baseType.getContentType() != SchemaType.SIMPLE_CONTENT &&
                 contentType == null)
        {
            // recovery: extends ANY_SIMPLE type
            baseType = BuiltinSchemaTypeSystem.ST_ANY_SIMPLE;
        }
        if (baseType != null && baseType.finalRestriction())
        {
            state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$FINAL,
                    new Object[] { QNameHelper.pretty(baseType.getName()), QNameHelper.pretty(sImpl.getName()) },
                    parseTree.xgetBase());
            // recovery: just keep going
        }
        // build attr model and anonymous types
        SchemaAttributeModelImpl attrModel;
        if (baseType == null)
            attrModel = new SchemaAttributeModelImpl();
        else
            attrModel = new SchemaAttributeModelImpl(baseType.getAttributeModel());
        translateAttributeModel(parseTree, targetNamespace, chameleon, sImpl.getAttFormDefault(),
            anonymousTypes, sImpl, null, attrModel, baseType, false, null);
        // summarize wildcard information
        WildcardResult wcAttr = summarizeAttrWildcards(attrModel);
        // add attribute property model
        Map attributePropertyModel = buildAttributePropertyModelByQName(attrModel, sImpl);
        // now fill in the actual schema type implementation
        sImpl.setBaseTypeRef(baseType.getRef());
        sImpl.setBaseDepth(((SchemaTypeImpl)baseType).getBaseDepth() + 1);
        sImpl.setContentBasedOnTypeRef(contentType.getRef());
        sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
        sImpl.setAnonymousTypeRefs(makeRefArray(anonymousTypes));
        sImpl.setWildcardSummary(QNameSet.EMPTY, false, wcAttr.typedWildcards, wcAttr.hasWildcards);
        sImpl.setComplexTypeVariety(SchemaType.SIMPLE_CONTENT);
        sImpl.setContentModel(null, attrModel, null, attributePropertyModel, false);
        sImpl.setSimpleTypeVariety(contentType.getSimpleVariety());
        sImpl.setPrimitiveTypeRef(contentType.getPrimitiveType() == null ? null : contentType.getPrimitiveType().getRef());
        switch (sImpl.getSimpleVariety())
        {
            case SchemaType.LIST:
                sImpl.setListItemTypeRef(contentType.getListItemType().getRef());
                break;
            case SchemaType.UNION:
                sImpl.setUnionMemberTypeRefs(makeRefArray(Arrays.asList(contentType.getUnionMemberTypes())));
                break;
        }
        // deal with facets
        StscSimpleTypeResolver.resolveFacets(sImpl, parseTree, (SchemaTypeImpl) contentType);
        // now compute our intrinsic properties
        StscSimpleTypeResolver.resolveFundamentalFacets(sImpl);
}

 static StscComplexTypeResolver.WildcardResult summarizeAttrWildcards(SchemaAttributeModel attrModel) 
{
        if (attrModel.getWildcardProcess() == SchemaAttributeModel.NONE)
            return new WildcardResult(QNameSet.EMPTY, false);
        if (attrModel.getWildcardProcess() == SchemaAttributeModel.SKIP)
            return new WildcardResult(QNameSet.EMPTY, true);
        return new WildcardResult(attrModel.getWildcardSet(), true);
}

 static StscComplexTypeResolver.WildcardResult summarizeEltWildcards(SchemaParticle contentModel) 
{
        if (contentModel == null)
        {
            return new WildcardResult(QNameSet.EMPTY, false);
        }
        switch (contentModel.getParticleType())
        {
            case SchemaParticle.ALL:
            case SchemaParticle.SEQUENCE:
            case SchemaParticle.CHOICE:
                QNameSetBuilder set = new QNameSetBuilder();
                boolean hasWildcards = false;
                for (int i = 0; i <  contentModel.countOfParticleChild(); i++)
                {
                    WildcardResult inner = summarizeEltWildcards(contentModel.getParticleChild(i));
                    set.addAll(inner.typedWildcards);
                    hasWildcards |= inner.hasWildcards;
                }
                return new WildcardResult(set.toQNameSet(), hasWildcards);
            case SchemaParticle.WILDCARD:
                return new WildcardResult(
                    (contentModel.getWildcardProcess() == SchemaParticle.SKIP) ?
                    QNameSet.EMPTY : contentModel.getWildcardSet(), true);
                // otherwise fallthrough
            default:
                return new WildcardResult(QNameSet.EMPTY, false);
        }
}

 static int translateAttributeCode(QName currentName) 
{
        Integer result = (Integer)attributeCodeMap.get(currentName);
        if (result == null)
            return 0;
        return result.intValue();
}

 static  void translateAttributeModel(XmlObject parseTree,
    String targetNamespace,
    boolean chameleon,
    String formDefault,
    List anonymousTypes,
    SchemaType outerType,
    Set seenAttributes,
    SchemaAttributeModelImpl result,
    SchemaType baseType,
    boolean extension,
    SchemaAttributeGroupImpl redefinitionFor) 
{
        StscState state = StscState.get();
        if (seenAttributes == null)
            seenAttributes = new HashSet();
        boolean seenWildcard = false;
        boolean seenRedefinition = false;
        SchemaAttributeModel baseModel = null;
        if (baseType != null)
            baseModel = baseType.getAttributeModel();
        XmlCursor cur = parseTree.newCursor();
        for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling())
        {
            switch (translateAttributeCode(cur.getName()))
            {
                case ATTRIBUTE_CODE:
                {
                    Attribute xsdattr = (Attribute)cur.getObject();
                    SchemaLocalAttribute sAttr = StscTranslator.translateAttribute(xsdattr, targetNamespace, formDefault, chameleon, anonymousTypes, outerType, baseModel, true);
                    if (sAttr == null)
                        continue;
                    if (seenAttributes.contains(sAttr.getName()))
                    {
                        state.error(XmlErrorCodes.COMPLEX_TYPE_PROPERTIES$DUPLICATE_ATTRIBUTE,
                            new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) },
                            xsdattr.xgetName());
                        continue; // ignore the duplicate attr
                    }
                    seenAttributes.add(sAttr.getName());
                    if (baseModel != null)
                    {
                        SchemaLocalAttribute baseAttr = baseModel.getAttribute(sAttr.getName());
                        if (baseAttr == null)
                        {
                            if (!extension)
                            {
                                if (!baseModel.getWildcardSet().contains(sAttr.getName()))
                                    state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_IN_BASE_WILDCARD_SET,
                                        new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) }, xsdattr);
                            }
                        }
                        else
                        {
                            if (extension)
                            {
                                // KHK: cos-ct-extends.1.2?
                                if (sAttr.getUse() == SchemaLocalAttribute.PROHIBITED)
                                    state.error("An extension cannot prohibit an attribute from the base type; use restriction instead.", XmlErrorCodes.DUPLICATE_ATTRIBUTE_NAME, xsdattr.xgetUse());
                            }
                            else
                            {
                                if (sAttr.getUse() != SchemaLocalAttribute.REQUIRED)
                                {
                                    if (baseAttr.getUse() == SchemaLocalAttribute.REQUIRED)
                                        state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_REQUIRED,
                                            new Object[] { QNameHelper.pretty(sAttr.getName()), QNameHelper.pretty(outerType.getName()) }, xsdattr);
                                    if (sAttr.getUse() == SchemaLocalAttribute.PROHIBITED)
                                        result.removeProhibitedAttribute(sAttr.getName());
                                }
                            }
                        }
                    }
                    if (sAttr.getUse() != SchemaLocalAttribute.PROHIBITED)
                    {
                        result.addAttribute(sAttr);
                    }
                    else
                    {
                        // attribute is prohibited. If it has an anonymous type remove
                        // it from the list (this will prevent inclusion of any anonymous
                        // types defined within the prohibited attribute which would
                        // otherwise attempt to refer to the prohibited attribute at
                        // save() time)
                        SchemaType attrType = sAttr.getType();
                        if (anonymousTypes != null && anonymousTypes.contains(attrType))
                        {
                            anonymousTypes.remove(attrType);
                        }
                    }
                    if (sAttr.getDefaultText() != null && !sAttr.isFixed())
                    {
                        if (sAttr.getUse() != SchemaLocalAttribute.OPTIONAL)
                            state.error(XmlErrorCodes.SCHEMA_ATTR$DEFAULT_AND_USE_OPTIONAL,
                                new Object[] { QNameHelper.pretty(sAttr.getName()) }, xsdattr);
                    }
                    break;
                }
                case ANY_ATTRIBUTE_CODE:
                {
                    Wildcard xsdwc = (Wildcard)cur.getObject();
                    if (seenWildcard)
                    {
                        // KHK: ?
                        state.error("Only one attribute wildcard allowed", XmlErrorCodes.DUPLICATE_ANY_ATTRIBUTE, xsdwc);
                        continue; // ignore the extra wildcard
                    }
                    seenWildcard = true;
                    NamespaceList nsList = xsdwc.xgetNamespace();
                    String nsText;
                    if (nsList == null)
                        nsText = "##any";
                    else
                        nsText = nsList.getStringValue();
                    QNameSet wcset = QNameSet.forWildcardNamespaceString(nsText, targetNamespace);
                    if (baseModel != null && !extension)
                    {
                        if (baseModel.getWildcardSet() == null)
                        {
                            state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$BASE_HAS_ATTR_WILDCARD, null, xsdwc);
                            continue; // ignore the extra wildcard
                        }
                        else if (!baseModel.getWildcardSet().containsAll(wcset))
                        {
                            state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ATTR_WILDCARD_SUBSET,
                                new Object[] { nsText }, xsdwc);
                            continue; // ignore the restriction
                        }
                    }
                    int wcprocess = translateWildcardProcess(xsdwc.xgetProcessContents());
                    if (result.getWildcardProcess() == SchemaAttributeModel.NONE)
                    {
                        result.setWildcardSet(wcset);
                        result.setWildcardProcess(wcprocess);
                    }
                    else
                    {
                        if (extension)
                        {
                            result.setWildcardSet(wcset.union(result.getWildcardSet()));
                            result.setWildcardProcess(wcprocess);
                        }
                        else
                        {
                            result.setWildcardSet(wcset.intersect(result.getWildcardSet()));
                            // keep old process
                        }
                    }
                    break;
                }
                case ATTRIBUTE_GROUP_CODE:
                {
                    AttributeGroupRef xsdag = (AttributeGroupRef)cur.getObject();
                    QName ref = xsdag.getRef();
                    if (ref == null)
                    {
                        // KHK: s4s
                        state.error("Attribute group reference must have a ref attribute", XmlErrorCodes.ATTRIBUTE_GROUP_MISSING_REF, xsdag);
                        continue;
                    }
                    SchemaAttributeGroupImpl group;
                    if (redefinitionFor != null)
                    {
                        group = state.findRedefinedAttributeGroup(ref, chameleon ? targetNamespace : null, redefinitionFor);
                        if (group != null &&
                            redefinitionFor.getName().equals(group.getName()))
                        {
                            if (seenRedefinition)
                                state.error(XmlErrorCodes.SCHEMA_REDEFINE$ATTR_GROUP_SELF_REF,
                                    new Object[] { QNameHelper.pretty(redefinitionFor.getName()) }, xsdag);
                            seenRedefinition = true;
                        }
                    }
                    else
                    {
                        group = state.findAttributeGroup(ref, chameleon ? targetNamespace : null, targetNamespace);
                    }
                    if (group == null)
                    {
                        state.notFoundError(ref, SchemaType.ATTRIBUTE_GROUP, xsdag.xgetRef(), true);
                        continue;
                    }
                    if (state.isProcessing(group))
                    {
                        state.error(XmlErrorCodes.SCHEMA_ATTR_GROUP$SELF_REF,
                            new Object[] { QNameHelper.pretty(group.getName()) },group.getParseObject());
                        continue;
                    }
                    String subTargetNamespace = targetNamespace;
                    if (group.getTargetNamespace() != null)
                    {
                        subTargetNamespace = group.getTargetNamespace();
                        chameleon = group.getChameleonNamespace() != null;
                    }
                    state.startProcessing(group);
                    SchemaAttributeGroupImpl nestedRedefinitionFor = null;
                    if (group.isRedefinition())
                        nestedRedefinitionFor = group;
                    translateAttributeModel(group.getParseObject(), subTargetNamespace, chameleon,
                        group.getFormDefault(),
                        anonymousTypes, outerType, seenAttributes, result, baseType,
                        extension, nestedRedefinitionFor);
                    state.finishProcessing(group);
                    break;
                }
                default:
                {
                    continue; // skip things that are not part of the attribute model.
                }
            }
        }
        // If this is restriction and no wildcard was present, then
        // we have to erase the inherited wildcards
        if (!extension && !seenWildcard)
        {
            result.setWildcardSet(null);
            result.setWildcardProcess(SchemaAttributeModel.NONE);
        }
}

 static SchemaParticle translateContentModel(SchemaType outerType,
    XmlObject parseTree,
    String targetNamespace,
    boolean chameleon,
    String elemFormDefault,
    String attFormDefault,
    int particleCode,
    List anonymousTypes,
    Map elementModel,
    boolean allowElt,
    StscComplexTypeResolver.RedefinitionForGroup redefinitionFor) 
{
        if (parseTree == null || particleCode == 0)
            return null;
        StscState state = StscState.get();
        // emitDBG("Translating content model for " + outerType);
        // indentDBG();
        assert(particleCode != 0);
        boolean hasChildren = false;
        BigInteger minOccurs;
        BigInteger maxOccurs;
        SchemaModelGroupImpl group = null;
        SchemaParticleImpl sPart;
        if (particleCode == SchemaParticle.ELEMENT)
        {
            if (!allowElt)
                state.error("Must be a sequence, choice or all here", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, parseTree);
            // TODO: detect substitution group for this element and construct a choice
            LocalElement parseElt = (LocalElement)parseTree;
            sPart = StscTranslator.translateElement(parseElt, targetNamespace, chameleon,
                elemFormDefault, attFormDefault, anonymousTypes, outerType);
            if (sPart == null)
                return null;
            minOccurs = extractMinOccurs(parseElt.xgetMinOccurs());
            maxOccurs = extractMaxOccurs(parseElt.xgetMaxOccurs());
            SchemaType oldType = (SchemaType)elementModel.get(sPart.getName());
            if (oldType == null)
            {
                elementModel.put(sPart.getName(), sPart.getType());
            }
            else if (!sPart.getType().equals(oldType))
            {
                state.error(XmlErrorCodes.ELEM_CONSISTANT, new Object[] { QNameHelper.pretty(sPart.getName()) }, parseTree);
                return null;
            }
        }
        else if (particleCode == SchemaParticle.WILDCARD)
        {
            if (!allowElt)
                state.error("Must be a sequence, choice or all here", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, parseTree);
            Any parseAny = (Any)parseTree;
            sPart = new SchemaParticleImpl();
            sPart.setParticleType(SchemaParticle.WILDCARD);
            QNameSet wcset;
            NamespaceList nslist = parseAny.xgetNamespace();
            if (nslist == null)
                wcset = QNameSet.ALL;
            else
                wcset = QNameSet.forWildcardNamespaceString(nslist.getStringValue(), targetNamespace);
            sPart.setWildcardSet(wcset);
            sPart.setWildcardProcess(translateWildcardProcess(parseAny.xgetProcessContents()));
            minOccurs = extractMinOccurs(parseAny.xgetMinOccurs());
            maxOccurs = extractMaxOccurs(parseAny.xgetMaxOccurs());
        }
        else
        {
            Group parseGroup = (Group)parseTree;
            sPart = new SchemaParticleImpl();
            // grab min/maxOccurs before dereferencign group ref
            minOccurs = extractMinOccurs(parseGroup.xgetMinOccurs());
            maxOccurs = extractMaxOccurs(parseGroup.xgetMaxOccurs());
            if (particleCode == MODEL_GROUP_CODE)
            {
                QName ref = parseGroup.getRef();
                if (ref == null)
                {
                    // KHK: s4s
                    state.error("Group reference must have a ref attribute", XmlErrorCodes.GROUP_MISSING_REF, parseTree);
                    return null;
                }
                if (redefinitionFor != null)
                {
                    group = state.findRedefinedModelGroup(ref, chameleon ? targetNamespace : null, redefinitionFor.getGroup());
                    if (group != null && group.getName().equals(redefinitionFor.getGroup().getName()))
                    {
                        if (redefinitionFor.isSeenRedefinition())
                            state.error(XmlErrorCodes.SCHEMA_REDEFINE$GROUP_SELF_REF,
                                new Object[] { QNameHelper.pretty(group.getName()) }, parseTree);
                        if (!BigInteger.ONE.equals(maxOccurs) || !BigInteger.ONE.equals(minOccurs))
                            state.error(XmlErrorCodes.SCHEMA_REDEFINE$GROUP_SELF_REF_MIN_MAX_1,
                                new Object[] { QNameHelper.pretty(group.getName()) }, parseTree);
                        redefinitionFor.setSeenRedefinition(true);
                    }
                }
                else
                {
                    group = state.findModelGroup(ref, chameleon ? targetNamespace : null, targetNamespace);
                }
                if (group == null)
                {
                    state.notFoundError(ref, SchemaType.MODEL_GROUP, ((Group)parseTree).xgetRef(), true);
                    return null;
                }
                if (state.isProcessing(group))
                {
                    state.error(XmlErrorCodes.MODEL_GROUP_PROPERTIES$CIRCULAR,
                        new Object[] { QNameHelper.pretty(group.getName()) }, group.getParseObject());
                    return null;
                }
                // no go to the child.
                XmlCursor cur = group.getParseObject().newCursor();
                for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling())
                {
                    particleCode = translateParticleCode(cur.getName());
                    if (particleCode != 0)
                    {
                        parseTree = parseGroup = (Group)cur.getObject();
                        break;
                    }
                }
                if (particleCode == 0)
                {
                    // KHK: s4s
                    state.error("Model group " + QNameHelper.pretty(group.getName()) + " is empty", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, group.getParseObject());
                    return null;
                }
                if (particleCode != SchemaParticle.ALL && particleCode != SchemaParticle.SEQUENCE && particleCode != SchemaParticle.CHOICE)
                {
                    // KHK: s4s
                    state.error("Model group " + QNameHelper.pretty(group.getName()) + " is not a sequence, all, or choice", XmlErrorCodes.EXPLICIT_GROUP_NEEDED, group.getParseObject());
                }
                String newTargetNamespace = group.getTargetNamespace();
                if (newTargetNamespace != null)
                    targetNamespace = newTargetNamespace;
                elemFormDefault = group.getElemFormDefault();
                attFormDefault = group.getAttFormDefault();
                chameleon = group.getChameleonNamespace() != null;
            }
            switch (particleCode)
            {
                case SchemaParticle.ALL:
                case SchemaParticle.SEQUENCE:
                case SchemaParticle.CHOICE:
                    sPart.setParticleType(particleCode);
                    hasChildren = true;
                    break;
                default:
                    assert(false);
                    throw new IllegalStateException();
            }
        }
        if (maxOccurs != null && minOccurs.compareTo(maxOccurs)  > 0)
        {
            state.error(XmlErrorCodes.PARTICLE_PROPERTIES$MIN_LTE_MAX, null, parseTree);
            maxOccurs = minOccurs; // remedy: pin max up to min
        }
        if (maxOccurs != null && maxOccurs.compareTo(BigInteger.ONE) <  0)
        {
            state.warning(XmlErrorCodes.PARTICLE_PROPERTIES$MAX_GTE_1, null, parseTree);
            // remove from the list of anonymous types if it was added
            anonymousTypes.remove(sPart.getType());
            return null; // maxOccurs == minOccurs == 0, same as no particle at all.
        }
        sPart.setMinOccurs(minOccurs);
        sPart.setMaxOccurs(maxOccurs);
        if (group != null)
        {
            state.startProcessing(group);
            redefinitionFor = null;
            if (group.isRedefinition())
                redefinitionFor = new RedefinitionForGroup(group);
        }
        if (hasChildren)
        {
            XmlCursor cur = parseTree.newCursor();
            List accumulate = new ArrayList();
            for (boolean more = cur.toFirstChild(); more; more = cur.toNextSibling())
            {
                int code = translateParticleCode(cur.getName());
                if (code == 0)
                    continue;
                addMinusPointlessParticles(accumulate,
                        translateContentModel(outerType,
                            cur.getObject(), targetNamespace, chameleon,
                            elemFormDefault, attFormDefault, code,
                            anonymousTypes, elementModel, true, redefinitionFor),
                        sPart.getParticleType());
            }
            sPart.setParticleChildren((SchemaParticle[])
                    accumulate.toArray(new SchemaParticle[accumulate.size()]));
            cur.dispose();
        }
        SchemaParticle result = filterPointlessParticlesAndVerifyAllParticles(sPart, parseTree);
        if (group != null)
        {
            state.finishProcessing(group);
        }
        // outdentDBG();
        return result;
}

 static int translateWildcardProcess(ProcessContents process) 
{
        if (process == null)
            return SchemaParticle.STRICT;
        String processValue = process.getStringValue();
        if ("lax".equals(processValue))
            return SchemaParticle.LAX;
        if ("skip".equals(processValue))
            return SchemaParticle.SKIP;
        return SchemaParticle.STRICT;
}