pierosl.java

High performance DB query

    throw new Error("Missing return statement in function");
  }

  final public ArrayList doStringArrayList() throws ParseException {
    String element;
    ArrayList theArray;
    int curState;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.ARRAYLIST);
    jj_consume_token(ARRAYSTART);
      theArray = new ArrayList();
    switch (jj_nt.kind) {
    case BASICTEXTCHARS:
    case LITERALSTART:
      element = doLiteralTextString();
      theArray.add(element);
      label_5:
      while (true) {
        switch (jj_nt.kind) {
        case ARRAYSEP:
          ;
          break;
        default:
          jj_la1[12] = jj_gen;
          break label_5;
        }
        jj_consume_token(ARRAYSEP);
        element = doLiteralTextString();
          theArray.add(element);
      }
      break;
    default:
      jj_la1[13] = jj_gen;
      ;
    }
    jj_consume_token(ARRAYEND);
      token_source.SwitchTo(curState);
      {if (true) return theArray;}
    throw new Error("Missing return statement in function");
  }

  final public ArrayList doExpressionArrayList() throws ParseException {
    Expression element;
    ArrayList theArray;
    int curState;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.ARRAYLIST);
    jj_consume_token(ARRAYSTART);
      theArray = new ArrayList();
    switch (jj_nt.kind) {
    case ARRAYEXPSTART:
      jj_consume_token(ARRAYEXPSTART);
      element = doExpression(true);
      theArray.add(element);
      label_6:
      while (true) {
        switch (jj_nt.kind) {
        case ARRAYSEP:
          ;
          break;
        default:
          jj_la1[14] = jj_gen;
          break label_6;
        }
        jj_consume_token(ARRAYSEP);
        element = doExpression(false);
          theArray.add(element);
      }
      break;
    default:
      jj_la1[15] = jj_gen;
      ;
    }
    jj_consume_token(ARRAYEND);
      token_source.SwitchTo(curState);
      {if (true) return theArray;}
    throw new Error("Missing return statement in function");
  }

  final public InetSocketAddress doInetSocketAddress() throws ParseException {
    String address, port;
    int curState;
    InetSocketAddress destination;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.INETSOCKET);
    address = doTextString();
    jj_consume_token(PORTSEP);
    port = doTextString();
      token_source.SwitchTo(curState);
      destination = ((address.equals("null")) || (port.equals("null"))) ? null : new InetSocketAddress(address, Integer.parseInt(port));
      {if (true) return destination;}
    throw new Error("Missing return statement in function");
  }

  final public String doTextString() throws ParseException {
    Token text;
    text = jj_consume_token(BASICTEXTCHARS);
      {if (true) return text.image;}
    throw new Error("Missing return statement in function");
  }

  final public Expression doExpression(boolean started) throws ParseException {
    String name, type;
    Expression subExpression;
    int curState;
    Expression expression = null;
    ArrayList parameters = new ArrayList();
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.EXPRESSION);
      if (started == false) getExpressionStart();
    switch (jj_nt.kind) {
    case EXPRESSIONFIELD:
      jj_consume_token(EXPRESSIONFIELD);
      jj_consume_token(EXPRESSIONSEP);
      name = doLiteralTextString();
      expression = new ExpressionField(name);
      break;
    case EXPRESSIONCONSTANT:
      jj_consume_token(EXPRESSIONCONSTANT);
      jj_consume_token(EXPRESSIONSEP);
      name = doLiteralTextString();
      jj_consume_token(EXPRESSIONCAST);
      type = doTextString();
      expression = new ExpressionConstant(makeTypedObject(type, name));
      break;
    case EXPRESSIONFUNCTION:
      jj_consume_token(EXPRESSIONFUNCTION);
      jj_consume_token(EXPRESSIONSEP);
      name = doLiteralTextString();
      label_7:
      while (true) {
        switch (jj_nt.kind) {
        case EXPRESSIONSEP:
          ;
          break;
        default:
          jj_la1[16] = jj_gen;
          break label_7;
        }
        jj_consume_token(EXPRESSIONSEP);
        subExpression = doExpression(false);
      parameters.add(subExpression);
      }
      expression = new ExpressionFunction(name, parameters);
      break;
    default:
      jj_la1[17] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(EXPRESSIONEND);
      token_source.SwitchTo(curState);
      {if (true) return expression;}
    throw new Error("Missing return statement in function");
  }

  final public void getExpressionStart() throws ParseException {
    jj_consume_token(EXPRESSIONSTART);
  }

  final public String doLiteralTextString() throws ParseException {
    Token text;
    String curStr, escaped;
    int curState;
    switch (jj_nt.kind) {
    case BASICTEXTCHARS:
      text = jj_consume_token(BASICTEXTCHARS);
      {if (true) return text.image;}
      break;
    case LITERALSTART:
      jj_consume_token(LITERALSTART);
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.LITERALS);
      curStr = new String();
      label_8:
      while (true) {
        switch (jj_nt.kind) {
        case LITERALTEXT:
        case LITERALESCAPE:
          ;
          break;
        default:
          jj_la1[18] = jj_gen;
          break label_8;
        }
        switch (jj_nt.kind) {
        case LITERALTEXT:
          text = jj_consume_token(LITERALTEXT);
      curStr += text.image;
          break;
        case LITERALESCAPE:
          jj_consume_token(LITERALESCAPE);
          escaped = doLiteralEscape();
      curStr += escaped;
          break;
        default:
          jj_la1[19] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(LITERALEND);
      token_source.SwitchTo(curState);
      {if (true) return curStr;}
      break;
    default:
      jj_la1[20] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public String doLiteralEscape() throws ParseException {
    Token token;
    switch (jj_nt.kind) {
    case ESCAPEUNICODE:
      token = jj_consume_token(ESCAPEUNICODE);
      int x = Integer.parseInt(token.image.substring(1,4),16); {if (true) return new String(new Character((char) x).toString());}
      break;
    case ESCAPEQID:
      jj_consume_token(ESCAPEQID);
      {if (true) return "" + sourceID;}
      break;
    case ESCAPEQTAG:
      jj_consume_token(ESCAPEQTAG);
      {if (true) return queryNS;}
      break;
    case ESCAPEQADDR:
      jj_consume_token(ESCAPEQADDR);
      {if (true) return sourceSocketAddress.getAddress().toString().substring(1);}
      break;
    case ESCAPESLASH:
      jj_consume_token(ESCAPESLASH);
      {if (true) return "\\";}
      break;
    case ESCAPEQUOTE:
      jj_consume_token(ESCAPEQUOTE);
      {if (true) return "\"";}
      break;
    case ESCAPENEWLINE:
      jj_consume_token(ESCAPENEWLINE);
      {if (true) return "\n";}
      break;
    default:
      jj_la1[21] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  public PierOSLTokenManager token_source;
  SimpleCharStream jj_input_stream;
  public Token token, jj_nt;
  private int jj_gen;
  final private int[] jj_la1 = new int[22];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static private int[] jj_la1_2;
  static {
      jj_la1_0();
      jj_la1_1();
      jj_la1_2();
   }
   private static void jj_la1_0() {
      jj_la1_0 = new int[] {0x4,0x0,0x0,0x80,0x1ffff000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
   }
   private static void jj_la1_1() {
      jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0xe,0x1,0x800000,0x0,0x800000,0x400000,0x200,0x1c00,0x6000000,0x6000000,0x0,0xf0000000,};
   }
   private static void jj_la1_2() {
      jj_la1_2 = new int[] {0x0,0x18,0x18,0x0,0x0,0x0,0x18,0x18,0x0,0x18,0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0x18,0x7,};
   }

  public PierOSL(java.io.InputStream stream) {
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new PierOSLTokenManager(jj_input_stream);
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  public void ReInit(java.io.InputStream stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  public PierOSL(java.io.Reader stream) {
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new PierOSLTokenManager(jj_input_stream);
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  public PierOSL(PierOSLTokenManager tm) {
    token_source = tm;
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  public void ReInit(PierOSLTokenManager tm) {
    token_source = tm;
    token = new Token();
    token.next = jj_nt = token_source.getNextToken();
    jj_gen = 0;
    for (int i = 0; i < 22; i++) jj_la1[i] = -1;
  }

  final private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken = token;
    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
    else jj_nt = jj_nt.next = token_source.getNextToken();
    if (token.kind == kind) {
      jj_gen++;
      return token;
    }
    jj_nt = token;
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

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

  final public Token getToken(int index) {
    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;
  }

  private java.util.Vector jj_expentries = new java.util.Vector();
  private int[] jj_expentry;
  private int jj_kind = -1;

  public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[70];
    for (int i = 0; i < 70; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 22; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 70; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.addElement(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = (int[])jj_expentries.elementAt(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  final public void enable_tracing() {
  }

  final public void disable_tracing() {
  }

 }