Source code
/*
* TypeScript definitions to Java translator - http://www.jsweet.org
* Copyright (C) 2015 CINCHEO SAS <renaud.pawlak@cincheo.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
package org.jsweet.input.typescriptdef.parser;
public class GenParser {
public static void main(String[] args) throws Exception {
java_cup.Main.main(new String[] { "-expect", "0", "-package", "org.jsweet.input.typescriptdef.parser", "-expect", "0", "-parser", "TypescriptDefParser",
"typescriptdef.cup" });
JFlex.Main.main(new String[] { "typescriptdef.lex" });
}
}
Run 1
The code is concise and well-structured with a clear purpose, generating parser and lexer files. It has minimal nesting and one action per method, aiding readability. However, some ambiguity exists: the repeated '-expect 0' flag in the argument array could confuse readers, and the long parameter list lacks formatting. Magic strings for file names and package names slightly diminish clarity, though the overall intent is straightforward.
Run 2
The code is highly readable due to its simplicity and clarity. It has a logical structure with a single class and a concise main method. Nesting is minimal, with only method calls inside an array. The intent is unambiguous: generating parser files via Java CUP and JFlex. Code length is appropriate, with no unnecessary verbosity. Action granularity is good, with one logical operation per line. Reading flow is natural, progressing from the cup generation to the lexer generation. Minor deductions: the duplicated '-expect', '0' argument is slightly redundant, and the long single-line file paths and arguments reduce readability slightly. Overall, the code is clear and maintainable.
Run 3
The code is highly readable due to its simple structure, clear intent, and minimal nesting. The main method directly invokes two parser-generation tools with explicit string arguments, and each tool call occupies its own logical block. Action granularity is reasonable, though the java_cup.Main.main line contains many arguments on one line, slightly reducing readability. The license header adds length but is standard boilerplate and clearly separated from the logic. Overall, the code is concise, flat, and straightforward with no ambiguity.
Run 1
Code Structure: A single class and entry point logically group the parser and lexer generation steps. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Generator calls and filenames convey the purpose, although the abbreviated class name and unexplained command-line options slightly reduce clarity. Code length: The implementation is concise; the lengthy license header is conventional rather than unnecessary logic. Action granularity: Each generator invocation is a separate statement, keeping actions distinct. Reading flow: The two calls follow a straightforward sequence, but the long argument-array line and duplicated '-expect', '0' option introduce minor visual clutter.
Run 2
Code Structure: A single class and entry point logically group parser and lexer generation. Nesting: No nested control flow, making the code easy to scan. Clarity of intent: Class and tool names reveal the purpose, though the generation sequence and command-line options lack explanation; the duplicated '-expect', '0' pair is distracting. Code length: The implementation is concise; the lengthy license header is standard boilerplate rather than unnecessary implementation. Action granularity: Each statement performs one generation action, although the parser invocation packs many arguments onto a long line. Reading flow: Execution proceeds naturally from parser generation to lexer generation, with only the dense argument formatting slightly interrupting readability.
Run 3
Code Structure: A simple class with one entry point logically groups parser and lexer generation. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Generator names, arguments, and filenames communicate the purpose, though GenParser is abbreviated and the duplicated '-expect', '0' option is distracting. Code length: The executable code is concise; the lengthy license header is standard boilerplate rather than unnecessary implementation. Action granularity: Each generator invocation is a separate statement, although the first invocation packs many arguments into a long line. Reading flow: Parser generation followed by lexer generation is straightforward, but cleaner argument formatting would improve readability.