Esempio n. 1
0
  public Expr dropNoncompArgs(Context ctxt) {
    if (ctxt.getFlag("debug_drop_noncomp")) {
      ctxt.w.println("Dropping non-comp arguments from term-app " + toString(ctxt));
      ctxt.w.flush();
    }
    ArrayList nX = new ArrayList();
    ArrayList no = new ArrayList();
    boolean changed = false;
    Boolean b = new Boolean(false);
    for (int i = 0, iend = X.length; i < iend; i++) {
      if (X[i].isProof(ctxt) || specarg[i]) changed = true;
      else {
        nX.add(X[i]);
        no.add(b);
      }
    }

    Expr ret = this;
    if (changed) {
      if (nX.size() == 0) ret = head;
      else ret = new TermApp(head, Parser.toExprArray(nX), Parser.toBooleanArray(no));
    }

    if (ctxt.getFlag("debug_drop_noncomp")) {
      ctxt.w.println("Returning " + ret.toString(ctxt));
      ctxt.w.flush();
    }

    return ret;
  }
Esempio n. 2
0
 public void parseStyleDeclaration(CSSStyleDeclaration sd, InputSource source) throws IOException {
   Stack nodeStack = new Stack();
   nodeStack.push(sd);
   CSSOMHandler handler = new CSSOMHandler(nodeStack);
   _parser.setDocumentHandler(handler);
   _parser.parseStyleDeclaration(source);
 }
Esempio n. 3
0
 public static void main(String[] args) {
   Parser parser = new Parser();
   Label labels = new Label();
   String asmbly;
   int pc = 100;
   try {
     BufferedReader br = new BufferedReader(new FileReader(args[0]));
     String line;
     while ((line = br.readLine()) != null) {
       if (line.contains(":")) labels.fillLabels(line, pc);
       pc++;
     }
   } catch (Exception e) {
     System.out.println("Failed first");
   }
   try {
     BufferedReader br = new BufferedReader(new FileReader(args[0]));
     PrintWriter writer = new PrintWriter("output", "UTF-8");
     String line;
     while ((line = br.readLine()) != null) {
       asmbly = parser.parseLine(line, labels);
       writer.println(asmbly);
     }
     writer.close();
   } catch (Exception e) {
     System.out.println("Failed second");
   }
 }
Esempio n. 4
0
	public void WriteHeader(){
		out.println("\t\t"+Parser.StartingTag("ValidichroHeader"));
		out.println("\t\t\t"+Parser.Tag("Date",experiment_date));
		out.println("\t\t\t"+Parser.Tag("Generic",generic));
		//...
		out.println("\t\t"+Parser.EndingTag("ValidichroHeader"));
	}
Esempio n. 5
0
	public void WriteExported(){
		out.println(Parser.getFileHeader());
		out.println("\t"+Parser.StartingTag("ValidichroData"));
		WriteHeader();
		WriteBody();
		WriteUnparsed();
		out.println("\t"+Parser.EndingTag("ValidichroData"));
	}
Esempio n. 6
0
 public static AST_Imports MakeAST(String in) {
   try {
     Parser parser = Parser.getInstance(new StringReader(in));
     return (AST_Imports) parser.parse("AST_Imports");
   } catch (ParseException pe) {
     AstNode.fatalError("string-to-ast parse error: " + in);
     return null;
   }
 }
Esempio n. 7
0
	public void WriteBody(){
		//@ToDo : Make this proper java!
		//@ToDo Important:  Add missing elements and check existing ones
		//	-	Update:, now refers to values as Unknown1,Uknown2... It's just unknown to me, can't remember what these values represent!
		out.println("\t\t"+Parser.StartingTag("ValidichroBody"));
		for(String line :spectral_table){
			out.println("\t\t\t"+Parser.Tag("SpectralEntry",line));
		}
		out.println("\t\t"+Parser.EndingTag("ValidichroBody"));
	}
Esempio n. 8
0
 public static String parse(File f, BlobStore blobStore, HashStore hashStore)
     throws FileNotFoundException, IOException {
   Parser parser = new Parser();
   FileInputStream fin = null;
   BufferedInputStream bufIn = null;
   try {
     fin = new FileInputStream(f);
     bufIn = new BufferedInputStream(fin);
     return parser.parse(bufIn, hashStore, blobStore);
   } finally {
     IOUtils.closeQuietly(bufIn);
     IOUtils.closeQuietly(fin);
   }
 }
Esempio n. 9
0
  /**
   * Takes in a file name and outputs a Piece represending the song.
   *
   * @param abcFileName
   */
  public Piece buildSong(String abcFileName) {
    // Open up the File
    String fileContent = getFile(abcFileName);

    // Create Lexer, pass string into lexer
    Lexer lexer = new Lexer(fileContent);

    // Pass lexer into Parser to get Piece
    Parser parser = new Parser(lexer);

    Piece toReturn = parser.parse();

    return toReturn;
  }
Esempio n. 10
0
 /**
  * Parses an expression. Returns a object of type Node, does not catch errors. Does not set the
  * topNode variable of the JEP instance. This method should generally be used with the {@link
  * #evaluate evaluate} method rather than getValueAsObject.
  *
  * @param expression represented as a string.
  * @return The top node of a tree representing the parsed expression.
  * @throws ParseException
  * @since 2.3.0 alpha
  * @since 2.3.0 beta - will raise exception if errorList non empty
  */
 public Node parse(String expression) throws ParseException {
   java.io.StringReader sr = new java.io.StringReader(expression);
   errorList.removeAllElements();
   Node node = parser.parseStream(sr, this);
   if (this.hasError()) throw new ParseException(getErrorInfo());
   return node;
 }
Esempio n. 11
0
 public static void work(BufferedReader ir) {
   TestParser testParser = new TestParser();
   try {
     PushbackReader r = new PushbackReader(ir, 1024);
     Parser parser = new Parser(new Lexer(r));
     Node syntaxTree = parser.parse();
     syntaxTree.apply(testParser);
   } catch (LexerException e) {
     System.out.println(e.getMessage() + ".");
   } catch (ParserException e) {
     System.out.println(e.getMessage() + ".");
   } catch (IOException e) {
     System.out.println(e.getMessage() + ".");
     System.exit(1);
   }
 }
Esempio n. 12
0
 public void evaluate() {
   try {
     // clear problems and console messages
     problemsView.setText("");
     consoleView.setText("");
     // update status view
     statusView.setText(" Parsing ...");
     tabbedPane.setSelectedIndex(0);
     LispExpr root = Parser.parse(textView.getText());
     statusView.setText(" Running ...");
     tabbedPane.setSelectedIndex(1);
     // update run button
     runButton.setIcon(stopImage);
     runButton.setActionCommand("Stop");
     // start run thread
     runThread = new RunThread(root);
     runThread.start();
   } catch (SyntaxError e) {
     tabbedPane.setSelectedIndex(0);
     System.err.println(
         "Syntax Error at " + e.getLine() + ", " + e.getColumn() + " : " + e.getMessage());
   } catch (Error e) {
     // parsing error
     System.err.println(e.getMessage());
     statusView.setText(" Errors.");
   }
 }
Esempio n. 13
0
        public void ParseSpectralEntry(String line){
		//@ToDo, take all values (there are 7)
		//	Update	-	now takes all values, but calls them Unknown1,2,3,4 I need to find out what these values represent!
		//Not production safe!
		String table_ent=Parser.getTableRow(line,new String[]{"WaveLength","Smooth","Unsmooth","Unknown1","Unknown2","Uknown3","Unknown4"});
		spectral_table.add(table_ent);
        }
 /*.................................................................................................................*/
 public Object doCommand(String commandName, String arguments, CommandChecker checker) {
   if (checker.compare(
       this.getClass(), "Sets the username", "[username]", commandName, "setUsername")) {
     username = parser.getFirstToken(arguments);
   }
   return null;
 }
Esempio n. 15
0
  /**
   * Static service to get a term from its string representation, providing a specific operator
   * manager
   */
  public static Term parseSingleTerm(String st, OperatorManager op) throws InvalidTermException {
    try {
      Parser p = new Parser(op, st);
      Token t = p.tokenizer.readToken();
      if (t.isEOF()) throw new InvalidTermException("Term starts with EOF");

      p.tokenizer.unreadToken(t);
      Term term = p.expr(false);
      if (term == null) throw new InvalidTermException("Term is null");
      if (!p.tokenizer.readToken().isEOF())
        throw new InvalidTermException("The entire string could not be read as one term");
      term.resolveTerm();
      return term;
    } catch (IOException ex) {
      throw new InvalidTermException("An I/O error occured");
    }
  }
  public static HashMap<String, Test> processScriptFile(File file) {
    HashMap<String, Test> tests = new HashMap<String, Test>();
    try {
      Parser parser = new Parser(new Lexer(new PushbackReader(new FileReader(file))));
      Start root = parser.parse();
      AScript a1 = (AScript) root.getPScript();
      for (PScriptTail tail : a1.getScriptTail()) {
        AScriptTail a2 = (AScriptTail) tail;
        Test test = TestBuilder.buildTest(a2.getTest());
        tests.put(test.getName(), test);
      }

      System.out.println("SUCESSFULLY PARSED!");
    } catch (Exception e) {
      System.err.println(e.getMessage());
    }
    return tests;
  }
Esempio n. 17
0
  /**
   * Parses and returns a valid 'leftside' of an expression. If the left side starts with a prefix,
   * it consumes other expressions with a lower priority than itself. If the left side does not have
   * a prefix it must be an expr0.
   *
   * @param commaIsEndMarker used when the leftside is part of and argument list of expressions
   * @param maxPriority operators with a higher priority than this will effectivly end the
   *     expression
   * @return a wrapper of: 1. term correctly structured and 2. the priority of its root operator
   * @throws InvalidTermException
   */
  private IdentifiedTerm parseLeftSide(boolean commaIsEndMarker, int maxPriority)
      throws InvalidTermException, IOException {
    // 1. prefix expression
    Token f = tokenizer.readToken();
    if (f.isOperator(commaIsEndMarker)) {
      int FX = opManager.opPrio(f.seq, "fx");
      int FY = opManager.opPrio(f.seq, "fy");

      if (f.seq.equals("-")) {
        Token t = tokenizer.readToken();
        if (t.isNumber())
          /*Michele Castagna 06/2011*/
          // return new IdentifiedTerm(0, Parser.createNumber("-" + t.seq));
          return identifyTerm(0, Parser.createNumber("-" + t.seq), tokenStart);
        /**/
        else tokenizer.unreadToken(t);
      }

      // check that no operator has a priority higher than permitted
      if (FY > maxPriority) FY = -1;
      if (FX > maxPriority) FX = -1;

      // FX has priority over FY
      boolean haveAttemptedFX = false;
      if (FX >= FY && FX >= OperatorManager.OP_LOW) {
        IdentifiedTerm found = exprA(FX - 1, commaIsEndMarker); // op(fx, n) exprA(n - 1)
        if (found != null)
          /*Castagna 06/2011*/
          // return new IdentifiedTerm(FX, new Struct(f.seq, found.result));
          return identifyTerm(FX, new Struct(f.seq, found.result), tokenStart);
        /**/
        else haveAttemptedFX = true;
      }
      // FY has priority over FX, or FX has failed
      if (FY >= OperatorManager.OP_LOW) {
        IdentifiedTerm found =
            exprA(FY, commaIsEndMarker); // op(fy,n) exprA(1200)  or   op(fy,n) exprA(n)
        if (found != null)
          /*Castagna 06/2011*/
          // return new IdentifiedTerm(FY, new Struct(f.seq, found.result));
          return identifyTerm(FY, new Struct(f.seq, found.result), tokenStart);
        /**/
      }
      // FY has priority over FX, but FY failed
      if (!haveAttemptedFX && FX >= OperatorManager.OP_LOW) {
        IdentifiedTerm found = exprA(FX - 1, commaIsEndMarker); // op(fx, n) exprA(n - 1)
        if (found != null)
          /*Castagna 06/2011*/
          // return new IdentifiedTerm(FX, new Struct(f.seq, found.result));
          return identifyTerm(FX, new Struct(f.seq, found.result), tokenStart);
        /**/
      }
    }
    tokenizer.unreadToken(f);
    // 2. expr0
    return new IdentifiedTerm(0, expr0());
  }
Esempio n. 18
0
 public void reset() {
   this.lookupEnvironment.reset();
   // GROOVY start: give the parser a chance to reset as well
   parser.reset();
   // GROOVY end
   this.parser.scanner.source = null;
   this.unitsToProcess = null;
   if (DebugRequestor != null) DebugRequestor.reset();
   this.problemReporter.reset();
 }
 /*.................................................................................................................*/
 public Object doCommand(String commandName, String arguments, CommandChecker checker) {
   if (checker.compare(
       this.getClass(),
       "Sets the running file path",
       "[file path]",
       commandName,
       "setRunningFilePath")) {
     runningFilePath = parser.getFirstToken(arguments);
   } else if (checker.compare(
       this.getClass(),
       "Sets the output file paths",
       "[file paths]",
       commandName,
       "setOutputFilePaths")) {
     int num = parser.getNumberOfTokens(arguments);
     outputFilePaths = new String[num];
     if (num > 0) outputFilePaths[0] = parser.getFirstToken();
     for (int i = 1; i < num; i++) outputFilePaths[i] = parser.getNextToken();
   }
   return null;
 }
Esempio n. 20
0
  public static void parse(File sourceFile) throws Exception {
    if (ByteCodeTranslator.verbose) {
      System.out.println("Parsing: " + sourceFile.getAbsolutePath());
    }
    ClassReader r = new ClassReader(new FileInputStream(sourceFile));
    /*if(ByteCodeTranslator.verbose) {
        System.out.println("Class: " + r.getClassName() + " derives from: " + r.getSuperName() + " interfaces: " + Arrays.asList(r.getInterfaces()));
    }*/
    Parser p = new Parser();
    p.clsName = r.getClassName().replace('/', '_').replace('$', '_');
    if (p.clsName.startsWith("java_lang_annotation")
        || p.clsName.startsWith("java_lang_Deprecated")
        || p.clsName.startsWith("java_lang_Override")
        || p.clsName.startsWith("java_lang_SuppressWarnings")) {
      return;
    }
    p.cls = new ByteCodeClass(p.clsName);
    r.accept(p, ClassReader.EXPAND_FRAMES);

    classes.add(p.cls);
  }
Esempio n. 21
0
 private void parseMapsXml() {
   try {
     String fileName = LocationLoader.getLocationDir(NavigineApp.AppContext, null) + "/maps.xml";
     List<LocationInfo> infoList = Parser.parseMapsXml(NavigineApp.AppContext, fileName);
     mInfoList = new ArrayList<LocationInfo>();
     if (infoList != null) mInfoList = infoList;
     mAdapter.updateList();
     new File(fileName).delete();
   } catch (Throwable e) {
     Log.e(TAG, Log.getStackTraceString(e));
   }
 }
Esempio n. 22
0
  public JavaProgram createJavaProgram(
      List sourceFiles,
      String libraryPath,
      String mainClassname,
      String projectType,
      String policyType)
      throws Exception {
    // Debug.setOn(true);
    long l = Debug.getTime();
    LibraryData libraryData = new LibraryData(new File(libraryPath), projectType, language, false);
    Library library = new Library(libraryData);
    Parser parser =
        Parser.createParser(this.language, sourceFiles, library, new TranslationPolicy(policyType));

    long lll = Debug.getTime();
    System.out.println("Library Loaded in " + (lll - l) + "ms");

    ParseTree tree = parser.parse();
    TranslationReport report = tree.getTranslationReport();

    long ll = Debug.getTime();
    System.out.println("Code parsed in " + (ll - lll) + "ms");
    Debug.setOn(true);

    Translator tt = new Translator(this.language);
    JavaProgram jp = tt.createJavaProgram(tree, mainClassname, projectType);

    if (report.hasTypeResolveErrors() || report.hasTranslationWarnings()) {
      List errors = new ArrayList();
      errors.addAll(report.getTypeResolveExceptions());
      report.doReport(errors, report.getTranslationWarnings());
    }

    l = Debug.getTime();
    System.out.println("Translated in " + (l - ll) + "ms");

    jp.setTypeResolved(!report.hasTypeResolveErrors()); // resolved if no errors

    return jp;
  }
Esempio n. 23
0
  public static void main(String args[]) {
    try {
      System.out.println("Type in a tiny exp folowed by one or two Ctrl-d's:");
      Parser p = new Parser(new Lexer(new PushbackReader(new InputStreamReader(System.in), 1024)));

      Start tree = p.parse();
      NewEval.replaceUminus(tree);
      /* pretty-print */
      System.out.println("\nThe result of evaluating:");
      PrettyPrinter.print(tree);

      /* pre-eval to replace uminus */

      /* evaluate */
      System.out.print("\nis: ");
      PrettyPrinter.print(Evaluator.eval(tree));
      System.out.println("\n");

    } catch (Exception e) {
      System.out.println(e);
    }
  }
Esempio n. 24
0
  public static void main(String[] args) throws IOException {
    String filename = "z.xml"; // NOT LOCALIZABLE, main

    try {
      String uri = "file:" + new File(filename).getAbsolutePath(); // NOT LOCALIZABLE, main

      //
      // turn it into an in-memory object.
      //
      Parser parser = getParser();
      parser.setDocumentHandler(new XmlParser());
      parser.setErrorHandler(new MyErrorHandler());
      parser.parse(uri);

    } catch (SAXParseException err) {
      Debug.trace(
          "** Parsing error" // NOT LOCALIZABLE, main
              + ", line "
              + err.getLineNumber() // NOT LOCALIZABLE
              + ", uri "
              + err.getSystemId()); // NOT LOCALIZABLE
      Debug.trace("   " + err.getMessage());

    } catch (SAXException e) {
      Exception x = e;
      if (e.getException() != null) x = e.getException();
      x.printStackTrace();

    } catch (Throwable t) {
      t.printStackTrace();
    }

    byte[] buf = new byte[256];
    Debug.trace("Press ENTER to exit."); // NOT LOCALIZABLE
    System.in.read(buf, 0, 256);
    System.exit(0);
  }
Esempio n. 25
0
 public void prettyPrint() {
   try {
     // clear old problem messages
     problemsView.setText("");
     // update status view
     statusView.setText(" Parsing ...");
     LispExpr root = Parser.parse(textView.getText());
     statusView.setText(" Pretty Printing ...");
     String newText = PrettyPrinter.prettyPrint(root);
     textView.setText(newText);
     statusView.setText(" Done.");
   } catch (Error e) {
     System.err.println(e.getMessage());
     statusView.setText(" Errors.");
   }
 }
Esempio n. 26
0
  public static void test1() {
    Sequence[] seqs = Parser.test1();
    double[][] distances = (new GappedHammingDistance()).getDistanceMatrix(seqs);
    DecimalFormat f = new DecimalFormat("0000.000");

    System.out.println("   " + seqs.length);

    for (int i = 0; i < seqs.length; i++) {
      System.out.print(seqs[i].name);
      for (int k = 0; k < 10 - seqs[i].name.length(); k++) {
        System.out.print(" ");
      }
      System.out.print("  ");
      int cols = 1;
      for (int j = 0; j < seqs.length; j++) {
        if (i != j) {
          int di = i;
          int dj = j;
          // force symmetric matrix - arg - what the???
          // testing!!!
          if (j > i) {
            di = j;
            dj = i;
          }
          double d = distances[di][dj];
          // testing
          if (d > 2000) {
            System.err.println("ARGH");
          }
          System.out.print(f.format(d));
        } else {
          System.out.print(f.format(0));
        }
        System.out.print("  ");
        cols++;
        if (cols >= 7) {
          System.out.println();
          System.out.print("  ");
          cols = 0;
        }
      }
      if (cols != 7) {
        System.out.println();
      }
    }
  }
Esempio n. 27
0
  /**
   * Parses the expression. If there are errors in the expression, they are added to the <code>
   * errorList</code> member. Errors can be obtained through <code>getErrorInfo()</code>.
   *
   * @param expression_in The input expression string
   * @return the top node of the expression tree if the parse was successful, <code>null</code>
   *     otherwise
   */
  public Node parseExpression(String expression_in) {
    Reader reader = new StringReader(expression_in);

    try {
      // try parsing
      errorList.removeAllElements();
      topNode = parser.parseStream(reader, this);

      // if there is an error in the list, the parse failed
      // so set topNode to null
      if (hasError()) topNode = null;
    } catch (Throwable e) {
      // an exception was thrown, so there is no parse tree
      topNode = null;

      // check the type of error
      if (e instanceof ParseException) {
        // the ParseException object contains additional error
        // information
        errorList.addElement(((ParseException) e).getMessage());
        // getErrorInfo());
      } else {
        // if the exception was not a ParseException, it was most
        // likely a syntax error
        if (debug) {
          System.out.println(e.getMessage());
          e.printStackTrace();
        }
        errorList.addElement("Syntax error");
      }
    }

    // If traversing is enabled, print a dump of the tree to
    // standard output
    if (traverse && !hasError()) {
      ParserVisitor v = new ParserDumpVisitor();
      try {
        topNode.jjtAccept(v, null);
      } catch (ParseException e) {
        errorList.addElement(e.getMessage());
      }
    }

    return topNode;
  }
Esempio n. 28
0
  @SuppressWarnings("deprecation")
  public static void main(String[] args) throws java.lang.Exception {
    try {

      String zipCode = ReadInput();

      WeatherProxy proxy = new WeatherProxy();
      String weatherData = proxy.getWeatherForZip(zipCode);

      String cityStateTemp = Parser.GetCityStateTemperature(weatherData);
      System.out.println(cityStateTemp);

    } catch (NumberFormatException e) {
      System.out.println("invalid zip code format");
    } catch (Exception e) {
      System.out.println(e);
    }
  }
Esempio n. 29
0
  private void test(Parser p, DataSet d) {

    int dsize = d.size();
    testSize = dsize;

    for (int i = 0; i < dsize; i++) {

      String words = d.sent(i);
      Exp sem = d.sem(i);
      if (verbose) {
        System.out.println(
            i + ": ==================(" + correctParses + " -- " + wrongParses + ")");
        System.out.println(words);
        System.out.println(sem);
      }

      String mes = null;
      if (verbose) mes = "Test";
      p.parseTimed(words, null, mes);
      isCorrect(words, sem, p);
    }
  }
Esempio n. 30
0
 // bindKeyToCommand binds a given key sequence to a Lisp command
 // so that pressing the key sequence executes the command.
 public void bindKeyToCommand(String keySequence, String cmd) {
   bindKeyToCommand(keySequence, Parser.parse(cmd));
 }