Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.thaiopensource.relaxng.impl;
  
 
 
 
 
   private final SchemaBuilderImpl parent;
   private boolean hadError = false;
   private final SubParser subParser;
   private final SchemaPatternBuilder pb;
   private final String inheritNs;
   private final ErrorHandler eh;
   private final OpenIncludes openIncludes;
   static final Localizer localizer = new Localizer(SchemaBuilderImpl.class);
 
   static class OpenIncludes {
     final String uri;
     final OpenIncludes parent;
 
     OpenIncludes(String uriOpenIncludes parent) {
       this. = uri;
       this. = parent;
     }
   }
 
   static public Pattern parse(Parseable parseable,
                               ErrorHandler eh,
                               DatatypeLibraryFactory datatypeLibraryFactory,
                               SchemaPatternBuilder pb,
                               boolean isAttributesPattern)
           throws IncorrectSchemaExceptionIOExceptionSAXException {
     try {
       SchemaBuilderImpl sb = new SchemaBuilderImpl(parseable,
                                                    eh,
                                                    new BuiltinDatatypeLibraryFactory(datatypeLibraryFactory),
                                                    pb);
       ParsedPattern pp = parseable.parse(sbnew RootScope(sb));
       if (isAttributesPattern)
         pp = sb.wrapAttributesPattern(pp);
       return sb.expandPattern((Pattern)pp);
     }
     catch (IllegalSchemaException e) {
       throw new IncorrectSchemaException();
     }
     catch (BuildException e) {
       throw unwrapBuildException(e);
     }
   }
 
 
                                               SchemaPatternBuilder pb)
           throws SAXException {
     final SchemaBuilderImpl sb = new SchemaBuilderImpl(parser,
                                                        eh,
                                                        new BuiltinDatatypeLibraryFactory(dlf),
                                                        pb);
    final ParsedPatternFuture pf = parser.installHandlers(xrsbnew RootScope(sb));
    return new PatternFuture() {
      public Pattern getPattern(boolean isAttributesPatternthrows IncorrectSchemaExceptionSAXExceptionIOException {
        try {
          ParsedPattern pp = pf.getParsedPattern();
          if (isAttributesPattern)
            pp = sb.wrapAttributesPattern(pp);
          return sb.expandPattern((Pattern)pp);
        }
        catch (IllegalSchemaException e) {
          throw new IncorrectSchemaException();
        }
        catch (BuildException e) {
          throw unwrapBuildException(e);
        }
      }
    };
  }
    Throwable t = e.getCause();
    if (t instanceof IOException)
      throw (IOException)t;
    if (t instanceof RuntimeException)
      return (RuntimeException)t;
    if (t instanceof IllegalSchemaException)
      throw new IncorrectSchemaException();
    if (t instanceof SAXException)
      throw (SAXException)t;
    if (t instanceof Exception)
      throw new SAXException((Exception)t);
    throw new SAXException(t.getClass().getName() + " thrown");
  }
    // XXX where can we get a locator from?
    return makeElement(makeAnyName(nullnull), patternnullnull);
  }
    if (!) {
      try {
        pattern.checkRecursion(0);
        pattern = pattern.expand();
        pattern.checkRestrictions(.nullnull);
        if (!)
          return pattern;
      }
      catch (SAXParseException e) {
        error(e);
      }
      catch (SAXException e) {
        throw new BuildException(e);
      }
      catch (RestrictionViolationException e) {
        if (e.getName() != null)
          error(e.getMessageId(), NameFormatter.format(e.getName()), e.getLocator());
        else
          error(e.getMessageId(), e.getLocator());
      }
    }
    throw new IllegalSchemaException();
  }
  private SchemaBuilderImpl(SubParser subParser,
                            ErrorHandler eh,
                            DatatypeLibraryFactory datatypeLibraryFactory,
                            SchemaPatternBuilder pb) {
    this. = null;
    this. = subParser;
    this. = eh;
    this. = datatypeLibraryFactory;
    this. = pb;
    this. = "";
    this. = null;
  }
  private SchemaBuilderImpl(String inheritNs,
                            String uri,
                            SchemaBuilderImpl parent) {
    this. = parent;
    this. = parent.subParser;
    this. = parent.eh;
    this. = parent.datatypeLibraryFactory;
    this. = parent.pb;
    this. = parent.resolveInherit(inheritNs);
    this. = new OpenIncludes(uriparent.openIncludes);
  }
  public ParsedPattern makeChoice(ParsedPattern[] patternsint nPatternsLocation locAnnotations anno)
          throws BuildException {
    if (nPatterns <= 0)
      throw new IllegalArgumentException();
    Pattern result = (Pattern)patterns[0];
    for (int i = 1; i < nPatternsi++)
      result = .makeChoice(result, (Pattern)patterns[i]);
    return result;
  }
  public ParsedPattern makeInterleave(ParsedPattern[] patternsint nPatternsLocation locAnnotations anno)
          throws BuildException {
    if (nPatterns <= 0)
      throw new IllegalArgumentException();
    Pattern result = (Pattern)patterns[0];
    for (int i = 1; i < nPatternsi++)
      result = .makeInterleave(result, (Pattern)patterns[i]);
    return result;
  }
  public ParsedPattern makeGroup(ParsedPattern[] patternsint nPatternsLocation locAnnotations anno)
          throws BuildException {
    if (nPatterns <= 0)
      throw new IllegalArgumentException();
    Pattern result = (Pattern)patterns[0];
    for (int i = 1; i < nPatternsi++)
      result = .makeGroup(result, (Pattern)patterns[i]);
    return result;
  }
          throws BuildException {
    return .makeOneOrMore((Pattern)p);
  }
          throws BuildException {
    return .makeZeroOrMore((Pattern)p);
  }
          throws BuildException {
    return .makeOptional((Pattern)p);
  }
          throws BuildException {
    return .makeList((Pattern)p, (Locator)loc);
  }
          throws BuildException {
    return .makeMixed((Pattern)p);
  }
  public ParsedPattern makeEmpty(Location locAnnotations anno) {
    return .makeEmpty();
  }
  public ParsedPattern makeNotAllowed(Location locAnnotations anno) {
    return .makeUnexpandedNotAllowed();
  }
  public ParsedPattern makeText(Location locAnnotations anno) {
    return .makeText();
  }
    return .makeError();
  }
    return new ErrorNameClass();
  }
          throws BuildException {
    if (messageId != null)
      error(messageId, (Locator)loc);
    return .makeAttribute((NameClass)nc, (Pattern)p, (Locator)loc);
  }
          throws BuildException {
    return .makeElement((NameClass)nc, (Pattern)p, (Locator)loc);
  }
  private class DummyDataPatternBuilder implements DataPatternBuilder {
    public void addParam(String nameString valueContext contextString nsLocation locAnnotations anno)
            throws BuildException {
    }
    public void annotation(ParsedElementAnnotation ea)
            throws BuildException {
    }
    public ParsedPattern makePattern(Location locAnnotations anno)
            throws BuildException {
      return .makeError();
    }
    public ParsedPattern makePattern(ParsedPattern exceptLocation locAnnotations anno)
            throws BuildException {
      return .makeError();
    }
  }
  private class ValidationContextImpl implements ValidationContext {
    private final ValidationContext vc;
    private final String ns;
      this. = vc;
      this. = ns.length() == 0 ? null : ns;
    }
    public String resolveNamespacePrefix(String prefix) {
      String result = prefix.length() == 0 ?  : .resolveNamespacePrefix(prefix);
      if (result == ) {
        if (.length() == 0)
          return null;
        return ;
      }
      return result;
    }
    public String getBaseUri() {
      return .getBaseUri();
    }
    public boolean isUnparsedEntity(String entityName) {
      return .isUnparsedEntity(entityName);
    }
    public boolean isNotation(String notationName) {
      return .isNotation(notationName);
    }
  }
  private class DataPatternBuilderImpl implements DataPatternBuilder {
    private final DatatypeBuilder dtb;
      this. = dtb;
    }
    public void addParam(String nameString valueContext contextString nsLocation locAnnotations anno)
            throws BuildException {
      try {
        .addParameter(namevaluenew ValidationContextImpl(contextns));
      }
      catch (DatatypeException e) {
	String detail = e.getMessage();
        int pos = e.getIndex();
        String displayedParam;
        if (pos == .)
          displayedParam = null;
        else
          displayedParam = displayParam(valuepos);
        if (displayedParam != null) {
          if (detail != null)
            error("invalid_param_detail_display"detaildisplayedParam, (Locator)loc);
          else
            error("invalid_param_display"displayedParam, (Locator)loc);
        }
	else if (detail != null)
	  error("invalid_param_detail"detail, (Locator)loc);
	else
	  error("invalid_param", (Locator)loc);
      }
    }
    public void annotation(ParsedElementAnnotation ea)
            throws BuildException {
    }
    String displayParam(String valueint pos) {
      if (pos < 0)
        pos = 0;
      else if (pos > value.length())
        pos = value.length();
      return .message("display_param"value.substring(0, pos), value.substring(pos));
    }
    public ParsedPattern makePattern(Location locAnnotations anno)
            throws BuildException {
      try {
        return .makeData(.createDatatype());
      }
      catch (DatatypeException e) {
	String detail = e.getMessage();
	if (detail != null)
	  error("invalid_params_detail"detail, (Locator)loc);
	else
	  error("invalid_params", (Locator)loc);
        return .makeError();
      }
    }
    public ParsedPattern makePattern(ParsedPattern exceptLocation locAnnotations anno)
            throws BuildException {
      try {
        return .makeDataExcept(.createDatatype(), (Pattern)except, (Locator)loc);
      }
      catch (DatatypeException e) {
	String detail = e.getMessage();
	if (detail != null)
	  error("invalid_params_detail"detail, (Locator)loc);
	else
	  error("invalid_params", (Locator)loc);
        return .makeError();
      }
    }
  }
  public DataPatternBuilder makeDataPatternBuilder(String datatypeLibraryString typeLocation loc)
          throws BuildException {
    if (dl == null)
      error("unrecognized_datatype_library"datatypeLibrary, (Locator)loc);
    else {
      try {
        return new DataPatternBuilderImpl(dl.createDatatypeBuilder(type));
      }
      catch (DatatypeException e) {
	String detail = e.getMessage();
	if (detail != null)
	  error("unsupported_datatype_detail"datatypeLibrarytypedetail, (Locator)loc);
	else
	  error("unrecognized_datatype"datatypeLibrarytype, (Locator)loc);
      }
    }
    return new DummyDataPatternBuilder();
  }
  public ParsedPattern makeValue(String datatypeLibraryString typeString valueContext contextString ns,
                                 Location locAnnotations annothrows BuildException {
    if (dl == null)
      error("unrecognized_datatype_library"datatypeLibrary, (Locator)loc);
    else {
      try {
        DatatypeBuilder dtb = dl.createDatatypeBuilder(type);
        try {
          Datatype dt = dtb.createDatatype();
          Object obj = dt.createValue(valuenew ValidationContextImpl(contextns));
          if (obj != null)
            return .makeValue(dtobj);
          error("invalid_value"value, (Locator)loc);
        }
        catch (DatatypeException e) {
          String detail = e.getMessage();
          if (detail != null)
            error("datatype_requires_param_detail"detail, (Locator)loc);
          else
            error("datatype_requires_param", (Locator)loc);
        }
      }
      catch (DatatypeException e) {
        error("unrecognized_datatype"datatypeLibrarytype, (Locator)loc);
      }
    }
    return .makeError();
  }
  static class GrammarImpl implements GrammarDivIncludedGrammar {
    private final SchemaBuilderImpl sb;
    private final Hashtable defines;
    private final RefPattern startRef;
    private final Scope parent;
    private GrammarImpl(SchemaBuilderImpl sbScope parent) {
      this. = sb;
      this. = parent;
      this. = new Hashtable();
      this. = new RefPattern(null);
    }
    protected GrammarImpl(SchemaBuilderImpl sbGrammarImpl g) {
      this. = sb;
       = g.parent;
       = g.startRef;
       = g.defines;
    }
    public ParsedPattern endGrammar(Location locAnnotations annothrows BuildException {
      for (Enumeration enum = .keys();
           enum.hasMoreElements();) {
        String name = (String)enum.nextElement();
        RefPattern rp = (RefPattern).get(name);
        if (rp.getPattern() == null) {
          .error("reference_to_undefined"namerp.getRefLocator());
          rp.setPattern(..makeError());
        }
      }
      Pattern start = .getPattern();
      if (start == null) {
        .error("missing_start_element", (Locator)loc);
        start = ..makeError();
      }
      return start;
    }
    public void endDiv(Location locAnnotations annothrows BuildException {
      // nothing to do
    }
    public ParsedPattern endIncludedGrammar(Location locAnnotations annothrows BuildException {
      return null;
    }
    public void define(String nameGrammarSection.Combine combineParsedPattern patternLocation locAnnotations anno)
            throws BuildException {
      define(lookup(name), combinepatternloc);
    }
    private void define(RefPattern rpGrammarSection.Combine combineParsedPattern patternLocation loc)
            throws BuildException {
      switch (rp.getReplacementStatus()) {
      case .:
        if (combine == null) {
          if (rp.isCombineImplicit()) {
            if (rp.getName() == null)
              .error("duplicate_start", (Locator)loc);
            else
              .error("duplicate_define"rp.getName(), (Locator)loc);
          }
          else
            rp.setCombineImplicit();
        }
        else {
          byte combineType = (combine ==  ? . : .);
          if (rp.getCombineType() != .
              && rp.getCombineType() != combineType) {
            if (rp.getName() == null)
              .error("conflict_combine_start", (Locator)loc);
            else
              .error("conflict_combine_define"rp.getName(), (Locator)loc);
          }
          rp.setCombineType(combineType);
        }
        Pattern p = (Pattern)pattern;
        if (rp.getPattern() == null)
          rp.setPattern(p);
        else if (rp.getCombineType() == .)
          rp.setPattern(..makeInterleave(rp.getPattern(), p));
        else
          rp.setPattern(..makeChoice(rp.getPattern(), p));
        break;
        break;
        break;
      }
    }
    public void topLevelAnnotation(ParsedElementAnnotation eathrows BuildException {
    }
    public void topLevelComment(CommentList commentsthrows BuildException {
    }
    private RefPattern lookup(String name) {
      if (name == )
        return ;
      return lookup1(name);
    }
    private RefPattern lookup1(String name) {
      RefPattern p = (RefPattern).get(name);
      if (p == null) {
        p = new RefPattern(name);
        .put(namep);
      }
      return p;
    }
    public ParsedPattern makeRef(String nameLocation locAnnotations annothrows BuildException {
      RefPattern p = lookup1(name);
      if (p.getRefLocator() == null && loc != null)
        p.setRefLocator((Locator)loc);
      return p;
    }
    public ParsedPattern makeParentRef(String nameLocation locAnnotations annothrows BuildException {
      if ( == null) {
        .error("parent_ref_outside_grammar", (Locator)loc);
        return .makeErrorPattern();
      }
      return .makeRef(namelocanno);
    }
    public Div makeDiv() {
      return this;
    }
    public Include makeInclude() {
      return new IncludeImpl(this);
    }
  }
  static class RootScope implements Scope {
    private final SchemaBuilderImpl sb;
      this. = sb;
    }
    public ParsedPattern makeParentRef(String nameLocation locAnnotations annothrows BuildException {
      .error("parent_ref_outside_grammar", (Locator)loc);
      return .makeErrorPattern();
    }
    public ParsedPattern makeRef(String nameLocation locAnnotations annothrows BuildException {
      .error("ref_outside_grammar", (Locator)loc);
      return .makeErrorPattern();
    }
  }
  static class Override {
    Override(RefPattern prpOverride next) {
      this. = prp;
      this. = next;
    }
    final RefPattern prp;
    final Override next;
    byte replacementStatus;
  }
  private static class IncludeImpl implements IncludeDiv {
    private final SchemaBuilderImpl sb;
    private Override overrides;
    private final GrammarImpl grammar;
    private IncludeImpl(SchemaBuilderImpl sbGrammarImpl grammar) {
      this. = sb;
      this. = grammar;
    }
    public void define(String nameGrammarSection.Combine combineParsedPattern patternLocation locAnnotations anno)
            throws BuildException {
      RefPattern rp = .lookup(name);
       = new Override(rp);
      .define(rpcombinepatternloc);
    }
    public void endDiv(Location locAnnotations annothrows BuildException {
      // nothing to do
    }
    public void topLevelAnnotation(ParsedElementAnnotation eathrows BuildException {
      // nothing to do
    }
    public void topLevelComment(CommentList commentsthrows BuildException {
    }
    public Div makeDiv() {
      return this;
    }
    public void endInclude(String uriString ns,
                           Location locAnnotations annothrows BuildException {
      for (OpenIncludes inc = .;
           inc != null;
           inc = inc.parent) {
        if (inc.uri.equals(uri)) {
          .error("recursive_include"uri, (Locator)loc);
          return;
        }
      }
      for (Override o = o != nullo = o.next) {
        o.replacementStatus = o.prp.getReplacementStatus();
      }
      try {
        SchemaBuilderImpl isb = new SchemaBuilderImpl(nsuri);
        ..parseInclude(uriisbnew GrammarImpl(isb));
        for (Override o = o != nullo = o.next) {
          if (o.prp.getReplacementStatus() == .) {
            if (o.prp.getName() == null)
              .error("missing_start_replacement", (Locator)loc);
            else
              .error("missing_define_replacement"o.prp.getName(), (Locator)loc);
          }
        }
      }
      catch (IllegalSchemaException e) {
        .noteError();
      }
      finally {
        for (Override o = o != nullo = o.next)
          o.prp.setReplacementStatus(o.replacementStatus);
      }
    }
    public Include makeInclude() {
      return null;
    }
  }
  public Grammar makeGrammar(Scope parent) {
    return new GrammarImpl(thisparent);
  }
    return p;
  }
    return nc;
  }
    return p;
  }
    return nc;
  }
  public ParsedPattern commentAfter(ParsedPattern pCommentList commentsthrows BuildException {
    return p;
  }
    return nc;
  }
  public ParsedPattern makeExternalRef(String uriString nsScope scope,
                                       Location locAnnotations anno)
          throws BuildException {
    for (OpenIncludes inc = ;
         inc != null;
         inc = inc.parent) {
      if (inc.uri.equals(uri)) {
        error("recursive_include"uri, (Locator)loc);
        return .makeError();
      }
    }
    try {
      return .parseExternal(urinew SchemaBuilderImpl(nsurithis), scope);
    }
    catch (IllegalSchemaException e) {
      noteError();
      return .makeError();
    }
  }
  public ParsedNameClass makeChoice(ParsedNameClass[] nameClassesint nNameClassesLocation locAnnotations anno) {
    if (nNameClasses <= 0)
      throw new IllegalArgumentException();
    NameClass result = (NameClass)nameClasses[0];
    for (int i = 1; i < nNameClassesi++)
      result = new ChoiceNameClass(result, (NameClass)nameClasses[i]);
    return result;
  }
  public ParsedNameClass makeName(String nsString localNameString prefixLocation locAnnotations anno) {
    return new SimpleNameClass(new Name(resolveInherit(ns), localName));
  }
  public ParsedNameClass makeNsName(String nsLocation locAnnotations anno) {
    return new NsNameClass(resolveInherit(ns));
  }
  public ParsedNameClass makeNsName(String nsParsedNameClass exceptLocation locAnnotations anno) {
    return new NsNameExceptNameClass(resolveInherit(ns), (NameClass)except);
  }
  public ParsedNameClass makeAnyName(Location locAnnotations anno) {
    return new AnyNameClass();
  }
  public ParsedNameClass makeAnyName(ParsedNameClass exceptLocation locAnnotations anno) {
    return new AnyNameExceptNameClass((NameClass)except);
  }
  private final String resolveInherit(String ns) {
    if (ns == )
      return ;
    return ns;
  }
  private class LocatorImpl implements LocatorLocation {
    private final String systemId;
    private final int lineNumber;
    private final int columnNumber;
    private LocatorImpl(String systemIdint lineNumberint columnNumber) {
      this. = systemId;
      this. = lineNumber;
      this. = columnNumber;
    }
    public String getPublicId() {
      return null;
    }
    public String getSystemId() {
      return ;
    }
    public int getLineNumber() {
      return ;
    }
    public int getColumnNumber() {
      return ;
    }
  }
  public Location makeLocation(String systemIdint lineNumberint columnNumber) {
    return new LocatorImpl(systemIdlineNumbercolumnNumber);
  }
  public Annotations makeAnnotations(CommentList commentsContext context) {
    return this;
  }
                                                               Location locCommentList commentsContext context) {
    return this;
  }
    return this;
  }
  public void addComment(String valueLocation locthrows BuildException {
  }
  public void addAttribute(String nsString localNameString prefixString valueLocation loc) {
    // nothing needed
  }
  public void addElement(ParsedElementAnnotation ea) {
    // nothing needed
  }
  public void addComment(CommentList commentsthrows BuildException {
    // nothing needed
  }
  public void addLeadingComment(CommentList commentsthrows BuildException {
    // nothing needed
  }
  public void addText(String valueLocation locCommentList comments) {
    // nothing needed
  }
    return null;
  }
  public boolean usesComments() {
    return false;
  }
  private void error(SAXParseException messagethrows BuildException {
    noteError();