Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /* Generated By:JavaCC: Do not edit this line. CompactSyntax.java */
   package com.thaiopensource.relaxng.parse.compact;
   
  
  
  
  
  import java.io.Reader;
  import java.net.URL;
  
  public class CompactSyntax implements ContextCompactSyntaxConstants {
    private static final int IN_ELEMENT = 0;
    private static final int IN_ATTRIBUTE = 1;
    private static final int IN_ANY_NAME = 2;
    private static final int IN_NS_NAME = 4;
  
    private String compatibilityPrefix = null;
    private SchemaBuilder sb;
    private String sourceUri;
    private ErrorHandler eh;
    private final Hashtable namespaceTable = new Hashtable();
    private final Hashtable datatypesTable = new Hashtable();
    private boolean hadError = false;
    private static final Localizer localizer = new Localizer(CompactSyntax.class);
    private final Hashtable attributeNameTable = new Hashtable();
    private boolean annotationsIncludeElements = false;
  
    final class LocatedString {
      private final String str;
      private final Token tok;
  
      LocatedString(String strToken tok) {
        this. = str;
        this. = tok;
      }
  
      String getString() {
        return ;
      }
  
      Location getLocation() {
        return makeLocation();
      }
  
      Token getToken() {
        return ;
      }
  
    }
  
    public CompactSyntax(Reader rString sourceUriSchemaBuilder sbErrorHandler eh) {
      this(r);
      this. = sourceUri;
      this. = sb;
      this. = eh;
      // this causes the root pattern to have non-null annotations
      // which is useful because it gives a context to trang
      this. = sb.makeCommentList();
    }
  
    ParsedPattern parse(Scope scopethrows IllegalSchemaException {
      try {
        ParsedPattern p = Input(scope);
        if (!)
          return p;
      }
      catch (ParseException e) {
        error("syntax_error"e.currentToken.next);
      }
      catch (EscapeSyntaxException e) {
     }
     throw new IllegalSchemaException();
   }
 
     try {
       ParsedPattern p = IncludedGrammar(g);
       if (!)
         return p;
     }
     catch (ParseException e) {
       error("syntax_error"e.currentToken.next);
     }
     catch (EscapeSyntaxException e) {
     }
     throw new IllegalSchemaException();
   }
 
   private void checkNsName(int contextLocatedString ns) {
     if ((context & ) != 0)
       error("ns_name_except_contains_ns_name"ns.getToken());
   }
 
   private void checkAnyName(int contextToken t) {
     if ((context & ) != 0)
       error("ns_name_except_contains_any_name"t);
     if ((context & ) != 0)
       error("any_name_except_contains_any_name"t);
   }
 
   private void error(String keyToken tok) {
     doError(.message(key), tok);
   }
 
   private void error(String keyString argToken tok) {
     doError(.message(keyarg), tok);
   }
 
   private void error(String keyString arg1String arg2Token tok) {
     doError(.message(keyarg1arg2), tok);
   }
 
   private void doError(String messageToken tok) {
      = true;
     if ( != null) {
       LocatorImpl loc = new LocatorImpl();
       loc.setLineNumber(tok.beginLine);
       loc.setColumnNumber(tok.beginColumn);
       loc.setSystemId();
       try {
         .error(new SAXParseException(messageloc));
       }
       catch (SAXException se) {
         throw new BuildException(se);
       }
     }
   }
 
     if ( != null) {
       LocatorImpl loc = new LocatorImpl();
       loc.setLineNumber(e.getLineNumber());
       loc.setColumnNumber(e.getColumnNumber());
       loc.setSystemId();
       try {
         .error(new SAXParseException(.message(e.getKey()), loc));
       }
       catch (SAXException se) {
         throw new BuildException(se);
       }
     }
   }
 
   private static String unquote(String s) {
     if (s.length() >= 6 && s.charAt(0) == s.charAt(1)) {
       s = s.replace('\u0000''\n');
       return s.substring(3, s.length() - 3);
     }
     else
       return s.substring(1, s.length() - 1);
   }
 
     return .makeLocation(t.beginLinet.beginColumn);
   }
 
   private static ParsedPattern[] addPattern(ParsedPattern[] patternsint iParsedPattern p) {
     if (i >= patterns.length) {
       ParsedPattern[] oldPatterns = patterns;
       patterns = new ParsedPattern[oldPatterns.length*2];
       System.arraycopy(oldPatterns, 0, patterns, 0, oldPatterns.length);
     }
     patterns[i] = p;
     return patterns;
   }
 
     if ( == null) {
        = "a";
       while (.get() != null)
          =  + "a";
     }
     return ;
   }
 
   public String resolveNamespacePrefix(String prefix) {
     String result = (String).get(prefix);
     if (result.length() == 0)
       return null;
     return result;
   }
 
   public Enumeration prefixes() {
     return .keys();
   }
 
   public String getBaseUri() {
     return ;
   }
 
   public boolean isUnparsedEntity(String entityName) {
     return false;
   }
 
   public boolean isNotation(String notationName) {
     return false;
   }
 
   public Context copy() {
     return this;
   }
 
   private Context getContext() {
     return this;
   }
 
   private CommentList getComments() {
     return getComments(getTopLevelComments());
   }
 
 
   private CommentList getTopLevelComments() {
     CommentList tem = ;
      = null;
     return tem;
   }
 
   private void noteTopLevelComments() {
   }
 
   private void topLevelComments(GrammarSection section) {
     section.topLevelComment(getComments(null));
   }
 
   private Token lastCommentSourceToken = null;
 
   private CommentList getComments(CommentList comments) {
     Token nextToken = getToken(1);
     if ( != nextToken) {
       if ( == null)
          = ;
       do {
         Token t = .;
         if (t != null) {
           while (t.specialToken != null)
             t = t.specialToken;
           if (comments == null)
             comments = .makeCommentList();
           for (; t != nullt = t.next) {
             String s = mungeComment(t.image);
             Location loc = makeLocation(t);
             if (t.next != null
                 && t.next.kind == .) {
               StringBuffer buf = new StringBuffer(s);
               do {
                 t = t.next;
                 buf.append('\n');
                 buf.append(mungeComment(t.image));
               } while (t.next != null
                        && t.next.kind == .);
               s = buf.toString();
             }
             comments.addComment(sloc);
           }
         }
       } while ( != nextToken);
     }
     return comments;
   }
 
     CommentList comments = getComments(null);
     if (comments == null)
       return p;
     return .commentAfter(pcomments);
   }
 
     CommentList comments = getComments(null);
     if (comments == null)
       return nc;
     return .commentAfter(nccomments);
   }
 
   private static String mungeComment(String image) {
     int i = image.indexOf('#') + 1;
     while (i < image.length() && image.charAt(i) == '#')
       i++;
     if (i < image.length() && image.charAt(i) == ' ')
       i++;
     return image.substring(i);
   }
 
     CommentList comments = getComments();
     if (comments == null)
       return null;
     return .makeAnnotations(commentsgetContext());
   }
 
     CommentList comments = getComments();
     if (comments == null)
       return a;
     if (a == null)
       a = .makeAnnotations(nullgetContext());
     a.addComment(comments);
     return a;
   }
 
     CommentList comments = getComments();
     if (comments == null)
       return a;
     if (a == null)
       return .makeAnnotations(commentsgetContext());
     a.addLeadingComment(comments);
     return a;
   }
 
     CommentList comments = getTopLevelComments();
     if (comments == null)
       return null;
     return .makeAnnotations(commentsgetContext());
   }
 
   private void clearAttributeList() {
   }
 
   private void addAttribute(Annotations aString nsString localNameString prefixString valueToken tok) {
     String key = ns + "#" + localName;
     if (.get(key) != null)
       error("duplicate_attribute"nslocalNametok);
     else {
       .put(keykey);
       a.addAttribute(nslocalNameprefixvaluemakeLocation(tok));
     }
   }
 
   private void checkExcept(Token[] except) {
     if (except[0] != null)
       error("except_missing_parentheses"except[0]);
   }
 
   private String lookupPrefix(String prefixToken t) {
     String ns = (String).get(prefix);
     if (ns == null) {
       error("undeclared_prefix"prefixt);
       return "#error";
     }
     return ns;
   }
   private String lookupDatatype(String prefixToken t) {
     String ns = (String).get(prefix);
     if (ns == null) {
       error("undeclared_prefix"prefixt);
       return ""// XXX
     }
     return ns;
   }
   private String resolve(String str) {
     try {
      return new URL(new URL(), str).toString();
     }
     catch (MalformedURLException e) { }
     return str;
   }
 
   final public ParsedPattern Input(Scope scopethrows ParseException {
     Preamble();
     if (jj_2_1(2147483647)) {
       p = TopLevelGrammar(scope);
     } else {
       switch ((==-1)?jj_ntk():) {
       case 1:
       case 10:
       case 17:
       case 18:
       case 19:
       case 26:
       case 27:
       case 28:
       case 31:
       case 32:
       case 33:
       case 34:
       case 35:
       case 36:
       case :
       case :
       case :
       case :
       case :
         p = Expr(truescopenullnull);
                                          p = afterComments(p);
         jj_consume_token(0);
         break;
       default:
         [0] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
   final public void TopLevelLookahead() throws ParseException {
     switch ((==-1)?jj_ntk():) {
     case :
       jj_consume_token(1);
       break;
     case :
     case :
       Identifier();
       switch ((==-1)?jj_ntk():) {
       case 1:
         jj_consume_token(1);
         break;
       case 2:
         jj_consume_token(2);
         break;
       case 3:
         jj_consume_token(3);
         break;
       case 4:
         jj_consume_token(4);
         break;
       default:
         [1] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     case 5:
     case 6:
     case 7:
       break;
     case 1:
       LookaheadBody();
       break;
     case :
       LookaheadDocumentation();
       switch ((==-1)?jj_ntk():) {
       case 1:
         LookaheadBody();
         break;
       default:
         [2] = ;
         ;
       }
       break;
     default:
       [3] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void LookaheadAfterAnnotations() throws ParseException {
     switch ((==-1)?jj_ntk():) {
     case :
     case :
       Identifier();
       switch ((==-1)?jj_ntk():) {
       case 2:
         jj_consume_token(2);
         break;
       case 3:
         jj_consume_token(3);
         break;
       case 4:
         jj_consume_token(4);
         break;
       default:
         [4] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       break;
     case 5:
     case 6:
     case 7:
       break;
     default:
       [5] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void LookaheadGrammarKeyword() throws ParseException {
     switch ((==-1)?jj_ntk():) {
     case 5:
       jj_consume_token(5);
       break;
     case 6:
       jj_consume_token(6);
       break;
     case 7:
       jj_consume_token(7);
       break;
     default:
       [6] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
   }
 
   final public void LookaheadDocumentation() throws ParseException {
     label_1:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
         break;
         break;
       default:
         [7] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
       label_2:
       while (true) {
         switch ((==-1)?jj_ntk():) {
         case :
           ;
           break;
         default:
           [8] = ;
           break label_2;
         }
       }
       switch ((==-1)?jj_ntk():) {
       case :
         ;
         break;
       default:
         [9] = ;
         break label_1;
       }
     }
   }
 
   final public void LookaheadBody() throws ParseException {
     jj_consume_token(1);
     label_3:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 1:
       case 2:
       case 5:
       case 6:
       case 7:
       case 8:
       case 10:
       case 13:
       case 14:
       case 15:
       case 16:
       case 17:
       case 18:
       case 19:
       case 26:
       case 27:
       case 31:
       case 32:
       case 33:
       case 34:
       case 35:
       case 36:
       case :
       case :
       case :
       case :
         ;
         break;
       default:
         [10] = ;
         break label_3;
       }
       switch ((==-1)?jj_ntk():) {
       case :
         break;
       case 5:
       case 6:
       case 7:
       case 10:
       case 13:
       case 14:
       case 15:
       case 16:
       case 17:
       case 18:
       case 19:
       case 26:
       case 27:
       case 31:
       case 32:
       case 33:
       case 34:
       case 35:
       case 36:
       case :
       case :
         UnprefixedName();
         break;
       case 2:
         jj_consume_token(2);
         break;
       case :
         jj_consume_token();
         break;
       case 8:
         jj_consume_token(8);
         break;
       case 1:
         LookaheadBody();
         break;
       default:
         [11] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     jj_consume_token(9);
   }
 
   final public ParsedPattern IncludedGrammar(IncludedGrammar gthrows ParseException {
   Annotations a;
     Preamble();
     if (jj_2_2(2147483647)) {
       a = GrammarBody(gggetTopLevelCommentsAsAnnotations());
     } else {
       switch ((==-1)?jj_ntk():) {
       case 1:
       case 10:
       case :
         a = Annotations();
         jj_consume_token(10);
         jj_consume_token(11);
         a = GrammarBody(gga);
                                                                 topLevelComments(g);
         jj_consume_token(12);
         break;
       default:
         [12] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     p = afterComments(g.endIncludedGrammar(.makeLocation(, 1, 1), a));
     jj_consume_token(0);
     {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern TopLevelGrammar(Scope scopethrows ParseException {
   Grammar g;
     g = .makeGrammar(scope);
     a = GrammarBody(gga);
     p = afterComments(g.endGrammar(.makeLocation(, 1, 1), a));
     jj_consume_token(0);
     {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
   final public void Preamble() throws ParseException {
     label_4:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case 13:
       case 14:
       case 16:
         ;
         break;
       default:
         [13] = ;
         break label_4;
       }
       switch ((==-1)?jj_ntk():) {
       case 13:
       case 14:
         NamespaceDecl();
         break;
       case 16:
         DatatypesDecl();
         break;
       default:
         [14] = ;
         jj_consume_token(-1);
         throw new ParseException();
       }
     }
     if (.get("xsd") == null)
   }
 
   final public void NamespaceDecl() throws ParseException {
   LocatedString prefix = null;
   boolean isDefault = false;
   String namespaceName;
     switch ((==-1)?jj_ntk():) {
     case 13:
       jj_consume_token(13);
       prefix = UnprefixedName();
       break;
     case 14:
       jj_consume_token(14);
                    isDefault = true;
       jj_consume_token(13);
       switch ((==-1)?jj_ntk():) {
       case 5:
       case 6:
       case 7:
       case 10:
       case 13:
       case 14:
       case 15:
       case 16:
       case 17:
       case 18:
       case 19:
       case 26:
       case 27:
       case 31:
       case 32:
       case 33:
       case 34:
       case 35:
       case 36:
       case :
       case :
         prefix = UnprefixedName();
         break;
       default:
         [15] = ;
         ;
       }
       break;
     default:
       [16] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     jj_consume_token(2);
     namespaceName = NamespaceName();
     if (isDefault)
        = namespaceName;
     if (prefix != null) {
       if (prefix.getString().equals("xmlns"))
         error("xmlns_prefix"prefix.getToken());
       else if (prefix.getString().equals("xml")) {
         if (!namespaceName.equals(.))
           error("xml_prefix_bad_uri"prefix.getToken());
       }
       else if (namespaceName.equals(.))
         error("xml_uri_bad_prefix"prefix.getToken());
       else {
            = prefix.getString();
         .put(prefix.getString(), namespaceName);
       }
     }
   }
 
   final public String NamespaceName() throws ParseException {
   String r;
     switch ((==-1)?jj_ntk():) {
     case :
       r = Literal();
       break;
     case 15:
       jj_consume_token(15);
                                r = .;
       break;
     default:
       [17] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     {if (truereturn r;}
     throw new Error("Missing return statement in function");
   }
 
   final public void DatatypesDecl() throws ParseException {
   LocatedString prefix;
   String uri;
     jj_consume_token(16);
     prefix = UnprefixedName();
     jj_consume_token(2);
     uri = Literal();
     .put(prefix.getString(), uri);
   }
 
   final public ParsedPattern AnnotatedPrimaryExpr(boolean topLevelScope scopeToken[] exceptthrows ParseException {
   Annotations a;
   Token t;
     a = Annotations();
     p = PrimaryExpr(topLevelscopeaexcept);
     label_5:
     while (true) {
       switch ((==-1)?jj_ntk():) {
       case :
         ;
         break;
       default:
         [18] = ;
         break label_5;
       }
       t = jj_consume_token();
       e = AnnotationElement(false);
        if (topLevel)
          error("top_level_follow_annotation"t);
        else
          p = .annotateAfter(pe);
     }
     {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern PrimaryExpr(boolean topLevelScope scopeAnnotations aToken[] exceptthrows ParseException {
     switch ((==-1)?jj_ntk():) {
     case 26:
       p = ElementExpr(scopea);
       break;
     case 27:
       p = AttributeExpr(scopea);
       break;
     case 10:
       p = GrammarExpr(scopea);
       break;
     case 33:
       p = ExternalRefExpr(scopea);
       break;
     case 31:
       p = ListExpr(scopea);
       break;
     case 32:
       p = MixedExpr(scopea);
       break;
     case 28:
       p = ParenExpr(topLevelscopea);
       break;
     case :
     case :
       p = IdentifierExpr(scopea);
       break;
     case 34:
       p = ParentExpr(scopea);
       break;
     case 35:
     case 36:
     case :
       p = DataExpr(topLevelscopeaexcept);
       break;
     case :
       p = ValueExpr(topLevela);
       break;
     case 18:
       p = TextExpr(a);
       break;
     case 17:
       p = EmptyExpr(a);
       break;
     case 19:
       p = NotAllowedExpr(a);
       break;
     default:
       [19] = ;
       jj_consume_token(-1);
       throw new ParseException();
     }
     {if (truereturn p;}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern EmptyExpr(Annotations athrows ParseException {
   Token t;
     t = jj_consume_token(17);
     {if (truereturn .makeEmpty(makeLocation(t), a);}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern TextExpr(Annotations athrows ParseException {
   Token t;
     t = jj_consume_token(18);
     {if (truereturn .makeText(makeLocation(t), a);}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern NotAllowedExpr(Annotations athrows ParseException {
   Token t;
     t = jj_consume_token(19);
     {if (truereturn .makeNotAllowed(makeLocation(t), a);}
     throw new Error("Missing return statement in function");
   }
 
   final public ParsedPattern Expr(boolean topLevelScope scopeToken tAnnotations athrows ParseException {
   ParsedPattern[] patterns = new ParsedPattern[2];
   int nPatterns = 1;
   boolean[] hadOccur = new boolean[1];
   Token[] except = new Token[1];
     p = UnaryExpr(topLevelscopehadOccurexcept);
     patterns[0] = p;
     switch ((==-1)?jj_ntk():) {
     case 20:
     case 21:
     case 22:
       switch ((==-1)?jj_ntk():) {
       case 20:
      checkExcept(except);
         label_6:
         while (true) {
           t = jj_consume_token(20);
           p = UnaryExpr(topLevelscopenullexcept);
        patterns = addPattern(patternsnPatterns++, p); checkExcept(except);
           switch ((==-1)?jj_ntk():) {
           case 20:
             ;
             break;
           default:
             [20] = ;
             break label_6;
           }
         }
       p = .makeChoice(patternsnPatternsmakeLocation(t), a);
         break;
       case 21:
         label_7:
         while (true) {
           t = jj_consume_token(21);
           p = UnaryExpr(topLevelscopenullexcept);
        patterns = addPattern(patternsnPatterns++, p); checkExcept(except);
           switch ((==-1)?jj_ntk():) {
           case 21:
             ;
             break;
           default:
             [21] = ;
             break label_7;
           }
         }
       p = .makeInterleave(patternsnPatternsmakeLocation(t), a);
         break;
       case 22:
         label_8:
         while (true) {
           t = jj_consume_token(22);
          p = UnaryExpr(topLevelscopenullexcept);
       patterns = addPattern(patternsnPatterns++, p); checkExcept(except);
          switch ((==-1)?jj_ntk():) {
          case 22:
            ;
            break;
          default:
            [22] = ;
            break label_8;
          }
        }
      p = .makeGroup(patternsnPatternsmakeLocation(t), a);
        break;
      default:
        [23] = ;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      [24] = ;
      ;
    }
    if (nPatterns == 1 && a != null) {
      if (hadOccur[0])
        p = .annotate(