Rcc.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:15k
源码类别:

网格计算

开发平台:

Java

  1. /* Generated By:JavaCC: Do not edit this line. Rcc.java */
  2. /**
  3.  * Licensed to the Apache Software Foundation (ASF) under one
  4.  * or more contributor license agreements.  See the NOTICE file
  5.  * distributed with this work for additional information
  6.  * regarding copyright ownership.  The ASF licenses this file
  7.  * to you under the Apache License, Version 2.0 (the
  8.  * "License"); you may not use this file except in compliance
  9.  * with the License.  You may obtain a copy of the License at
  10.  *
  11.  *     http://www.apache.org/licenses/LICENSE-2.0
  12.  *
  13.  * Unless required by applicable law or agreed to in writing, software
  14.  * distributed under the License is distributed on an "AS IS" BASIS,
  15.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16.  * See the License for the specific language governing permissions and
  17.  * limitations under the License.
  18.  */
  19. package org.apache.hadoop.record.compiler.generated;
  20. import org.apache.hadoop.record.compiler.*;
  21. import java.util.ArrayList;
  22. import java.util.Hashtable;
  23. import java.util.Iterator;
  24. import java.io.File;
  25. import java.io.FileReader;
  26. import java.io.FileNotFoundException;
  27. import java.io.IOException;
  28. public class Rcc implements RccConstants {
  29.   private static String language = "java";
  30.   private static String destDir = ".";
  31.   private static ArrayList<String> recFiles = new ArrayList<String>();
  32.   private static ArrayList<String> cmdargs = new ArrayList<String>();
  33.   private static JFile curFile;
  34.   private static Hashtable<String,JRecord> recTab;
  35.   private static String curDir = ".";
  36.   private static String curFileName;
  37.   private static String curModuleName;
  38.   public static void main(String[] args) {
  39.     System.exit(driver(args));
  40.   }
  41.   public static void usage() {
  42.     System.err.println("Usage: rcc --language [java|c++] ddl-files");
  43.   }
  44.   public static int driver(String[] args) {
  45.     for (int i=0; i<args.length; i++) {
  46.       if ("-l".equalsIgnoreCase(args[i]) ||
  47.           "--language".equalsIgnoreCase(args[i])) {
  48.         language = args[i+1].toLowerCase();
  49.         i++;
  50.       } else if ("-d".equalsIgnoreCase(args[i]) ||
  51.                  "--destdir".equalsIgnoreCase(args[i])) {
  52.         destDir = args[i+1];
  53.         i++;
  54.       } else if (args[i].startsWith("-")) {
  55.         String arg = args[i].substring(1);
  56.         if (arg.startsWith("-")) {
  57.           arg = arg.substring(1);
  58.         }
  59.         cmdargs.add(arg.toLowerCase());
  60.       } else {
  61.         recFiles.add(args[i]);
  62.       }
  63.     }
  64.     if (recFiles.size() == 0) {
  65.       usage();
  66.       return 1;
  67.     }
  68.     for (int i=0; i<recFiles.size(); i++) {
  69.       curFileName = recFiles.get(i);
  70.       File file = new File(curFileName);
  71.       try {
  72.         FileReader reader = new FileReader(file);
  73.         Rcc parser = new Rcc(reader);
  74.         try {
  75.           recTab = new Hashtable<String,JRecord>();
  76.           curFile = parser.Input();
  77.         } catch (ParseException e) {
  78.           System.err.println(e.toString());
  79.           return 1;
  80.         }
  81.         try {
  82.           reader.close();
  83.         } catch (IOException e) {
  84.         }
  85.       } catch (FileNotFoundException e) {
  86.         System.err.println("File " + recFiles.get(i) +
  87.                            " Not found.");
  88.         return 1;
  89.       }
  90.       try {
  91.         int retCode = curFile.genCode(language, destDir, cmdargs);
  92.         if (retCode != 0) { return retCode; }
  93.       } catch (IOException e) {
  94.         System.err.println(e.toString());
  95.         return 1;
  96.       }
  97.     }
  98.     return 0;
  99.   }
  100.   final public JFile Input() throws ParseException {
  101.     ArrayList<JFile> ilist = new ArrayList<JFile>();
  102.     ArrayList<JRecord> rlist = new ArrayList<JRecord>();
  103.     JFile i;
  104.     ArrayList<JRecord> l;
  105.     label_1:
  106.     while (true) {
  107.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  108.       case INCLUDE_TKN:
  109.         i = Include();
  110.         ilist.add(i);
  111.         break;
  112.       case MODULE_TKN:
  113.         l = Module();
  114.         rlist.addAll(l);
  115.         break;
  116.       default:
  117.         jj_la1[0] = jj_gen;
  118.         jj_consume_token(-1);
  119.         throw new ParseException();
  120.       }
  121.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  122.       case MODULE_TKN:
  123.       case INCLUDE_TKN:
  124.         ;
  125.         break;
  126.       default:
  127.         jj_la1[1] = jj_gen;
  128.         break label_1;
  129.       }
  130.     }
  131.     jj_consume_token(0);
  132.     {if (true) return new JFile(curFileName, ilist, rlist);}
  133.     throw new Error("Missing return statement in function");
  134.   }
  135.   final public JFile Include() throws ParseException {
  136.     String fname;
  137.     Token t;
  138.     jj_consume_token(INCLUDE_TKN);
  139.     t = jj_consume_token(CSTRING_TKN);
  140.     JFile ret = null;
  141.     fname = t.image.replaceAll("^"", "").replaceAll(""$","");
  142.     File file = new File(curDir, fname);
  143.     String tmpDir = curDir;
  144.     String tmpFile = curFileName;
  145.     curDir = file.getParent();
  146.     curFileName = file.getName();
  147.     try {
  148.       FileReader reader = new FileReader(file);
  149.       Rcc parser = new Rcc(reader);
  150.       try {
  151.         ret = parser.Input();
  152.         System.out.println(fname + " Parsed Successfully");
  153.       } catch (ParseException e) {
  154.         System.out.println(e.toString());
  155.         System.exit(1);
  156.       }
  157.       try {
  158.         reader.close();
  159.       } catch (IOException e) {
  160.       }
  161.     } catch (FileNotFoundException e) {
  162.       System.out.println("File " + fname +
  163.                          " Not found.");
  164.       System.exit(1);
  165.     }
  166.     curDir = tmpDir;
  167.     curFileName = tmpFile;
  168.     {if (true) return ret;}
  169.     throw new Error("Missing return statement in function");
  170.   }
  171.   final public ArrayList<JRecord> Module() throws ParseException {
  172.     String mName;
  173.     ArrayList<JRecord> rlist;
  174.     jj_consume_token(MODULE_TKN);
  175.     mName = ModuleName();
  176.     curModuleName = mName;
  177.     jj_consume_token(LBRACE_TKN);
  178.     rlist = RecordList();
  179.     jj_consume_token(RBRACE_TKN);
  180.     {if (true) return rlist;}
  181.     throw new Error("Missing return statement in function");
  182.   }
  183.   final public String ModuleName() throws ParseException {
  184.     String name = "";
  185.     Token t;
  186.     t = jj_consume_token(IDENT_TKN);
  187.     name += t.image;
  188.     label_2:
  189.     while (true) {
  190.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  191.       case DOT_TKN:
  192.         ;
  193.         break;
  194.       default:
  195.         jj_la1[2] = jj_gen;
  196.         break label_2;
  197.       }
  198.       jj_consume_token(DOT_TKN);
  199.       t = jj_consume_token(IDENT_TKN);
  200.       name += "." + t.image;
  201.     }
  202.     {if (true) return name;}
  203.     throw new Error("Missing return statement in function");
  204.   }
  205.   final public ArrayList<JRecord> RecordList() throws ParseException {
  206.     ArrayList<JRecord> rlist = new ArrayList<JRecord>();
  207.     JRecord r;
  208.     label_3:
  209.     while (true) {
  210.       r = Record();
  211.       rlist.add(r);
  212.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  213.       case RECORD_TKN:
  214.         ;
  215.         break;
  216.       default:
  217.         jj_la1[3] = jj_gen;
  218.         break label_3;
  219.       }
  220.     }
  221.     {if (true) return rlist;}
  222.     throw new Error("Missing return statement in function");
  223.   }
  224.   final public JRecord Record() throws ParseException {
  225.     String rname;
  226.     ArrayList<JField<JType>> flist = new ArrayList<JField<JType>>();
  227.     Token t;
  228.     JField<JType> f;
  229.     jj_consume_token(RECORD_TKN);
  230.     t = jj_consume_token(IDENT_TKN);
  231.     rname = t.image;
  232.     jj_consume_token(LBRACE_TKN);
  233.     label_4:
  234.     while (true) {
  235.       f = Field();
  236.       flist.add(f);
  237.       jj_consume_token(SEMICOLON_TKN);
  238.       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  239.       case BYTE_TKN:
  240.       case BOOLEAN_TKN:
  241.       case INT_TKN:
  242.       case LONG_TKN:
  243.       case FLOAT_TKN:
  244.       case DOUBLE_TKN:
  245.       case USTRING_TKN:
  246.       case BUFFER_TKN:
  247.       case VECTOR_TKN:
  248.       case MAP_TKN:
  249.       case IDENT_TKN:
  250.         ;
  251.         break;
  252.       default:
  253.         jj_la1[4] = jj_gen;
  254.         break label_4;
  255.       }
  256.     }
  257.     jj_consume_token(RBRACE_TKN);
  258.     String fqn = curModuleName + "." + rname;
  259.     JRecord r = new JRecord(fqn, flist);
  260.     recTab.put(fqn, r);
  261.     {if (true) return r;}
  262.     throw new Error("Missing return statement in function");
  263.   }
  264.   final public JField<JType> Field() throws ParseException {
  265.     JType jt;
  266.     Token t;
  267.     jt = Type();
  268.     t = jj_consume_token(IDENT_TKN);
  269.     {if (true) return new JField<JType>(t.image, jt);}
  270.     throw new Error("Missing return statement in function");
  271.   }
  272.   final public JType Type() throws ParseException {
  273.     JType jt;
  274.     Token t;
  275.     String rname;
  276.     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  277.     case MAP_TKN:
  278.       jt = Map();
  279.       {if (true) return jt;}
  280.       break;
  281.     case VECTOR_TKN:
  282.       jt = Vector();
  283.       {if (true) return jt;}
  284.       break;
  285.     case BYTE_TKN:
  286.       jj_consume_token(BYTE_TKN);
  287.       {if (true) return new JByte();}
  288.       break;
  289.     case BOOLEAN_TKN:
  290.       jj_consume_token(BOOLEAN_TKN);
  291.       {if (true) return new JBoolean();}
  292.       break;
  293.     case INT_TKN:
  294.       jj_consume_token(INT_TKN);
  295.       {if (true) return new JInt();}
  296.       break;
  297.     case LONG_TKN:
  298.       jj_consume_token(LONG_TKN);
  299.       {if (true) return new JLong();}
  300.       break;
  301.     case FLOAT_TKN:
  302.       jj_consume_token(FLOAT_TKN);
  303.       {if (true) return new JFloat();}
  304.       break;
  305.     case DOUBLE_TKN:
  306.       jj_consume_token(DOUBLE_TKN);
  307.       {if (true) return new JDouble();}
  308.       break;
  309.     case USTRING_TKN:
  310.       jj_consume_token(USTRING_TKN);
  311.       {if (true) return new JString();}
  312.       break;
  313.     case BUFFER_TKN:
  314.       jj_consume_token(BUFFER_TKN);
  315.       {if (true) return new JBuffer();}
  316.       break;
  317.     case IDENT_TKN:
  318.       rname = ModuleName();
  319.       if (rname.indexOf('.', 0) < 0) {
  320.         rname = curModuleName + "." + rname;
  321.       }
  322.       JRecord r = recTab.get(rname);
  323.       if (r == null) {
  324.         System.out.println("Type " + rname + " not known. Exiting.");
  325.         System.exit(1);
  326.       }
  327.       {if (true) return r;}
  328.       break;
  329.     default:
  330.       jj_la1[5] = jj_gen;
  331.       jj_consume_token(-1);
  332.       throw new ParseException();
  333.     }
  334.     throw new Error("Missing return statement in function");
  335.   }
  336.   final public JMap Map() throws ParseException {
  337.     JType jt1;
  338.     JType jt2;
  339.     jj_consume_token(MAP_TKN);
  340.     jj_consume_token(LT_TKN);
  341.     jt1 = Type();
  342.     jj_consume_token(COMMA_TKN);
  343.     jt2 = Type();
  344.     jj_consume_token(GT_TKN);
  345.     {if (true) return new JMap(jt1, jt2);}
  346.     throw new Error("Missing return statement in function");
  347.   }
  348.   final public JVector Vector() throws ParseException {
  349.     JType jt;
  350.     jj_consume_token(VECTOR_TKN);
  351.     jj_consume_token(LT_TKN);
  352.     jt = Type();
  353.     jj_consume_token(GT_TKN);
  354.     {if (true) return new JVector(jt);}
  355.     throw new Error("Missing return statement in function");
  356.   }
  357.   public RccTokenManager token_source;
  358.   SimpleCharStream jj_input_stream;
  359.   public Token token, jj_nt;
  360.   private int jj_ntk;
  361.   private int jj_gen;
  362.   final private int[] jj_la1 = new int[6];
  363.   static private int[] jj_la1_0;
  364.   static private int[] jj_la1_1;
  365.   static {
  366.     jj_la1_0();
  367.     jj_la1_1();
  368.   }
  369.   private static void jj_la1_0() {
  370.     jj_la1_0 = new int[] {0x2800, 0x2800, 0x40000000, 0x1000, 0xffc000, 0xffc000,};
  371.   }
  372.   private static void jj_la1_1() {
  373.     jj_la1_1 = new int[] {0x0, 0x0, 0x0, 0x0, 0x1, 0x1,};
  374.   }
  375.   public Rcc(java.io.InputStream stream) {
  376.     this(stream, null);
  377.   }
  378.   public Rcc(java.io.InputStream stream, String encoding) {
  379.     try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
  380.     token_source = new RccTokenManager(jj_input_stream);
  381.     token = new Token();
  382.     jj_ntk = -1;
  383.     jj_gen = 0;
  384.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  385.   }
  386.   public void ReInit(java.io.InputStream stream) {
  387.     ReInit(stream, null);
  388.   }
  389.   public void ReInit(java.io.InputStream stream, String encoding) {
  390.     try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
  391.     token_source.ReInit(jj_input_stream);
  392.     token = new Token();
  393.     jj_ntk = -1;
  394.     jj_gen = 0;
  395.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  396.   }
  397.   public Rcc(java.io.Reader stream) {
  398.     jj_input_stream = new SimpleCharStream(stream, 1, 1);
  399.     token_source = new RccTokenManager(jj_input_stream);
  400.     token = new Token();
  401.     jj_ntk = -1;
  402.     jj_gen = 0;
  403.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  404.   }
  405.   public void ReInit(java.io.Reader stream) {
  406.     jj_input_stream.ReInit(stream, 1, 1);
  407.     token_source.ReInit(jj_input_stream);
  408.     token = new Token();
  409.     jj_ntk = -1;
  410.     jj_gen = 0;
  411.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  412.   }
  413.   public Rcc(RccTokenManager tm) {
  414.     token_source = tm;
  415.     token = new Token();
  416.     jj_ntk = -1;
  417.     jj_gen = 0;
  418.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  419.   }
  420.   public void ReInit(RccTokenManager tm) {
  421.     token_source = tm;
  422.     token = new Token();
  423.     jj_ntk = -1;
  424.     jj_gen = 0;
  425.     for (int i = 0; i < 6; i++) jj_la1[i] = -1;
  426.   }
  427.   final private Token jj_consume_token(int kind) throws ParseException {
  428.     Token oldToken;
  429.     if ((oldToken = token).next != null) token = token.next;
  430.     else token = token.next = token_source.getNextToken();
  431.     jj_ntk = -1;
  432.     if (token.kind == kind) {
  433.       jj_gen++;
  434.       return token;
  435.     }
  436.     token = oldToken;
  437.     jj_kind = kind;
  438.     throw generateParseException();
  439.   }
  440.   final public Token getNextToken() {
  441.     if (token.next != null) token = token.next;
  442.     else token = token.next = token_source.getNextToken();
  443.     jj_ntk = -1;
  444.     jj_gen++;
  445.     return token;
  446.   }
  447.   final public Token getToken(int index) {
  448.     Token t = token;
  449.     for (int i = 0; i < index; i++) {
  450.       if (t.next != null) t = t.next;
  451.       else t = t.next = token_source.getNextToken();
  452.     }
  453.     return t;
  454.   }
  455.   final private int jj_ntk() {
  456.     if ((jj_nt=token.next) == null)
  457.       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
  458.     else
  459.       return (jj_ntk = jj_nt.kind);
  460.   }
  461.   private java.util.Vector<int[]> jj_expentries = new java.util.Vector<int[]>();
  462.   private int[] jj_expentry;
  463.   private int jj_kind = -1;
  464.   public ParseException generateParseException() {
  465.     jj_expentries.removeAllElements();
  466.     boolean[] la1tokens = new boolean[33];
  467.     for (int i = 0; i < 33; i++) {
  468.       la1tokens[i] = false;
  469.     }
  470.     if (jj_kind >= 0) {
  471.       la1tokens[jj_kind] = true;
  472.       jj_kind = -1;
  473.     }
  474.     for (int i = 0; i < 6; i++) {
  475.       if (jj_la1[i] == jj_gen) {
  476.         for (int j = 0; j < 32; j++) {
  477.           if ((jj_la1_0[i] & (1<<j)) != 0) {
  478.             la1tokens[j] = true;
  479.           }
  480.           if ((jj_la1_1[i] & (1<<j)) != 0) {
  481.             la1tokens[32+j] = true;
  482.           }
  483.         }
  484.       }
  485.     }
  486.     for (int i = 0; i < 33; i++) {
  487.       if (la1tokens[i]) {
  488.         jj_expentry = new int[1];
  489.         jj_expentry[0] = i;
  490.         jj_expentries.addElement(jj_expentry);
  491.       }
  492.     }
  493.     int[][] exptokseq = new int[jj_expentries.size()][];
  494.     for (int i = 0; i < jj_expentries.size(); i++) {
  495.       exptokseq[i] = jj_expentries.elementAt(i);
  496.     }
  497.     return new ParseException(token, exptokseq, tokenImage);
  498.   }
  499.   final public void enable_tracing() {
  500.   }
  501.   final public void disable_tracing() {
  502.   }
  503. }