/* Generated By:JavaCC: Do not edit this line. AOTParse.java */
//package AOT;

import java.util.*;


class AOTParse implements AOTParseConstants {

 static String unescapeString(String in) {
 // entfernt Anfuehrungszeichen um in, loest Fluchtzeichen in in auf

  String out = "";

  char c;

  for (int i = 1; i<in.length()-1; i++) {

   c = in.charAt(i);

   if(c=='\\') {

    ++i;

         if(in.charAt(i)=='n')
          c = '\n';
         else if(in.charAt(i)=='r')
          c = '\r';
         else if(in.charAt(i)=='t')
          c = '\t';
    else
     c = in.charAt(i);

   }

   out += c;

  }

  return out;

 }

 static String escapeString(String in) {
 // fuegt Fluchtzeichen vor reservierten Zeichen ein

  if(in==null)
   return "";

  String out = "";

  char c;

  for (int i = 0; i<in.length(); i++) {

   c = in.charAt(i);

   if(c=='\\'||c=='\"')
    out += "\\"+c;
   else if(c=='\n')
    out += "\\n";
   else if(c=='\r')
    out += "\\r";
   else if(c=='\t')
    out += "\\t";
   else
    out += c;

  }

  return out;

 }

  final public Node document(Node parent, Edge edge, Constraint[][] consp, Bookmark[][] bookmp) throws ParseError {
  Node n;
    if (jj_mask_1[getToken(1).kind]) {
      jj_consume_token(DocumentToken);
      jj_consume_token(28);
      n = node(parent, edge);
      jj_consume_token(29);
      jj_consume_token(30);
      consp[0] = constraints();
      bookmp[0] = bookmarks();
    } else {
      jj_expLA1[1] = jj_gen;
      if (jj_mask_0[getToken(1).kind]) {
        n = node(parent, edge);
                             consp[0] = null; bookmp[0] = null;
      } else {
        jj_expLA1[0] = jj_gen;
        jj_consume_token(-1);
        throw new ParseError();
      }
    }
    return n;
  }

  static boolean[] jj_mask_0 = new boolean[37];
  static {
    jj_mask_0[AndToken] =
    jj_mask_0[OrToken] =
    jj_mask_0[iOrToken] =
    jj_mask_0[TextToken] =
    jj_mask_0[IncludeToken] = true;
  }
  static boolean[] jj_mask_1 = new boolean[37];
  static {
    jj_mask_1[DocumentToken] = true;
  }
  
  final public Node node(Node parent, Edge edge) throws ParseError {
  Node[] c;
  Node n;

  Token leaf_text_token, rows_token, columns_token, url_token;

  int rows, columns;
  String leaf_text, url;
    if (jj_mask_11[getToken(1).kind]) {
      jj_consume_token(AndToken);
      jj_consume_token(28);
                   n = new AND_Node(parent, edge, null, null, false);
      jj_consume_token(31);
      c = children(n);
      jj_consume_token(32);
      if (jj_mask_10[getToken(1).kind]) {
        And_Attributes((AND_Node)n);
      } else {
        jj_expLA1[10] = jj_gen;
        ;
      }
      jj_consume_token(29);
                                                                n.set_children(c); return n;
    } else {
      jj_expLA1[11] = jj_gen;
      if (jj_mask_9[getToken(1).kind]) {
        jj_consume_token(OrToken);
        jj_consume_token(28);
                  n = new OR_Node(parent, edge, null, null, false);
        jj_consume_token(31);
        c = children(n);
        jj_consume_token(32);
        if (jj_mask_8[getToken(1).kind]) {
          Or_Attributes((OR_Node)n);
        } else {
          jj_expLA1[8] = jj_gen;
          ;
        }
        jj_consume_token(29);
                                                              n.set_children(c); return n;
      } else {
        jj_expLA1[9] = jj_gen;
        if (jj_mask_7[getToken(1).kind]) {
          jj_consume_token(iOrToken);
          jj_consume_token(28);
                   n = new iOR_Node(parent, edge, null, null, false);
          jj_consume_token(31);
          c = children(n);
          jj_consume_token(32);
          if (jj_mask_6[getToken(1).kind]) {
            iOr_Attributes((iOR_Node)n);
          } else {
            jj_expLA1[6] = jj_gen;
            ;
          }
          jj_consume_token(29);
                                                                n.set_children(c); return n;
        } else {
          jj_expLA1[7] = jj_gen;
          if (jj_mask_5[getToken(1).kind]) {
            jj_consume_token(TextToken);
            jj_consume_token(28);
                    n = new Text_Node(parent, edge, null, false, "", AOTreeString.DEFAULT_TEXT_ROWS, AOTreeString.DEFAULT_TEXT_COLUMNS);
            if (jj_mask_3[getToken(1).kind]) {
              leaf_text_token = jj_consume_token(StringToken);
                                      ((Text_Node)n).set_leaf_text(unescapeString(leaf_text_token.image));
            } else {
              jj_expLA1[3] = jj_gen;
              ;
            }
            if (jj_mask_4[getToken(1).kind]) {
              Text_Attributes((Text_Node)n);
            } else {
              jj_expLA1[4] = jj_gen;
              ;
            }
            jj_consume_token(29);
        return n;
          } else {
            jj_expLA1[5] = jj_gen;
            if (jj_mask_2[getToken(1).kind]) {
              jj_consume_token(IncludeToken);
              jj_consume_token(28);
              url_token = jj_consume_token(StringToken);
              jj_consume_token(29);
    // Include-Datei expandieren

   url = unescapeString(url_token.image);

   String current_directory_before = AOT.Aot.current_directory!=null?new String(AOT.Aot.current_directory):null;

   String file_content = Document.read_tree(url); // inkl. Wechsel in's Verzeichnis von url

   if(file_content==null) {

    AOT.Aot.current_directory = current_directory_before;

    return null;

   }

   AOTreeString source = new AOTreeString(null, file_content);

   StringBuffer message = new StringBuffer();

   Constraint[][] dummy1 = new Constraint[1][];

   Bookmark[][] dummy2 = new Bookmark[1][];

   Node subtree = source.parse(parent, edge, message, dummy1, dummy2);
   // (^ Aufruf setzt unbedingt voraus, dass die javacc-Option STATIC=false gesetzt ist)

   AOT.Aot.current_directory = current_directory_before;

   if(subtree==null) {

    System.out.println("Error: Parser error in include-file "+url); // (Debugging-Info)

    InfoDialog.info(AOT.APPLET_NAME+" Error", "Could not parse include-file "+url+":\n"+message, InfoDialog.OK, "cats_src.html#grammatik");

   } else {

    System.out.println("Parse of include-file "+url+" was successful"); // (Debugging-Info)

    subtree.set_name(url);
      // Der (Datei-)Name url des Knotens ist im Baumdiagramm 
      // nur fuer den Superuser sichtbar und bewirkt ggf. beim Speichern des Baums,
      // dass der Unterbaum subroot in der Datei url statt in der Vater-Datei abgelegt wird.
      // Um dieses Prinzip zu verallgemeinern, erhaelt der Wurzelknoten root der Vater-Datei
      // deren Dateinamen.
   }

   return subtree;
            } else {
              jj_expLA1[2] = jj_gen;
              jj_consume_token(-1);
              throw new ParseError();
            }
          }
        }
      }
    }
  }

  static boolean[] jj_mask_2 = new boolean[37];
  static {
    jj_mask_2[IncludeToken] = true;
  }
  static boolean[] jj_mask_3 = new boolean[37];
  static {
    jj_mask_3[StringToken] = true;
  }
  static boolean[] jj_mask_4 = new boolean[37];
  static {
    jj_mask_4[33] = true;
  }
  static boolean[] jj_mask_5 = new boolean[37];
  static {
    jj_mask_5[TextToken] = true;
  }
  static boolean[] jj_mask_6 = new boolean[37];
  static {
    jj_mask_6[33] = true;
  }
  static boolean[] jj_mask_7 = new boolean[37];
  static {
    jj_mask_7[iOrToken] = true;
  }
  static boolean[] jj_mask_8 = new boolean[37];
  static {
    jj_mask_8[33] = true;
  }
  static boolean[] jj_mask_9 = new boolean[37];
  static {
    jj_mask_9[OrToken] = true;
  }
  static boolean[] jj_mask_10 = new boolean[37];
  static {
    jj_mask_10[33] = true;
  }
  static boolean[] jj_mask_11 = new boolean[37];
  static {
    jj_mask_11[AndToken] = true;
  }
  
  final public void And_Attribute(AND_Node target) throws ParseError {
    Common_Attribute(target);
  }

  final public void And_Attributes(AND_Node target) throws ParseError {
    jj_consume_token(33);
    And_Attribute(target);
    if (jj_mask_12[getToken(1).kind]) {
      And_Attributes(target);
    } else {
      jj_expLA1[12] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_12 = new boolean[37];
  static {
    jj_mask_12[33] = true;
  }
  
  final public void Or_Attribute(OR_Node target) throws ParseError {
    Common_Attribute(target);
  }

  final public void Or_Attributes(OR_Node target) throws ParseError {
    jj_consume_token(33);
    Or_Attribute(target);
    if (jj_mask_13[getToken(1).kind]) {
      Or_Attributes(target);
    } else {
      jj_expLA1[13] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_13 = new boolean[37];
  static {
    jj_mask_13[33] = true;
  }
  
  final public void iOr_Attribute(iOR_Node target) throws ParseError {
    Common_Attribute(target);
  }

  final public void iOr_Attributes(iOR_Node target) throws ParseError {
    jj_consume_token(33);
    iOr_Attribute(target);
    if (jj_mask_14[getToken(1).kind]) {
      iOr_Attributes(target);
    } else {
      jj_expLA1[14] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_14 = new boolean[37];
  static {
    jj_mask_14[33] = true;
  }
  
  final public void Text_Attribute(Text_Node target) throws ParseError {
 Token rows_token, cols_token;
    if (jj_mask_17[getToken(1).kind]) {
      Common_Attribute(target);
    } else {
      jj_expLA1[17] = jj_gen;
      if (jj_mask_16[getToken(1).kind]) {
        jj_consume_token(RowsToken);
        jj_consume_token(34);
        rows_token = jj_consume_token(IntegerToken);
                                                  target.set_rows(Integer.parseInt(rows_token.image));
      } else {
        jj_expLA1[16] = jj_gen;
        if (jj_mask_15[getToken(1).kind]) {
          jj_consume_token(ColsToken);
          jj_consume_token(34);
          cols_token = jj_consume_token(IntegerToken);
                                                  target.set_columns(Integer.parseInt(cols_token.image));
        } else {
          jj_expLA1[15] = jj_gen;
          jj_consume_token(-1);
          throw new ParseError();
        }
      }
    }
  }

  static boolean[] jj_mask_15 = new boolean[37];
  static {
    jj_mask_15[ColsToken] = true;
  }
  static boolean[] jj_mask_16 = new boolean[37];
  static {
    jj_mask_16[RowsToken] = true;
  }
  static boolean[] jj_mask_17 = new boolean[37];
  static {
    jj_mask_17[HelpToken] =
    jj_mask_17[CollapsedToken] = true;
  }
  
  final public void Text_Attributes(Text_Node target) throws ParseError {
    jj_consume_token(33);
    Text_Attribute(target);
    if (jj_mask_18[getToken(1).kind]) {
      Text_Attributes(target);
    } else {
      jj_expLA1[18] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_18 = new boolean[37];
  static {
    jj_mask_18[33] = true;
  }
  
  final public void Common_Attribute(Node target) throws ParseError {
  Token collapsed_token;
  Token help_token;
    if (jj_mask_20[getToken(1).kind]) {
      jj_consume_token(CollapsedToken);
      jj_consume_token(34);
      collapsed_token = jj_consume_token(Boolean);
                                                      target.set_collapsed(collapsed_token.image.equalsIgnoreCase("yes")||collapsed_token.image.equalsIgnoreCase("true"));
    } else {
      jj_expLA1[20] = jj_gen;
      if (jj_mask_19[getToken(1).kind]) {
        jj_consume_token(HelpToken);
        jj_consume_token(34);
        help_token = jj_consume_token(StringToken);
                                                target.set_help(unescapeString(help_token.image));
      } else {
        jj_expLA1[19] = jj_gen;
        jj_consume_token(-1);
        throw new ParseError();
      }
    }
  }

  static boolean[] jj_mask_19 = new boolean[37];
  static {
    jj_mask_19[HelpToken] = true;
  }
  static boolean[] jj_mask_20 = new boolean[37];
  static {
    jj_mask_20[CollapsedToken] = true;
  }
  
  final public Node[] children(Node parent) throws ParseError {
  Vector children_temp;
  Node n;
    if (jj_mask_22[getToken(1).kind]) {
      n = child(parent);
                      children_temp = new Vector(); children_temp.addElement(n);
      label_1:
      while (true) {
        if (jj_mask_21[getToken(1).kind]) {
          ;
        } else {
          jj_expLA1[21] = jj_gen;
          break label_1;
        }
        jj_consume_token(33);
        n = child(parent);
                           children_temp.addElement(n);
      }
   Node[] children = new Node[children_temp.size()];

   children_temp.copyInto(children);

   return children;
    } else {
      jj_expLA1[22] = jj_gen;
    return new Node[0]; /* (ueblicherweise bei And([]))*/
    }
  }

  static boolean[] jj_mask_21 = new boolean[37];
  static {
    jj_mask_21[33] = true;
  }
  static boolean[] jj_mask_22 = new boolean[37];
  static {
    jj_mask_22[IdToken] = true;
  }
  
  final public Node child(Node parent) throws ParseError {
  Edge edge;
  Node n;
    edge = parse_edge();
    jj_consume_token(35);
    n = node(parent, edge);
    return n;
  }

  final public Edge parse_edge() throws ParseError {
 Edge e;

 Token id_token;
    id_token = jj_consume_token(IdToken);
                        e = new Edge("", null, new String(id_token.image));
    if (jj_mask_24[getToken(1).kind]) {
      jj_consume_token(28);
      if (jj_mask_23[getToken(1).kind]) {
        Edge_Attributes(e);
      } else {
        jj_expLA1[23] = jj_gen;
        ;
      }
      jj_consume_token(29);
    } else {
      jj_expLA1[24] = jj_gen;
      ;
    }
   return e;
  }

  static boolean[] jj_mask_23 = new boolean[37];
  static {
    jj_mask_23[StringToken] =
    jj_mask_23[HelpToken] =
    jj_mask_23[LabelToken] = true;
  }
  static boolean[] jj_mask_24 = new boolean[37];
  static {
    jj_mask_24[28] = true;
  }
  
  final public void Edge_Attribute(Edge target) throws ParseError {
 Token label_token, help_token;
    if (jj_mask_27[getToken(1).kind]) {
      if (jj_mask_26[getToken(1).kind]) {
        jj_consume_token(LabelToken);
        jj_consume_token(34);
      } else {
        jj_expLA1[26] = jj_gen;
        ;
      }
      label_token = jj_consume_token(StringToken);
                                                       target.set_label(unescapeString(label_token.image));
    } else {
      jj_expLA1[27] = jj_gen;
      if (jj_mask_25[getToken(1).kind]) {
        jj_consume_token(HelpToken);
        jj_consume_token(34);
        help_token = jj_consume_token(StringToken);
                                                 target.set_help(unescapeString(help_token.image));
      } else {
        jj_expLA1[25] = jj_gen;
        jj_consume_token(-1);
        throw new ParseError();
      }
    }
  }

  static boolean[] jj_mask_25 = new boolean[37];
  static {
    jj_mask_25[HelpToken] = true;
  }
  static boolean[] jj_mask_26 = new boolean[37];
  static {
    jj_mask_26[LabelToken] = true;
  }
  static boolean[] jj_mask_27 = new boolean[37];
  static {
    jj_mask_27[StringToken] =
    jj_mask_27[LabelToken] = true;
  }
  
  final public void Edge_Attributes(Edge target) throws ParseError {
    Edge_Attribute(target);
    if (jj_mask_28[getToken(1).kind]) {
      jj_consume_token(33);
      Edge_Attributes(target);
    } else {
      jj_expLA1[28] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_28 = new boolean[37];
  static {
    jj_mask_28[33] = true;
  }
  
  final public Constraint[] constraints() throws ParseError {
  Vector constraints_temp;
  Constraint c;
    constraints_temp = new Vector();
    label_2:
    while (true) {
      if (jj_mask_29[getToken(1).kind]) {
        ;
      } else {
        jj_expLA1[29] = jj_gen;
        break label_2;
      }
      c = constraint();
                      constraints_temp.addElement(c);
    }
   Constraint[] constraints_array = new Constraint[constraints_temp.size()];

   constraints_temp.copyInto(constraints_array);

   return constraints_array;
  }

  static boolean[] jj_mask_29 = new boolean[37];
  static {
    jj_mask_29[ConstraintToken] = true;
  }
  
  final public Constraint constraint() throws ParseError {
 Constraint constraint;

 String selection_a, selection_b;

 Vector selections_temp;
   constraint = new Constraint(); selections_temp = new Vector();
    jj_consume_token(ConstraintToken);
    jj_consume_token(28);
    jj_consume_token(28);
    selection_a = selections("\r\n  ");
    jj_consume_token(29);
    jj_consume_token(33);
   selections_temp.addElement("("+selection_a+")");
    jj_consume_token(31);
    label_3:
    while (true) {
      if (jj_mask_30[getToken(1).kind]) {
        ;
      } else {
        jj_expLA1[30] = jj_gen;
        break label_3;
      }
      jj_consume_token(28);
      selection_b = selections("\r\n  ");
      jj_consume_token(29);
      selections_temp.addElement("("+selection_b+")");
      if (jj_mask_31[getToken(1).kind]) {
        jj_consume_token(33);
      } else {
        jj_expLA1[31] = jj_gen;
        ;
      }
    }
    jj_consume_token(32);
    if (jj_mask_32[getToken(1).kind]) {
      Constraint_Attributes(constraint);
    } else {
      jj_expLA1[32] = jj_gen;
      ;
    }
    jj_consume_token(29);
    jj_consume_token(30);
  constraint.patterns = new String[selections_temp.size()];

  selections_temp.copyInto(constraint.patterns);

  return constraint;
  }

  static boolean[] jj_mask_30 = new boolean[37];
  static {
    jj_mask_30[28] = true;
  }
  static boolean[] jj_mask_31 = new boolean[37];
  static {
    jj_mask_31[33] = true;
  }
  static boolean[] jj_mask_32 = new boolean[37];
  static {
    jj_mask_32[33] = true;
  }
  
  final public String selections(String indent) throws ParseError {
  // Achtung: die aeusseren Klammern von (selection) werden hier nicht gematcht !

 String sels;

 String tmp;
   sels = new String();
    tmp = selection(indent);
                           sels += tmp;
    label_4:
    while (true) {
      if (jj_mask_33[getToken(1).kind]) {
        ;
      } else {
        jj_expLA1[33] = jj_gen;
        break label_4;
      }
      jj_consume_token(33);
         sels += ",";
      tmp = selection(indent);
                                                  sels += tmp;
    }
   return sels;
  }

  static boolean[] jj_mask_33 = new boolean[37];
  static {
    jj_mask_33[33] = true;
  }
  
  final public String selection(String indent) throws ParseError {
  // Matching einer(!) Selektion muss immer per selections() erfolgen,
  // da eine Selektion (bei Weglassen der aeusseren Klammern) kein Baum ist!

 String sel;

 String tmp;

 Token token;
    sel  = new String();
    if (jj_mask_38[getToken(1).kind]) {
      if (jj_mask_37[getToken(1).kind]) {
        jj_consume_token(36);
            sel += "_";
      } else {
        jj_expLA1[37] = jj_gen;
        if (jj_mask_36[getToken(1).kind]) {
          token = jj_consume_token(StringToken);
                             sel += /*"\""+unescapeString(*/token.image/*)+"\""*/;
        } else {
          jj_expLA1[36] = jj_gen;
          if (jj_mask_35[getToken(1).kind]) {
            token = jj_consume_token(IdToken);
                         sel += indent+token.image;
            if (jj_mask_34[getToken(1).kind]) {
              jj_consume_token(28);
                 sel += "(";
              tmp = selections(indent+"  ");
                                           sel += tmp;
              jj_consume_token(29);
                 sel += ")";
            } else {
              jj_expLA1[34] = jj_gen;
              ;
            }
          } else {
            jj_expLA1[35] = jj_gen;
            jj_consume_token(-1);
            throw new ParseError();
          }
        }
      }
    } else {
      jj_expLA1[38] = jj_gen;
      ;
    }
   return sel;
  }

  static boolean[] jj_mask_34 = new boolean[37];
  static {
    jj_mask_34[28] = true;
  }
  static boolean[] jj_mask_35 = new boolean[37];
  static {
    jj_mask_35[IdToken] = true;
  }
  static boolean[] jj_mask_36 = new boolean[37];
  static {
    jj_mask_36[StringToken] = true;
  }
  static boolean[] jj_mask_37 = new boolean[37];
  static {
    jj_mask_37[36] = true;
  }
  static boolean[] jj_mask_38 = new boolean[37];
  static {
    jj_mask_38[StringToken] =
    jj_mask_38[IdToken] =
    jj_mask_38[36] = true;
  }
  
  final public void Constraint_Attribute(Constraint target) throws ParseError {
 Token label_token, help_token, suspended_token;
    if (jj_mask_42[getToken(1).kind]) {
      if (jj_mask_41[getToken(1).kind]) {
        jj_consume_token(LabelToken);
        jj_consume_token(34);
      } else {
        jj_expLA1[41] = jj_gen;
        ;
      }
      label_token = jj_consume_token(StringToken);
                                                      target.id = unescapeString(label_token.image);
    } else {
      jj_expLA1[42] = jj_gen;
      if (jj_mask_40[getToken(1).kind]) {
        jj_consume_token(HelpToken);
        jj_consume_token(34);
        help_token = jj_consume_token(StringToken);
                                                target.help = unescapeString(help_token.image);
      } else {
        jj_expLA1[40] = jj_gen;
        if (jj_mask_39[getToken(1).kind]) {
          jj_consume_token(SuspendedToken);
          jj_consume_token(34);
          suspended_token = jj_consume_token(Boolean);
                                                      target.suspended = suspended_token.image.equalsIgnoreCase("true")||suspended_token.image.equalsIgnoreCase("yes");
        } else {
          jj_expLA1[39] = jj_gen;
          jj_consume_token(-1);
          throw new ParseError();
        }
      }
    }
  }

  static boolean[] jj_mask_39 = new boolean[37];
  static {
    jj_mask_39[SuspendedToken] = true;
  }
  static boolean[] jj_mask_40 = new boolean[37];
  static {
    jj_mask_40[HelpToken] = true;
  }
  static boolean[] jj_mask_41 = new boolean[37];
  static {
    jj_mask_41[LabelToken] = true;
  }
  static boolean[] jj_mask_42 = new boolean[37];
  static {
    jj_mask_42[StringToken] =
    jj_mask_42[LabelToken] = true;
  }
  
  final public void Constraint_Attributes(Constraint target) throws ParseError {
    jj_consume_token(33);
    Constraint_Attribute(target);
    if (jj_mask_43[getToken(1).kind]) {
      Constraint_Attributes(target);
    } else {
      jj_expLA1[43] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_43 = new boolean[37];
  static {
    jj_mask_43[33] = true;
  }
  
  final public Bookmark[] bookmarks() throws ParseError {
  Vector bookmarks_temp;
  Bookmark c;
    bookmarks_temp = new Vector();
    label_5:
    while (true) {
      if (jj_mask_44[getToken(1).kind]) {
        ;
      } else {
        jj_expLA1[44] = jj_gen;
        break label_5;
      }
      c = bookmark();
                    bookmarks_temp.addElement(c);
    }
   Bookmark[] bookmarks_array = new Bookmark[bookmarks_temp.size()];

   bookmarks_temp.copyInto(bookmarks_array);

   return bookmarks_array;
  }

  static boolean[] jj_mask_44 = new boolean[37];
  static {
    jj_mask_44[BookmarkToken] = true;
  }
  
  final public Bookmark bookmark() throws ParseError {
 Bookmark bookmark;

 String selection_a;
   bookmark = new Bookmark("Noname", null);
    jj_consume_token(BookmarkToken);
    jj_consume_token(28);
    jj_consume_token(28);
    selection_a = selections("\r\n  ");
    jj_consume_token(29);
   bookmark.content = "("+selection_a+")";
    if (jj_mask_45[getToken(1).kind]) {
      Bookmark_Attributes(bookmark);
    } else {
      jj_expLA1[45] = jj_gen;
      ;
    }
    jj_consume_token(29);
    jj_consume_token(30);
   return bookmark;
  }

  static boolean[] jj_mask_45 = new boolean[37];
  static {
    jj_mask_45[33] = true;
  }
  
  final public void Bookmark_Attribute(Bookmark target) throws ParseError {
 Token label_token;
    if (jj_mask_46[getToken(1).kind]) {
      jj_consume_token(LabelToken);
      jj_consume_token(34);
    } else {
      jj_expLA1[46] = jj_gen;
      ;
    }
    label_token = jj_consume_token(StringToken);
                                                      target.name = unescapeString(label_token.image);
  }

  static boolean[] jj_mask_46 = new boolean[37];
  static {
    jj_mask_46[LabelToken] = true;
  }
  
  final public void Bookmark_Attributes(Bookmark target) throws ParseError {
    jj_consume_token(33);
    Bookmark_Attribute(target);
    if (jj_mask_47[getToken(1).kind]) {
      Bookmark_Attributes(target);
    } else {
      jj_expLA1[47] = jj_gen;
      ;
    }
  }

  static boolean[] jj_mask_47 = new boolean[37];
  static {
    jj_mask_47[33] = true;
  }
  
  public AOTParseTokenManager token_source;
  public Token token;
  private AOTParse jj_me;
  private int jj_gen;
  private int[] jj_expLA1 = new int[48];

  public AOTParse(java.io.InputStream stream) {
    ASCII_CharStream input_stream = new ASCII_CharStream(stream, 1, 1);
    token_source = new AOTParseTokenManager(input_stream);
    token = new Token();
    jj_me = this;
    jj_gen = 0;
    for (int i = 0; i < 48; i++) jj_expLA1[i] = -1;
  }

  public void ReInit(java.io.InputStream stream) {
    ASCII_CharStream input_stream = new ASCII_CharStream(stream, 1, 1);
    token_source.ReInit(input_stream);
    token = new Token();
    jj_gen = 0;
    for (int i = 0; i < 48; i++) jj_expLA1[i] = -1;
  }

  public AOTParse(AOTParseTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_me = this;
    jj_gen = 0;
    for (int i = 0; i < 48; i++) jj_expLA1[i] = -1;
  }

  public void ReInit(AOTParseTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_gen = 0;
    for (int i = 0; i < 48; i++) jj_expLA1[i] = -1;
  }

  final private Token jj_consume_token(int kind) throws ParseError {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    if (token.kind == kind) {
      jj_gen++;
      return token;
    }
    jj_token_error_setup(token, kind);
    throw new ParseError();
  }

  final public Token getNextToken() throws ParseError {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_gen++;
    return token;
  }

  final public Token getToken(int index) throws ParseError {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  static final String jj_add_escapes(String str) {
    String retval = "";
    char ch;
    for (int i = 0; i < str.length(); i++) {
      ch = str.charAt(i);
      if (ch == '\b') {
        retval += "\\b";
      } else if (ch == '\t') {
        retval += "\\t";
      } else if (ch == '\n') {
        retval += "\\n";
      } else if (ch == '\f') {
        retval += "\\f";
      } else if (ch == '\r') {
        retval += "\\r";
      } else if (ch == '\"') {
        retval += "\\\"";
      } else if (ch == '\'') {
        retval += "\\\'";
      } else if (ch == '\\') {
        retval += "\\\\";
      } else if (ch < 0x20 || ch > 0x7e) {
        String s = "0000" + Integer.toString(ch, 16);
        retval += "\\u" + s.substring(s.length() - 4, s.length());
      } else {
        retval += ch;
      }
    }
    return retval;
  }

  protected int error_line;
  protected int error_column;
  protected String error_string;
  protected String[] expected_tokens;

  protected void token_error() {
    System.out.println("");
    System.out.println("Parse error at line " + error_line + ", column " + error_column + ".  Encountered:");
    System.out.println("    \"" + jj_add_escapes(error_string) + "\"");
    System.out.println("");
    if (expected_tokens.length == 1) {
      System.out.println("Was expecting:");
    } else {
      System.out.println("Was expecting one of:");
    }
    for (int i = 0; i < expected_tokens.length; i++) {
      System.out.println("    " + expected_tokens[i]);
    }
    System.out.println("");
  }

  private java.util.Vector jj_errortokens = new java.util.Vector();

  final private void jj_token_error_setup(Token current, int kind) throws ParseError {
    jj_errortokens.removeAllElements();
    boolean[] la1tokens = new boolean[37];
    boolean[] mask = null;
    for (int i = 0; i < 37; i++) {
      la1tokens[i] = false;
    }
    if (kind >= 0) la1tokens[kind] = true;
    for (int i = 0; i < 48; i++) {
      if (jj_expLA1[i] == jj_gen) {
        switch (i) {
          case 0: mask = jj_mask_0; break;
          case 1: mask = jj_mask_1; break;
          case 2: mask = jj_mask_2; break;
          case 3: mask = jj_mask_3; break;
          case 4: mask = jj_mask_4; break;
          case 5: mask = jj_mask_5; break;
          case 6: mask = jj_mask_6; break;
          case 7: mask = jj_mask_7; break;
          case 8: mask = jj_mask_8; break;
          case 9: mask = jj_mask_9; break;
          case 10: mask = jj_mask_10; break;
          case 11: mask = jj_mask_11; break;
          case 12: mask = jj_mask_12; break;
          case 13: mask = jj_mask_13; break;
          case 14: mask = jj_mask_14; break;
          case 15: mask = jj_mask_15; break;
          case 16: mask = jj_mask_16; break;
          case 17: mask = jj_mask_17; break;
          case 18: mask = jj_mask_18; break;
          case 19: mask = jj_mask_19; break;
          case 20: mask = jj_mask_20; break;
          case 21: mask = jj_mask_21; break;
          case 22: mask = jj_mask_22; break;
          case 23: mask = jj_mask_23; break;
          case 24: mask = jj_mask_24; break;
          case 25: mask = jj_mask_25; break;
          case 26: mask = jj_mask_26; break;
          case 27: mask = jj_mask_27; break;
          case 28: mask = jj_mask_28; break;
          case 29: mask = jj_mask_29; break;
          case 30: mask = jj_mask_30; break;
          case 31: mask = jj_mask_31; break;
          case 32: mask = jj_mask_32; break;
          case 33: mask = jj_mask_33; break;
          case 34: mask = jj_mask_34; break;
          case 35: mask = jj_mask_35; break;
          case 36: mask = jj_mask_36; break;
          case 37: mask = jj_mask_37; break;
          case 38: mask = jj_mask_38; break;
          case 39: mask = jj_mask_39; break;
          case 40: mask = jj_mask_40; break;
          case 41: mask = jj_mask_41; break;
          case 42: mask = jj_mask_42; break;
          case 43: mask = jj_mask_43; break;
          case 44: mask = jj_mask_44; break;
          case 45: mask = jj_mask_45; break;
          case 46: mask = jj_mask_46; break;
          case 47: mask = jj_mask_47; break;
        }
        for (int j = 0; j < 37; j++) {
          if (mask[j]) la1tokens[j] = true;
        }
      }
    }
    if (la1tokens[0]) {
      jj_errortokens.addElement(tokenImage[0] + " ");
    }
    for (int i = 1; i < 37; i++) {
      if (la1tokens[i]) {
        jj_errortokens.addElement(tokenImage[i] + " ...");
      }
    }
    expected_tokens = new String[jj_errortokens.size()];
    for (int i = 0; i < jj_errortokens.size(); i++) {
      expected_tokens[i] = (String)(jj_errortokens.elementAt(i));
    }
    error_line = current.beginLine;
    error_column = current.beginColumn;
    if (current.kind == 0) {
      error_string = tokenImage[0];
    } else {
      error_string = current.image;
    }
    jj_me.token_error();
  }

  final public void enable_tracing() {
  }

  final public void disable_tracing() {
  }

}