├── input.txt ├── javascript ├── js_transpiler │ ├── java_translator.java │ ├── jison_parsers │ │ ├── javascript_parser.js │ │ ├── regex_parser.jison │ │ ├── antlr_parser.jison │ │ ├── txl_parser.jison │ │ ├── marpa_parser.jison │ │ ├── nearley_parser.jison │ │ ├── ometa_parser.jison │ │ ├── racc_parser.jison │ │ ├── ohm_parser.jison │ │ ├── pegjs_parser.jison │ │ ├── jison_parser.jison │ │ ├── protobuf_parser.jison │ │ ├── thrift_parser.jison │ │ ├── hy_parser.jison │ │ ├── pddl_parser.jison │ │ ├── picat_parser.jison │ │ ├── clojure_parser.jison │ │ ├── core_logic_parser.jison │ │ ├── tptp_parser.jison │ │ ├── coq_parser.jison │ │ ├── tex_parser.jison │ │ ├── kif_parser.jison │ │ ├── smt_lib_parser.jison │ │ └── emacs_lisp_parser.jison │ ├── peggy_parsers │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-04215313292338995765 │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-09705600126022506657 │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-42971930776886479997 │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-51392489504139504675 │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-61563784729200476953 │ │ ├── test_peggy_parsers_bundle.js.tmp-browserify-80944327202963184398 │ │ └── code_generators.js │ ├── typescript-to-glsl │ │ └── typescript-to-glsl │ │ │ └── README.md │ └── example_files.html ├── pegjs_test.html └── runtime_type_inference.js ├── Makefile ├── php └── transpiler.php ├── translated_functions ├── translated_functions.erl ├── a.exe ├── python_functions.pl ├── prolog │ └── python_functions.pl ├── cpp │ ├── javascript.o │ ├── javascript.cpp │ ├── prolog.cpp │ └── translated_functions.cpp ├── python_functions.hi ├── python_functions.o ├── python_functions.exe ├── translated_functions.exe ├── translated_functions.o ├── __pycache__ │ └── java_interpreter.cpython-36.pyc ├── python_functions.hs ├── translated_functions.glsl ├── glsl │ ├── translated_functions.glsl │ └── prolog.glsl ├── translated_functions.cpp ├── translated_functions.fut ├── translated_functions.rb ├── javascript_functions.java ├── translated_functions.cs ├── translated_functions.php ├── translated_functions.lua └── translated_functions.js ├── generic_functions.o ├── generic_functions.exe ├── code_generators ├── code_generator.lua ├── code_generator.ts ├── code_generator.scala ├── code_generator.hpp ├── code_generator.hs ├── code_generator.erl └── Code_Generator.java ├── python ├── __pycache__ │ └── transpiler.cpython-36.pyc └── transpiler.py ├── .travis.yml ├── tests.pl~ ├── pack.pl ├── prolog ├── anything_to_python.pl ├── simplified translator │ ├── common_grammar.pl │ ├── tokenizer.pl │ ├── optimized_javascript_parser.pl │ ├── input.txt │ ├── tests.pl │ ├── ruby_source.rb │ ├── output.txt │ ├── php_source.php │ ├── javascript_source.js │ └── java_source.java ├── common_grammar.pl ├── optimized_java_parser │ ├── common_grammar.pl │ ├── parentheses_expr.pl │ ├── class_statement.pl │ ├── dot_expr.pl │ ├── statement.pl │ └── statement_with_semicolon.pl ├── optimized_javascript_parser │ ├── common_grammar.pl │ ├── parentheses_expr.pl │ ├── class_statement.pl │ ├── dot_expr.pl │ ├── statement.pl │ └── statement_with_semicolon.pl ├── optimized_python_parser │ ├── common_grammar.pl │ ├── parentheses_expr.pl │ ├── class_statement.pl │ ├── dot_expr.pl │ ├── statement.pl │ └── statement_with_semicolon.pl ├── parentheses_expr.pl ├── class_statement.pl ├── dot_expr.pl ├── statement.pl └── statement_with_semicolon.pl ├── tests.pl ├── generic_functions.c ├── LICENSE.txt └── map.h /input.txt: -------------------------------------------------------------------------------- 1 | 2 | var a = 1; 3 | -------------------------------------------------------------------------------- /javascript/js_transpiler/java_translator.java: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/javascript_parser.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | test: 2 | swipl -s tests.pl -g run_tests,halt -t 'halt(1)' 3 | -------------------------------------------------------------------------------- /php/transpiler.php: -------------------------------------------------------------------------------- 1 | use PhpParser; 2 | // https://github.com/nikic/PHP-Parser 3 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.erl: -------------------------------------------------------------------------------- 1 | len(A) -> 2 | array:length(A). 3 | -------------------------------------------------------------------------------- /generic_functions.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/generic_functions.o -------------------------------------------------------------------------------- /generic_functions.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/generic_functions.exe -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-04215313292338995765: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-09705600126022506657: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-42971930776886479997: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-51392489504139504675: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-61563784729200476953: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/test_peggy_parsers_bundle.js.tmp-browserify-80944327202963184398: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /translated_functions/a.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/a.exe -------------------------------------------------------------------------------- /translated_functions/python_functions.pl: -------------------------------------------------------------------------------- 1 | any(A) :- member(true,A). 2 | all(B) :- forall(B,member(A,B)). 3 | -------------------------------------------------------------------------------- /translated_functions/prolog/python_functions.pl: -------------------------------------------------------------------------------- 1 | any(A) :- member(true,A). 2 | all(B) :- forall(B,member(A,B)). 3 | -------------------------------------------------------------------------------- /code_generators/code_generator.lua: -------------------------------------------------------------------------------- 1 | function ternary_operator(a,b,c) 2 | return a .. "?" .. b .. ":" .. c 3 | end 4 | -------------------------------------------------------------------------------- /translated_functions/cpp/javascript.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/cpp/javascript.o -------------------------------------------------------------------------------- /javascript/js_transpiler/typescript-to-glsl/typescript-to-glsl/README.md: -------------------------------------------------------------------------------- 1 | # typescript-to-glsl 2 | A Typescript to GLSL compiler 3 | -------------------------------------------------------------------------------- /translated_functions/python_functions.hi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/python_functions.hi -------------------------------------------------------------------------------- /translated_functions/python_functions.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/python_functions.o -------------------------------------------------------------------------------- /translated_functions/python_functions.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/python_functions.exe -------------------------------------------------------------------------------- /code_generators/code_generator.ts: -------------------------------------------------------------------------------- 1 | function ternary_operator(a:String,b:String,c:String):String{ 2 | return a + "?" + b + ":" + c; 3 | } 4 | -------------------------------------------------------------------------------- /python/__pycache__/transpiler.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/python/__pycache__/transpiler.cpython-36.pyc -------------------------------------------------------------------------------- /translated_functions/translated_functions.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/translated_functions.exe -------------------------------------------------------------------------------- /translated_functions/translated_functions.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/translated_functions.o -------------------------------------------------------------------------------- /code_generators/code_generator.scala: -------------------------------------------------------------------------------- 1 | 2 | def ternary_operator(a:String,b:String,c:String):String = { 3 | return a + "?" + b + ":" + c 4 | } 5 | -------------------------------------------------------------------------------- /code_generators/code_generator.hpp: -------------------------------------------------------------------------------- 1 | std::string ternary_operator(std::string a,std::string b,std::string c){ 2 | return a + "?" + b + ":" + c; 3 | } 4 | -------------------------------------------------------------------------------- /translated_functions/__pycache__/java_interpreter.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jarble/transpiler/HEAD/translated_functions/__pycache__/java_interpreter.cpython-36.pyc -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | before_script: 2 | - sudo apt-add-repository ppa:swi-prolog/devel -y 3 | - sudo apt-get update -q 4 | - sudo apt-get install swi-prolog-nox 5 | 6 | script: make test 7 | -------------------------------------------------------------------------------- /code_generators/code_generator.hs: -------------------------------------------------------------------------------- 1 | 2 | ternary_operator::String -> String -> String -> String -> String 3 | ternary_operator lang a b c = 4 | (if (elem ["java"] lang) then 5 | "(" ++ a ++ "?" ++ b ++ ":" ++ c ++ ")") 6 | -------------------------------------------------------------------------------- /code_generators/code_generator.erl: -------------------------------------------------------------------------------- 1 | 2 | ternary_operator(Lang,A,B,C) -> 3 | if lists:member(Lang,["java"]) -> 4 | string:concat(string:concat(string:concat(string:concat(string:concat(string:concat("(",A),"?"),B),":"),C),")") 5 | end. 6 | -------------------------------------------------------------------------------- /javascript/js_transpiler/peggy_parsers/code_generators.js: -------------------------------------------------------------------------------- 1 | //import this file into each peggy parser 2 | 3 | function member(lang,list){ 4 | return list.indexOf(lang) !== -1; 5 | } 6 | 7 | export function concatenate_string(lang){ 8 | 9 | } 10 | -------------------------------------------------------------------------------- /translated_functions/python_functions.hs: -------------------------------------------------------------------------------- 1 | main = print ((1::Object) + (2::Object)) 2 | 3 | data Object = Int 4 | 5 | class Python a where 6 | (+) :: a -> a -> a 7 | 8 | instance Python Object where 9 | (+) a b = (a::Object) + (b::Object) 10 | -------------------------------------------------------------------------------- /tests.pl~: -------------------------------------------------------------------------------- 1 | :- use_module(prolog/transpiler). 2 | :- use_module(library(func)). 3 | :- set_prolog_flag(double_quotes,chars). 4 | :- initialization(main). 5 | 6 | main :- 7 | File='input.txt',read_file_to_codes(File,Input_,[]),atom_codes(Input,Input_), 8 | writeln(Input),translate_langs(Input). 9 | -------------------------------------------------------------------------------- /code_generators/Code_Generator.java: -------------------------------------------------------------------------------- 1 | 2 | public class Code_Generator{ 3 | public static String ternary_operator(String lang,String a,String b,String c){ 4 | if(new ArrayList<>(Arrays.asList("java")).contains(lang)){ 5 | return "(" + a + "?" + b + ":" + c + ")"; 6 | } 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /pack.pl: -------------------------------------------------------------------------------- 1 | name('transpiler'). 2 | title('A universal translator for programming languages'). 3 | 4 | version('0.1'). 5 | download('https://github.com/jarble/transpiler/archive/v0.1.zip'). 6 | 7 | 8 | author('Anderson Green','jarble@gmail.com'). 9 | packager('Anderson Green','jarble@gmail.com'). 10 | maintainer('Anderson Green','jarble@gmail.com'). 11 | 12 | home('https://github.com/jarble/transpiler/'). 13 | -------------------------------------------------------------------------------- /translated_functions/cpp/javascript.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | enum types {Number,String}; 6 | 7 | class Object { 8 | public: 9 | std::string str; 10 | float number; 11 | types type; 12 | Object(float f){ 13 | number = f; 14 | type = Number; 15 | } 16 | Object(std::string the_str){ 17 | str = the_str; 18 | type = String; 19 | } 20 | Object type_of(Object the_obj){ 21 | if(the_obj.type == Number){ 22 | return Object("number"); 23 | } 24 | } 25 | }; 26 | -------------------------------------------------------------------------------- /javascript/js_transpiler/example_files.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 9 | 10 | 13 | 14 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /prolog/anything_to_python.pl: -------------------------------------------------------------------------------- 1 | %Copyright 2016, Anderson Green 2 | 3 | :- set_prolog_flag(double_quotes,chars). 4 | :- initialization(main). 5 | %If X is an animal, then X is a bird or a mammal, and vice-versa. 6 | :- use_module(library(chr)). 7 | 8 | :- chr_constraint type/2. 9 | 10 | species(X,X1),species(X,X2) <=> X1 = X2. 11 | 12 | animal(X) <=> 13 | (mammal(X);bird(X)), 14 | (male(X);female(X)). 15 | 16 | male(X),female(X) ==> false. 17 | 18 | bird(X) <=> species(X,pigeon);species(X,parrot). 19 | 20 | mammal(X) <=> species(X,dog);species(X,cat);species(X,bull). 21 | 22 | species(X,bull) ==> male(X). 23 | 24 | main :- species(X,bull), age(X,20), age(X,13), writeln(X). 25 | -------------------------------------------------------------------------------- /python/transpiler.py: -------------------------------------------------------------------------------- 1 | import phply # to parse PHP 2 | import pyjsparser #to parse JavaScript 3 | import luaparser # to parse Lua 4 | import pycparser # to parse C 5 | 6 | import rpython #to translate Python to C 7 | import jiphy 8 | import transcrypt # to translate Python to JavaScript 9 | 10 | from pampy import match, HEAD, TAIL, _ 11 | 12 | def fibonacci(n): 13 | return match(n, 14 | 1, 1, 15 | 2, 1, 16 | _, lambda x: fibonacci(x-1) + fibonacci(x-2) 17 | ) 18 | 19 | print(fibonacci(3)) 20 | 21 | x = [1, 2, 3] 22 | 23 | print(match([1], [1, TAIL], lambda t: t)) # => [2, 3] 24 | 25 | print(match([1], [HEAD, TAIL], lambda h, t: (h, t))) # => (1, [2, 3]) 26 | -------------------------------------------------------------------------------- /tests.pl: -------------------------------------------------------------------------------- 1 | :-style_check(-singleton). 2 | :- use_module(prolog/transpiler). 3 | :- set_prolog_flag(double_quotes,chars). 4 | :- initialization(main). 5 | :- use_module(library(prolog_stack)). 6 | :- use_module(library(error)). 7 | 8 | user:prolog_exception_hook(Exception, Exception, Frame, _):- 9 | ( Exception = error(Term) 10 | ; Exception = error(Term, _)), 11 | get_prolog_backtrace(Frame, 20, Trace), 12 | format(user_error, 'Error: ~p', [Term]), nl(user_error), 13 | print_prolog_backtrace(user_error, Trace), nl(user_error), fail. 14 | 15 | main :- 16 | File='input.txt',read_file_to_codes(File,Input_,[]),atom_codes(Input,Input_), 17 | writeln(Input),profile(translate_langs(Input)). 18 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.glsl: -------------------------------------------------------------------------------- 1 | 2 | struct Math_{ 3 | float PI; 4 | float E; 5 | int sin; 6 | int cos; 7 | int tan; 8 | int min; 9 | int max; 10 | int pow; 11 | int exp; 12 | }; 13 | 14 | struct java_{ 15 | Math_ Math; 16 | }; 17 | 18 | struct Python{ 19 | Math_ math; 20 | }; 21 | 22 | struct Lua{ 23 | Math_ math; 24 | }; 25 | 26 | java_ java = java_(Math_(PI,2.718281828459045,1,2,3,4,5)); 27 | lua_ lua = lua_(Math_(java.Math.PI,java.math.E,java.Math.sin,java.Math.cos,java.Math.tan,java.Math.min,java.Math.max,java.Math.pow,java.Math.exp)); 28 | python_ python = python_(Math_(java.Math.PI,java.math.E,java.Math.sin,java.Math.cos,java.Math.tan,java.Math.min,java.Math.max,java.Math.pow,java.Math.exp)); 29 | -------------------------------------------------------------------------------- /translated_functions/glsl/translated_functions.glsl: -------------------------------------------------------------------------------- 1 | 2 | 3 | struct Math_{ 4 | float PI; 5 | float E; 6 | int sin; 7 | int cos; 8 | int tan; 9 | int min; 10 | int max; 11 | int pow; 12 | int exp; 13 | }; 14 | 15 | struct java_{ 16 | Math_ Math; 17 | }; 18 | 19 | struct Python{ 20 | Math_ math; 21 | }; 22 | 23 | struct Lua{ 24 | Math_ math; 25 | }; 26 | 27 | java_ java = java_(Math_(PI,2.718281828459045,1,2,3,4,5)); 28 | lua_ lua = lua_(Math_(java.Math.PI,java.math.E,java.Math.sin,java.Math.cos,java.Math.tan,java.Math.min,java.Math.max,java.Math.pow,java.Math.exp)); 29 | python_ python = python_(Math_(java.Math.PI,java.math.E,java.Math.sin,java.Math.cos,java.Math.tan,java.Math.min,java.Math.max,java.Math.pow,java.Math.exp)); 30 | 31 | call() 32 | -------------------------------------------------------------------------------- /translated_functions/glsl/prolog.glsl: -------------------------------------------------------------------------------- 1 | 2 | struct Object{ 3 | int type; 4 | int int1; 5 | float float1; 6 | bool bool1; 7 | }; 8 | 9 | 10 | 11 | Object new(){ 12 | Object self; 13 | self.type = 0; 14 | return self; 15 | } 16 | 17 | Object new(int int1){ 18 | Object self; 19 | self.int1 = int1; 20 | self.type = 1; 21 | return self; 22 | } 23 | Object new(float float1){ 24 | Object new; 25 | new.float1 = float1; 26 | new.type = 1; 27 | return new; 28 | } 29 | Object new(bool bool1){ 30 | Object self; 31 | self.bool1 = bool1; 32 | self.type = 2; 33 | return self; 34 | } 35 | 36 | bool var(Object self){ 37 | return self.type == 0; 38 | } 39 | bool nonvar(Object self){ 40 | return !var(self); 41 | } 42 | -------------------------------------------------------------------------------- /generic_functions.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | #include "map.h" //MAP and MAP_LIST macros 6 | 7 | #define type_to_string(x) x: #x "\n" 8 | 9 | // get the variable's type as a string 10 | #define get_type(X) _Generic((X), MAP_LIST(type_to_string,int,double,double*,int*,float*, default)) 11 | 12 | #define struct_member(X) X X ## _ ; 13 | 14 | typedef struct Any_type{ 15 | MAP(struct_member,int,float) 16 | } Any_type; 17 | 18 | int main(void) 19 | { 20 | //int x = 8; 21 | //int i = 1; 22 | //printf("%d",f_i); 23 | //const float y = 3.375; 24 | //MAP(CALL, ('a'), ('b'), ('c')); 25 | int arr[] = {1,2,3}; 26 | double arr1[] = {1.,2.,3.}; 27 | printf("%s",get_type(arr)); 28 | printf("%s",get_type(arr1)); 29 | printf("%s",get_type(arr[0])); 30 | printf("%s",get_type(arr1[0])); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | void print(T a) { 6 | std::cout << a << "\n"; 7 | } 8 | 9 | template 10 | int abs(T a){ 11 | return std::abs(a); 12 | } 13 | 14 | template 15 | int len(T a){ 16 | return a.size(); 17 | } 18 | 19 | template t3 add(t1 A,t1 B){ 20 | return A+B; 21 | } 22 | 23 | int main () 24 | { 25 | std::vector myints; 26 | std::cout << "0. size: " << myints.size() << '\n'; 27 | 28 | for (int i=0; i<10; i++) myints.push_back(i); 29 | std::cout << "1. size: " << myints.size() << '\n'; 30 | 31 | myints.insert (myints.end(),10,100); 32 | print("2. size: "); 33 | print(len(myints)); 34 | print(add(3,4)); 35 | 36 | myints.pop_back(); 37 | std::cout << "3. size: " << myints.size() << '\n'; 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.fut: -------------------------------------------------------------------------------- 1 | 2 | module Python = { 3 | module math = { 4 | let sin a = f32.sin a 5 | let cos a = f32.cos a 6 | let tan a = f32.tan a 7 | let asin a = f32.asin a 8 | let acos a = f32.acos a 9 | let atan a = f32.atan a 10 | let ceil a = f32.ceil a 11 | let floor a = f32.floor a 12 | let sqrt a = f32.sqrt a 13 | let fact (n: i32): i32 = reduce (*) 1 (1...n) 14 | let pow ((a:f32), (b:f32)):f32 = a**b 15 | } 16 | module functools = { 17 | let reduce (a, b) = reduce a b 18 | } 19 | let map (a,b) = map a b 20 | let filter (a,b) = filter a b 21 | let any a = any a 22 | let all a = all a 23 | let len a = length a 24 | let reversed a = reverse a 25 | } 26 | 27 | module Javascript = { 28 | module Math{ 29 | include Python.math 30 | } 31 | } 32 | 33 | module Php = { 34 | let strrev a = (Python.reversed a) 35 | include Python.math 36 | } 37 | 38 | module GLSL = { 39 | let fract a = (Python.abs a) - (Python.math.floor a) 40 | include Python.math 41 | } 42 | 43 | let main = Python.map(Python.math.floor,[3.1,4.2,5.3]) 44 | -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016, Anderson Green 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /prolog/simplified translator/common_grammar.pl: -------------------------------------------------------------------------------- 1 | :- use_module(library(dcg/basics)). 2 | 3 | string_literal("") --> "\"\"",!. 4 | string_literal(S) --> "\"",string_inner(S),"\"",!. 5 | string_literal1("") --> "\'\'",!. 6 | string_literal1(S) --> "\'",string_inner(S),"\'". 7 | string_inner([A]) --> string_inner_(A). 8 | string_inner([A|B]) --> string_inner_(A),string_inner(B). 9 | string_inner_(A) --> {A="\\\"";A="\\\'"},A;{dif(A,'"'),dif(A,'\''),dif(A,'\n')},[A]. 10 | 11 | ws --> "";blanks. 12 | ws_ --> (" ";"\n";"\r";"\t"),blanks. 13 | 14 | python_ws --> "";python_ws_. 15 | python_ws_ --> (" ";"\t"),python_ws. 16 | 17 | symbol([L|Ls]) --> letter(L), symbol_r(Ls). 18 | symbol_r([L|Ls]) --> csym(L), symbol_r(Ls). 19 | symbol_r([]) --> []. 20 | letter(Let) --> [Let], { code_type(Let, alpha) }. 21 | csym(Let) --> [Let], {code_type(Let, csym)}. 22 | 23 | a_double(A) --> a_double_(A). 24 | a_double([-A]) --> "-",a_double_(A). 25 | a_double_([A,['0']]) --> 26 | (an_int(A)). 27 | a_double_([A,B]) --> 28 | (an_int(A), ".",!, an_int(B)). 29 | an_int([L|Ls]) --> digit(L), an_int_r(Ls). 30 | an_int_r([L|Ls]) --> digit(L), an_int_r(Ls). 31 | an_int_r([]) --> []. 32 | -------------------------------------------------------------------------------- /prolog/simplified translator/tokenizer.pl: -------------------------------------------------------------------------------- 1 | :- module('tokenizer', [tokenize/2]). 2 | :- set_prolog_flag(double_quotes,chars). 3 | :- initialization(main). 4 | :- include(common_grammar). 5 | 6 | tokenize(Text,Output) :- phrase(tokenize(Output),Text). 7 | tokenize([A]) --> string_literal(A). 8 | tokenize([A]) --> an_int(A). 9 | tokenize([A]) --> symbol(A). 10 | tokenize([";"]) --> ";". 11 | tokenize(["+="]) --> "+=". 12 | tokenize(["*="]) --> "*=". 13 | tokenize(["+"]) --> "+". 14 | tokenize(["-"]) --> "-". 15 | tokenize([">"]) --> ">". 16 | tokenize(["<"]) --> "<". 17 | tokenize([")"]) --> ")". 18 | tokenize(["("]) --> "(". 19 | tokenize(["!"]) --> "!". 20 | tokenize(["@"]) --> "@". 21 | tokenize(["="]) --> "=". 22 | tokenize(["*"]) --> "*". 23 | tokenize(["/"]) --> "/". 24 | tokenize(["|"]) --> "|". 25 | tokenize(["&"]) --> "&". 26 | tokenize(["."]) --> ".". 27 | tokenize(["."]) --> "?". 28 | tokenize(["^"]) --> "^". 29 | tokenize(["?"]) --> "?". 30 | tokenize(["$"]) --> "$". 31 | tokenize(["#"]) --> "#". 32 | tokenize(["%"]) --> "%". 33 | tokenize([A|B]) --> tokenize([A]),skip_space,tokenize(B). 34 | skip_space --> 35 | [C], {code_type(C, space)}, skip_space. 36 | skip_space --> []. 37 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/regex_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | "\"" return '"' 6 | "?" return '?' 7 | "=" return '=' 8 | "|" return '|' 9 | "(" return '(' 10 | ")" return ')' 11 | [a-zA-Z0-9_][a-zA-Z0-9_]* return 'IDENTIFIER' 12 | <> return 'EOF' 13 | . return 'INVALID' 14 | 15 | /lex 16 | /* operator associations and precedence */ 17 | 18 | 19 | %start expressions 20 | 21 | %% /* language grammar */ 22 | 23 | expressions 24 | : statements EOF 25 | {return $1;} 26 | ; 27 | 28 | statements_: statement {$$ = 29 | [$1];}; 30 | 31 | statements: statements_ {$$ = ["top_level_statements",$1]}; 32 | 33 | 34 | 35 | 36 | statement: 37 | IDENTIFIER '=' '"' grammar_or '"' {[$$ = ["grammar_statement",$1,$4]]}; 38 | 39 | grammar_or: 40 | grammar_and "|" grammar_or {$$= ["grammar_or",$1,$3]} | grammar_and; 41 | 42 | grammar_and: 43 | e grammar_and {$$= ["grammar_and",$1,$2]} | e; 44 | 45 | e: "(" grammar_or ")" {$$= ["parentheses", $2];} | grammar_var; 46 | 47 | grammar_var: IDENTIFIER {$$= ["grammar_var",'"'+$1+'"'];}; 48 | -------------------------------------------------------------------------------- /prolog/common_grammar.pl: -------------------------------------------------------------------------------- 1 | string_literal("") --> "\"\"". 2 | string_literal(S) --> "\"",string_inner(S),"\"". 3 | string_literal1("") --> "\'\'". 4 | string_literal1(S) --> "\'",string_inner1(S),"\'","\'\''",{S=""}. 5 | string_inner([A]) --> string_inner_(A). 6 | string_inner([A|B]) --> string_inner_(A),string_inner(B). 7 | string_inner_(A) --> {A="\\\""},A;{dif(A,'"'),dif(A,'\n')},[A]. 8 | string_inner1([A]) --> string_inner1_(A). 9 | string_inner1([A|B]) --> string_inner1_(A),string_inner1(B). 10 | string_inner1_(A) --> {A="\\'"},A;{dif(A,'\''),dif(A,'\n')},[A]. 11 | 12 | ws --> "";ws_. 13 | ws_ --> (" ";"\n";"\r"),ws. 14 | 15 | python_ws --> "";python_ws_. 16 | python_ws_ --> (" ";"\t"),python_ws. 17 | 18 | symbol([L|Ls]) --> letter(L), symbol_r(Ls). 19 | symbol_r([L|Ls]) --> csym(L), symbol_r(Ls). 20 | symbol_r([]) --> []. 21 | letter(Let) --> [Let], { code_type(Let, alpha) }. 22 | csym(Let) --> [Let], {code_type(Let, csym)}. 23 | 24 | a_double([A,B]) --> 25 | (an_int(A), ".", an_int(B)). 26 | a_double([A,['0']]) --> 27 | (an_int(A)). 28 | an_int([L|Ls]) --> digit(L), an_int_r(Ls). 29 | an_int_r([L|Ls]) --> digit(L), an_int_r(Ls). 30 | an_int_r([]) --> []. 31 | digit(Let) --> [Let], { code_type(Let, digit) }. 32 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/common_grammar.pl: -------------------------------------------------------------------------------- 1 | string_literal("") --> "\"\"". 2 | string_literal(S) --> "\"",string_inner(S),"\"". 3 | string_literal1("") --> "\'\'". 4 | string_literal1(S) --> "\'",string_inner1(S),"\'","\'\''",{S=""}. 5 | string_inner([A]) --> string_inner_(A). 6 | string_inner([A|B]) --> string_inner_(A),string_inner(B). 7 | string_inner_(A) --> {A="\\\""},A;{dif(A,'"'),dif(A,'\n')},[A]. 8 | string_inner1([A]) --> string_inner1_(A). 9 | string_inner1([A|B]) --> string_inner1_(A),string_inner1(B). 10 | string_inner1_(A) --> {A="\\'"},A;{dif(A,'\''),dif(A,'\n')},[A]. 11 | 12 | ws --> "";ws_. 13 | ws_ --> (" ";"\n";"\r"),ws. 14 | 15 | python_ws --> "";python_ws_. 16 | python_ws_ --> (" ";"\t"),python_ws. 17 | 18 | symbol([L|Ls]) --> letter(L), symbol_r(Ls). 19 | symbol_r([L|Ls]) --> csym(L), symbol_r(Ls). 20 | symbol_r([]) --> []. 21 | letter(Let) --> [Let], { code_type(Let, alpha) }. 22 | csym(Let) --> [Let], {code_type(Let, csym)}. 23 | 24 | a_double([A,B]) --> 25 | (an_int(A), ".", an_int(B)). 26 | a_double([A,['0']]) --> 27 | (an_int(A)). 28 | an_int([L|Ls]) --> digit(L), an_int_r(Ls). 29 | an_int_r([L|Ls]) --> digit(L), an_int_r(Ls). 30 | an_int_r([]) --> []. 31 | digit(Let) --> [Let], { code_type(Let, digit) }. 32 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/common_grammar.pl: -------------------------------------------------------------------------------- 1 | string_literal("") --> "\"\"". 2 | string_literal(S) --> "\"",string_inner(S),"\"". 3 | string_literal1("") --> "\'\'". 4 | string_literal1(S) --> "\'",string_inner1(S),"\'","\'\''",{S=""}. 5 | string_inner([A]) --> string_inner_(A). 6 | string_inner([A|B]) --> string_inner_(A),string_inner(B). 7 | string_inner_(A) --> {A="\\\""},A;{dif(A,'"'),dif(A,'\n')},[A]. 8 | string_inner1([A]) --> string_inner1_(A). 9 | string_inner1([A|B]) --> string_inner1_(A),string_inner1(B). 10 | string_inner1_(A) --> {A="\\'"},A;{dif(A,'\''),dif(A,'\n')},[A]. 11 | 12 | ws --> "";ws_. 13 | ws_ --> (" ";"\n";"\r"),ws. 14 | 15 | python_ws --> "";python_ws_. 16 | python_ws_ --> (" ";"\t"),python_ws. 17 | 18 | symbol([L|Ls]) --> letter(L), symbol_r(Ls). 19 | symbol_r([L|Ls]) --> csym(L), symbol_r(Ls). 20 | symbol_r([]) --> []. 21 | letter(Let) --> [Let], { code_type(Let, alpha) }. 22 | csym(Let) --> [Let], {code_type(Let, csym)}. 23 | 24 | a_double([A,B]) --> 25 | (an_int(A), ".", an_int(B)). 26 | a_double([A,['0']]) --> 27 | (an_int(A)). 28 | an_int([L|Ls]) --> digit(L), an_int_r(Ls). 29 | an_int_r([L|Ls]) --> digit(L), an_int_r(Ls). 30 | an_int_r([]) --> []. 31 | digit(Let) --> [Let], { code_type(Let, digit) }. 32 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/common_grammar.pl: -------------------------------------------------------------------------------- 1 | string_literal("") --> "\"\"". 2 | string_literal(S) --> "\"",string_inner(S),"\"". 3 | string_literal1("") --> "\'\'". 4 | string_literal1(S) --> "\'",string_inner1(S),"\'","\'\''",{S=""}. 5 | string_inner([A]) --> string_inner_(A). 6 | string_inner([A|B]) --> string_inner_(A),string_inner(B). 7 | string_inner_(A) --> {A="\\\""},A;{dif(A,'"'),dif(A,'\n')},[A]. 8 | string_inner1([A]) --> string_inner1_(A). 9 | string_inner1([A|B]) --> string_inner1_(A),string_inner1(B). 10 | string_inner1_(A) --> {A="\\'"},A;{dif(A,'\''),dif(A,'\n')},[A]. 11 | 12 | ws --> "";ws_. 13 | ws_ --> (" ";"\n";"\r"),ws. 14 | 15 | python_ws --> "";python_ws_. 16 | python_ws_ --> (" ";"\t"),python_ws. 17 | 18 | symbol([L|Ls]) --> letter(L), symbol_r(Ls). 19 | symbol_r([L|Ls]) --> csym(L), symbol_r(Ls). 20 | symbol_r([]) --> []. 21 | letter(Let) --> [Let], { code_type(Let, alpha) }. 22 | csym(Let) --> [Let], {code_type(Let, csym)}. 23 | 24 | a_double([A,B]) --> 25 | (an_int(A), ".", an_int(B)). 26 | a_double([A,['0']]) --> 27 | (an_int(A)). 28 | an_int([L|Ls]) --> digit(L), an_int_r(Ls). 29 | an_int_r([L|Ls]) --> digit(L), an_int_r(Ls). 30 | an_int_r([]) --> []. 31 | digit(Let) --> [Let], { code_type(Let, digit) }. 32 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/antlr_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | ":" return ':' 9 | ";" return ';' 10 | "|" return '|' 11 | "(" return '(' 12 | ")" return ')' 13 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 14 | <> return 'EOF' 15 | . return 'INVALID' 16 | 17 | /lex 18 | /* operator associations and precedence */ 19 | 20 | 21 | %start expressions 22 | 23 | %% /* language grammar */ 24 | 25 | expressions 26 | : statements EOF 27 | {return $1;} 28 | ; 29 | 30 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 31 | [$1];}; 32 | 33 | statements: statements_ {$$ = ["top_level_statements",$1]}; 34 | 35 | 36 | 37 | 38 | statement: 39 | IDENTIFIER ":" grammar_or ";" {[$$ = ["grammar_statement",$1,$3]]}; 40 | 41 | grammar_or: 42 | grammar_and "|" grammar_or {$$= ["grammar_or",$1,$3]} | grammar_and; 43 | 44 | grammar_and: 45 | e grammar_and {$$= ["grammar_and",$1,$2]} | e; 46 | 47 | e: "(" grammar_or ")" {$$= ["parentheses", $2];} | grammar_var | STRING_LITERAL 48 | {$$ = yytext;}; 49 | 50 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 51 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/parentheses_expr.pl: -------------------------------------------------------------------------------- 1 | parentheses_expr(_,char,char_literal(A)) --> 2 | char_literal(A). 3 | 4 | parentheses_expr(_,string,string_literal(A)) --> 5 | string_literal(A). 6 | 7 | 8 | parentheses_expr(Data,Type1,anonymous_function(Type1,Params1,Body1)) --> 9 | anonymous_function_(Data,[ 10 | type(Data,Type1), 11 | parameters(Data,Params1), 12 | statements(Data,Type1,Body1) 13 | ]). 14 | 15 | parentheses_expr(Data,bool,"true") --> 16 | true_(Data). 17 | parentheses_expr(Data,bool,"false") --> 18 | false_(Data). 19 | 20 | parentheses_expr(Data,[array,Type],initializer_list(A)) --> 21 | initializer_list_(Data,[ 22 | initializer_list_(Data,Type,A), 23 | type(Data,Type) 24 | ]). 25 | 26 | parentheses_expr(Data,[dict,Type1],dict(A)) --> 27 | dict_(Data,[ 28 | dict_(Data,Type1,A), 29 | type(Data,Type1) 30 | ]). 31 | 32 | parentheses_expr(Data,Type,var_name(A)) --> 33 | var_name_(Data,Type,A). 34 | 35 | parentheses_expr(_,int,an_int(A)) --> 36 | an_int(A). 37 | parentheses_expr(_,double,a_double(A)) --> 38 | a_double(A). 39 | 40 | parentheses_expr(Data,Type,parentheses(A)) --> 41 | "(",ws,expr(Data,Type,A),ws,")". 42 | 43 | parentheses_expr(Data,Type, function_call(Name,Params1,Params2)) --> 44 | function_call_(Data,[ 45 | function_name(Data,Type,Name,Params2), 46 | function_call_parameters(Data,Params1,Params2) 47 | ]), 48 | {reserved_words(Name)}. 49 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/parentheses_expr.pl: -------------------------------------------------------------------------------- 1 | parentheses_expr(_,char,char_literal(A)) --> 2 | char_literal(A). 3 | 4 | parentheses_expr(_,string,string_literal(A)) --> 5 | string_literal(A). 6 | 7 | 8 | parentheses_expr(Data,Type1,anonymous_function(Type1,Params1,Body1)) --> 9 | anonymous_function_(Data,[ 10 | type(Data,Type1), 11 | parameters(Data,Params1), 12 | statements(Data,Type1,Body1) 13 | ]). 14 | 15 | parentheses_expr(Data,bool,"true") --> 16 | true_(Data). 17 | parentheses_expr(Data,bool,"false") --> 18 | false_(Data). 19 | 20 | parentheses_expr(Data,[array,Type],initializer_list(A)) --> 21 | initializer_list_(Data,[ 22 | initializer_list_(Data,Type,A), 23 | type(Data,Type) 24 | ]). 25 | 26 | parentheses_expr(Data,[dict,Type1],dict(A)) --> 27 | dict_(Data,[ 28 | dict_(Data,Type1,A), 29 | type(Data,Type1) 30 | ]). 31 | 32 | parentheses_expr(Data,Type,var_name(A)) --> 33 | var_name_(Data,Type,A). 34 | 35 | parentheses_expr(_,int,an_int(A)) --> 36 | an_int(A). 37 | parentheses_expr(_,double,a_double(A)) --> 38 | a_double(A). 39 | 40 | parentheses_expr(Data,Type,parentheses(A)) --> 41 | "(",ws,expr(Data,Type,A),ws,")". 42 | 43 | parentheses_expr(Data,Type, function_call(Name,Params1,Params2)) --> 44 | function_call_(Data,[ 45 | function_name(Data,Type,Name,Params2), 46 | function_call_parameters(Data,Params1,Params2) 47 | ]), 48 | {reserved_words(Name)}. 49 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/parentheses_expr.pl: -------------------------------------------------------------------------------- 1 | parentheses_expr(_,char,char_literal(A)) --> 2 | char_literal(A). 3 | 4 | parentheses_expr(_,string,string_literal(A)) --> 5 | string_literal(A). 6 | 7 | 8 | parentheses_expr(Data,Type1,anonymous_function(Type1,Params1,Body1)) --> 9 | anonymous_function_(Data,[ 10 | type(Data,Type1), 11 | parameters(Data,Params1), 12 | statements(Data,Type1,Body1) 13 | ]). 14 | 15 | parentheses_expr(Data,bool,"true") --> 16 | true_(Data). 17 | parentheses_expr(Data,bool,"false") --> 18 | false_(Data). 19 | 20 | parentheses_expr(Data,[array,Type],initializer_list(A)) --> 21 | initializer_list_(Data,[ 22 | initializer_list_(Data,Type,A), 23 | type(Data,Type) 24 | ]). 25 | 26 | parentheses_expr(Data,[dict,Type1],dict(A)) --> 27 | dict_(Data,[ 28 | dict_(Data,Type1,A), 29 | type(Data,Type1) 30 | ]). 31 | 32 | parentheses_expr(Data,Type,var_name(A)) --> 33 | var_name_(Data,Type,A). 34 | 35 | parentheses_expr(_,int,an_int(A)) --> 36 | an_int(A). 37 | parentheses_expr(_,double,a_double(A)) --> 38 | a_double(A). 39 | 40 | parentheses_expr(Data,Type,parentheses(A)) --> 41 | "(",ws,expr(Data,Type,A),ws,")". 42 | 43 | parentheses_expr(Data,Type, function_call(Name,Params1,Params2)) --> 44 | function_call_(Data,[ 45 | function_name(Data,Type,Name,Params2), 46 | function_call_parameters(Data,Params1,Params2) 47 | ]), 48 | {reserved_words(Name)}. 49 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/txl_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "define" return 'define' 9 | "expression" return 'expression' 10 | "end" return 'end' 11 | ":" return ':' 12 | ";" return ';' 13 | "|" return '|' 14 | "(" return '(' 15 | ")" return ')' 16 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 17 | <> return 'EOF' 18 | . return 'INVALID' 19 | 20 | /lex 21 | /* operator associations and precedence */ 22 | 23 | 24 | %start expressions 25 | 26 | %% /* language grammar */ 27 | 28 | expressions 29 | : statements EOF 30 | {return $1;} 31 | ; 32 | 33 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 34 | [$1];}; 35 | 36 | statements: statements_ {$$ = ["top_level_statements",$1]}; 37 | 38 | 39 | 40 | 41 | statement: 42 | "define" "expression" IDENTIFIER grammar_or "end" "define" {[$$ = ["grammar_statement",$3,$4]]}; 43 | 44 | grammar_or: 45 | grammar_and "|" grammar_or {$$= ["grammar_or",$1,$3]} | grammar_and; 46 | 47 | grammar_and: 48 | e grammar_and {$$= ["grammar_and",$1,$2]} | e; 49 | 50 | e: "(" grammar_or ")" {$$= ["parentheses", $2];} | grammar_var | STRING_LITERAL 51 | {$$ = yytext;}; 52 | 53 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 54 | -------------------------------------------------------------------------------- /prolog/parentheses_expr.pl: -------------------------------------------------------------------------------- 1 | parentheses_expr(_,char,char_literal(A)) --> 2 | char_literal(A). 3 | 4 | parentheses_expr(_,string,string_literal(A)) --> 5 | string_literal(A). 6 | 7 | 8 | parentheses_expr(Data,Type1,anonymous_function(Type1,Params1,Body1)) --> 9 | anonymous_function_(Data,[ 10 | type(Data,Type1), 11 | parameters(Data,Params1), 12 | statements(Data,Type1,Body1) 13 | ]). 14 | 15 | parentheses_expr(Data,bool,"true") --> 16 | true_(Data). 17 | parentheses_expr(Data,bool,"false") --> 18 | false_(Data). 19 | 20 | parentheses_expr(Data,[array,Type],initializer_list(A)) --> 21 | initializer_list_(Data,[ 22 | initializer_list_(Data,Type,A), 23 | type(Data,Type) 24 | ]). 25 | 26 | parentheses_expr(Data,[dict,Type1],dict(A)) --> 27 | dict_(Data,[ 28 | dict_(Data,Type1,A), 29 | type(Data,Type1) 30 | ]). 31 | 32 | %should be inclusive range 33 | parentheses_expr(Data,[array,int],range(A,B)) --> 34 | range_(Data,[ 35 | parentheses_expr(Data,int,A), 36 | expr(Data,int,B) 37 | ]). 38 | 39 | parentheses_expr(Data,Type,var_name(A)) --> 40 | var_name_(Data,Type,A). 41 | 42 | parentheses_expr(_,int,an_int(A)) --> 43 | an_int(A). 44 | parentheses_expr(_,double,a_double(A)) --> 45 | a_double(A). 46 | 47 | parentheses_expr(Data,Type,parentheses(A)) --> 48 | "(",ws,expr(Data,Type,A),ws,")". 49 | 50 | parentheses_expr(Data,Type, function_call(Name,Params1,Params2)) --> 51 | function_call_(Data,[ 52 | function_name(Data,Type,Name,Params2), 53 | function_call_parameters(Data,Params1,Params2) 54 | ]), 55 | {reserved_words(Name)}. 56 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.rb: -------------------------------------------------------------------------------- 1 | class Python 2 | def initialize(this) 3 | @this = this 4 | end 5 | def includes(item) 6 | return @this.include?(item) 7 | end 8 | def self.int(item) 9 | return item.to_i 10 | end 11 | def self.print(a) 12 | puts(a) 13 | end 14 | def self.map(a,b) 15 | return array.map { |n| n * 2 } 16 | end 17 | def self.str(item) 18 | return item.to_s 19 | end 20 | def self.float(item) 21 | return item.to_f 22 | end 23 | def self.len(item) 24 | return item.size 25 | end 26 | def keys() 27 | return @self.keys 28 | end 29 | def self.sorted(a) 30 | return a.sort! 31 | #return a copy of the array 32 | end 33 | def self.type(a) 34 | if a.kind_of?(Array) then 35 | return "Array" 36 | elsif [true, false].include? a then 37 | return "bool" 38 | end 39 | end 40 | end 41 | 42 | class Javascript 43 | def initialize(this) 44 | @self= this 45 | end 46 | def includes(item) 47 | return @self.include?(item) 48 | end 49 | def split(item) 50 | return @self.split(item) 51 | end 52 | def re 53 | return Re 54 | end 55 | class Re 56 | def self.compile(a) 57 | return /#{Regexp.quote(a)}/ 58 | end 59 | end 60 | class Console 61 | def self.log(a) 62 | Python.print(a) 63 | end 64 | end 65 | def console 66 | return Console 67 | end 68 | end 69 | 70 | class Php 71 | def initialize(this) 72 | @self= this 73 | end 74 | def self.in_array(needle,haystack) 75 | return new 76 | end 77 | def self.array_merge(a,b) 78 | return a + b 79 | end 80 | end 81 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/marpa_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | ";" return ';' 11 | "," return ',' 12 | "|" return '|' 13 | "::=" return '::=' 14 | "(" return '(' 15 | ")" return ')' 16 | "{" return '{' 17 | "}" return '}' 18 | "[" return '[' 19 | "]" return ']' 20 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 21 | <> return 'EOF' 22 | . return 'INVALID' 23 | 24 | /lex 25 | /* operator associations and precedence */ 26 | 27 | 28 | %start expressions 29 | 30 | %% /* language grammar */ 31 | 32 | expressions 33 | : statements EOF 34 | {return $1;} 35 | ; 36 | 37 | statements_: IDENTIFIER "::=" grammar_and statements_ {$$ = [["grammar_statement",$1,$3]].concat($4);} | statement {$$ = 38 | [$1];}; 39 | 40 | statements: statements_ {$$ = ["top_level_statements",$1]}; 41 | 42 | statement: 43 | IDENTIFIER "::=" grammar_and {$$ = ["grammar_statement",$1,$3]}; 44 | 45 | parameters: IDENTIFIER "," parameters {$$ = [$1].concat($3);} | IDENTIFIER {$$ = 46 | [$1];} | {$$ = [];}; 47 | 48 | grammar_and: 49 | grammar_and e {$$= ["grammar_and",$1,$2]} | e; 50 | 51 | e: grammar_var | STRING_LITERAL 52 | {$$ = yytext;}; 53 | 54 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 55 | -------------------------------------------------------------------------------- /prolog/simplified translator/optimized_javascript_parser.pl: -------------------------------------------------------------------------------- 1 | :- include(tokenizer). 2 | :- set_prolog_flag(double_quotes,chars). 3 | :- initialization(main). 4 | 5 | 6 | %To do: 7 | %Fix the precedence of '-' and '+'. Try to make the precedence equal for both of these operators. 8 | 9 | main :- tokenize("return a1+b1; const r = g*b+g*2; r = 2-1+a; r = 2+1-a;",Result),atoms_to_codes(Result1,Result),parse(Result1,Result2),writeln(Result2). 10 | 11 | atoms_to_codes([],[]). 12 | atoms_to_codes([A|B],[A1|B1]) :- atom_chars(A,A1),atoms_to_codes(B,B1). 13 | 14 | parse(List,Result) :- 15 | is_expr(A),is_expr(B), 16 | ( 17 | member(To_parse,[ 18 | ['[',A,']'], 19 | ['(',A,')'], 20 | ['{',A,'}'], 21 | [A,'.',B], 22 | 23 | %the order of operations is wrong here 24 | [A,'*',B], 25 | [A,'/',B], 26 | [A,'+',B], 27 | [A,'-',B], 28 | 29 | [A,'!==',B], 30 | [A,'===',B], 31 | [A,',',B], 32 | ['else','if',['(',A,')'],['{',B,'}']], 33 | ['if',['(',A,')'],['{',B,'}']], 34 | ['while',['(',A,')'],['{',B,'}']], 35 | ['else',['{',A,'}']], 36 | ['return',A,';'], 37 | ['const',A,'=',B,';'], 38 | ['let',A,'=',B,';'], 39 | ['var',A,'=',B,';'], 40 | [A,'=',B,';'], 41 | [A,'*=',B,';'], 42 | ['function',['(',A,')'],['{',B,'}']], 43 | ['function',_,['(',A,')'],['{',B,'}']] 44 | ]),parse(To_parse,List,Result1) 45 | ),parse(Result1,Result); 46 | ( 47 | Result=List 48 | ). 49 | 50 | is_expr(A) :- dif(A,'='),dif(A,'*'),dif(A,'['),dif(A,']'),dif(A,'('),dif(A,')'). 51 | 52 | 53 | parse(Sublist,List,Result) :- 54 | replace(Sublist,[Sublist],List,Result). 55 | 56 | replace(ToReplace, ToInsert, List, Result) :- 57 | once(append([Left, ToReplace, Right], List)), 58 | append([Left, ToInsert, Right], Result). 59 | -------------------------------------------------------------------------------- /javascript/pegjs_test.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Code to translate: 5 | 6 |
Input language: 7 | 8 |
Output language: 9 | 10 |
11 | 12 | 13 | 14 |

15 | 16 | 17 | 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/nearley_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | "->" return '->' 11 | ";" return ';' 12 | "," return ',' 13 | "|" return '|' 14 | "=" return '=' 15 | "(" return '(' 16 | ")" return ')' 17 | "{" return '{' 18 | "}" return '}' 19 | "[" return '[' 20 | "]" return ']' 21 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 22 | <> return 'EOF' 23 | . return 'INVALID' 24 | 25 | /lex 26 | /* operator associations and precedence */ 27 | 28 | 29 | %start expressions 30 | 31 | %% /* language grammar */ 32 | 33 | expressions 34 | : statements EOF 35 | {return $1;} 36 | ; 37 | 38 | statements: grammar_statements {$$ = ["top_level_statements",$1]}; 39 | 40 | grammar_statements: 41 | IDENTIFIER "->" grammar_and_ {$$= ["grammar_statement",$1,$3]} | IDENTIFIER "->" grammar_and_ grammar_statements {$$= [["grammar_statement",$1,$3]].concat([$4])}; 42 | 43 | grammar_and_: grammar_and_ "|" e {$$= ["grammar_or",$1,$3]} | grammar_and_ e { 44 | if(Array.isArray($1) && $1[0] == "grammar_or"){ 45 | $$ = ["grammar_or",$1[1],["grammar_and",$1[2],$2]]; 46 | } 47 | else{ 48 | $$ = ["grammar_and",$1,$2]; 49 | } 50 | } | e; 51 | 52 | e: "(" grammar_and_ ")" {$$= ["parentheses", $2];} | grammar_var | STRING_LITERAL 53 | {$$ = yytext;}; 54 | 55 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 56 | -------------------------------------------------------------------------------- /prolog/class_statement.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | class_statement(Data,Class_name,constructor(Params1,Body1)) --> 4 | namespace(Data,Data1,Class_name,Indent), 5 | %put this at the beginning of each statement without a semicolon 6 | constructor_(Data,[ 7 | function_name(Data,Class_name,Class_name,Params1), 8 | parameters(Data1,Params1), 9 | statements(Data1,_,Body1), 10 | Indent 11 | ]). 12 | 13 | class_statement(Data,_,static_method(Name1,Type1,Params1,Body1)) --> 14 | namespace(Data,Data1,Name1,Indent), 15 | %put this at the beginning of each statement without a semicolon 16 | static_method_(Data, [ 17 | function_name(Data,Type1,Name1,Params1), 18 | type(Data,Type1), 19 | parameters(Data1,Params1), 20 | statements(Data1,Type1,Body1), 21 | Indent 22 | ]). 23 | 24 | class_statement(Data,_,instance_method(Name1,Type1,Params1,Body1)) --> 25 | namespace(Data,Data1,Name1,Indent), 26 | instance_method_(Data,[ 27 | function_name(Data,Type1,Name1,Params1), 28 | type(Data1,Type1), 29 | parameters(Data1,Params1), 30 | statements(Data1,Type1,Body1), 31 | Indent 32 | ]). 33 | 34 | class_statement(Data,_,initialize_static_var_with_value(Type,Name,Expr)) --> 35 | initialize_static_var_with_value_(Data,[ 36 | type(Data,Type), 37 | var_name_(Data,Type,Name), 38 | expr(Data,Type,Expr) 39 | ]). 40 | 41 | class_statement(Data,_,initialize_instance_var(Type,Name)) --> 42 | initialize_instance_var_(Data,[ 43 | type(Data,Type), 44 | var_name_(Data,Type,Name) 45 | ]). 46 | 47 | class_statement(Data,_,initialize_instance_var_with_value_(Name,Expr,Type)) --> 48 | initialize_instance_var_with_value_(Data,[ 49 | var_name_(Data,Type,Name), 50 | expr(Data,Type,Expr), 51 | type(Data,Type) 52 | ]). 53 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/class_statement.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | class_statement(Data,Class_name,constructor(Params1,Body1)) --> 4 | namespace(Data,Data1,Class_name,Indent), 5 | %put this at the beginning of each statement without a semicolon 6 | constructor_(Data,[ 7 | function_name(Data,Class_name,Class_name,Params1), 8 | parameters(Data1,Params1), 9 | statements(Data1,_,Body1), 10 | Indent 11 | ]). 12 | 13 | class_statement(Data,_,static_method(Name1,Type1,Params1,Body1)) --> 14 | namespace(Data,Data1,Name1,Indent), 15 | %put this at the beginning of each statement without a semicolon 16 | static_method_(Data, [ 17 | function_name(Data,Type1,Name1,Params1), 18 | type(Data,Type1), 19 | parameters(Data1,Params1), 20 | statements(Data1,Type1,Body1), 21 | Indent 22 | ]). 23 | 24 | class_statement(Data,_,instance_method(Name1,Type1,Params1,Body1)) --> 25 | namespace(Data,Data1,Name1,Indent), 26 | instance_method_(Data,[ 27 | function_name(Data,Type1,Name1,Params1), 28 | type(Data1,Type1), 29 | parameters(Data1,Params1), 30 | statements(Data1,Type1,Body1), 31 | Indent 32 | ]). 33 | 34 | class_statement(Data,_,initialize_static_var_with_value(Type,Name,Expr)) --> 35 | initialize_static_var_with_value_(Data,[ 36 | type(Data,Type), 37 | var_name_(Data,Type,Name), 38 | expr(Data,Type,Expr) 39 | ]). 40 | 41 | class_statement(Data,_,initialize_instance_var(Type,Name)) --> 42 | initialize_instance_var_(Data,[ 43 | type(Data,Type), 44 | var_name_(Data,Type,Name) 45 | ]). 46 | 47 | class_statement(Data,_,initialize_instance_var_with_value_(Name,Expr,Type)) --> 48 | initialize_instance_var_with_value_(Data,[ 49 | var_name_(Data,Type,Name), 50 | expr(Data,Type,Expr), 51 | type(Data,Type) 52 | ]). 53 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/class_statement.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | class_statement(Data,Class_name,constructor(Params1,Body1)) --> 4 | namespace(Data,Data1,Class_name,Indent), 5 | %put this at the beginning of each statement without a semicolon 6 | constructor_(Data,[ 7 | function_name(Data,Class_name,Class_name,Params1), 8 | parameters(Data1,Params1), 9 | statements(Data1,_,Body1), 10 | Indent 11 | ]). 12 | 13 | class_statement(Data,_,static_method(Name1,Type1,Params1,Body1)) --> 14 | namespace(Data,Data1,Name1,Indent), 15 | %put this at the beginning of each statement without a semicolon 16 | static_method_(Data, [ 17 | function_name(Data,Type1,Name1,Params1), 18 | type(Data,Type1), 19 | parameters(Data1,Params1), 20 | statements(Data1,Type1,Body1), 21 | Indent 22 | ]). 23 | 24 | class_statement(Data,_,instance_method(Name1,Type1,Params1,Body1)) --> 25 | namespace(Data,Data1,Name1,Indent), 26 | instance_method_(Data,[ 27 | function_name(Data,Type1,Name1,Params1), 28 | type(Data1,Type1), 29 | parameters(Data1,Params1), 30 | statements(Data1,Type1,Body1), 31 | Indent 32 | ]). 33 | 34 | class_statement(Data,_,initialize_static_var_with_value(Type,Name,Expr)) --> 35 | initialize_static_var_with_value_(Data,[ 36 | type(Data,Type), 37 | var_name_(Data,Type,Name), 38 | expr(Data,Type,Expr) 39 | ]). 40 | 41 | class_statement(Data,_,initialize_instance_var(Type,Name)) --> 42 | initialize_instance_var_(Data,[ 43 | type(Data,Type), 44 | var_name_(Data,Type,Name) 45 | ]). 46 | 47 | class_statement(Data,_,initialize_instance_var_with_value_(Name,Expr,Type)) --> 48 | initialize_instance_var_with_value_(Data,[ 49 | var_name_(Data,Type,Name), 50 | expr(Data,Type,Expr), 51 | type(Data,Type) 52 | ]). 53 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/class_statement.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | class_statement(Data,Class_name,constructor(Params1,Body1)) --> 4 | namespace(Data,Data1,Class_name,Indent), 5 | %put this at the beginning of each statement without a semicolon 6 | constructor_(Data,[ 7 | function_name(Data,Class_name,Class_name,Params1), 8 | parameters(Data1,Params1), 9 | statements(Data1,_,Body1), 10 | Indent 11 | ]). 12 | 13 | class_statement(Data,_,static_method(Name1,Type1,Params1,Body1)) --> 14 | namespace(Data,Data1,Name1,Indent), 15 | %put this at the beginning of each statement without a semicolon 16 | static_method_(Data, [ 17 | function_name(Data,Type1,Name1,Params1), 18 | type(Data,Type1), 19 | parameters(Data1,Params1), 20 | statements(Data1,Type1,Body1), 21 | Indent 22 | ]). 23 | 24 | class_statement(Data,_,instance_method(Name1,Type1,Params1,Body1)) --> 25 | namespace(Data,Data1,Name1,Indent), 26 | instance_method_(Data,[ 27 | function_name(Data,Type1,Name1,Params1), 28 | type(Data1,Type1), 29 | parameters(Data1,Params1), 30 | statements(Data1,Type1,Body1), 31 | Indent 32 | ]). 33 | 34 | class_statement(Data,_,initialize_static_var_with_value(Type,Name,Expr)) --> 35 | initialize_static_var_with_value_(Data,[ 36 | type(Data,Type), 37 | var_name_(Data,Type,Name), 38 | expr(Data,Type,Expr) 39 | ]). 40 | 41 | class_statement(Data,_,initialize_instance_var(Type,Name)) --> 42 | initialize_instance_var_(Data,[ 43 | type(Data,Type), 44 | var_name_(Data,Type,Name) 45 | ]). 46 | 47 | class_statement(Data,_,initialize_instance_var_with_value_(Name,Expr,Type)) --> 48 | initialize_instance_var_with_value_(Data,[ 49 | var_name_(Data,Type,Name), 50 | expr(Data,Type,Expr), 51 | type(Data,Type) 52 | ]). 53 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/ometa_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | "ometa" return 'ometa' 11 | ";" return ';' 12 | "," return ',' 13 | "|" return '|' 14 | "=" return '=' 15 | "(" return '(' 16 | ")" return ')' 17 | "{" return '{' 18 | "}" return '}' 19 | "[" return '[' 20 | "]" return ']' 21 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 22 | <> return 'EOF' 23 | . return 'INVALID' 24 | 25 | /lex 26 | /* operator associations and precedence */ 27 | 28 | 29 | %start expressions 30 | 31 | %% /* language grammar */ 32 | 33 | expressions 34 | : statements EOF 35 | {return $1;} 36 | ; 37 | 38 | statements: grammar_statements {$$ = ["top_level_statements",[$1]]}; 39 | 40 | grammar_statements: "ometa" IDENTIFIER "{" statements_ "}" {$$=["grammar_statements",$2,["statements",$4]];}; 41 | 42 | statements_: 43 | IDENTIFIER "=" grammar_and_ {$$= [["grammar_statement",$1,$3]]} | IDENTIFIER "=" grammar_and_ "," statements_ {$$= [["grammar_statement",$1,$3]].concat($5)}; 44 | 45 | grammar_and_: grammar_and_ "|" e {$$= ["grammar_or",$1,$3]} | grammar_and_ "," e { 46 | if(Array.isArray($1) && $1[0] == "grammar_or"){ 47 | $$ = ["grammar_or",$1[1],["grammar_and",$1[2],$3]]; 48 | } 49 | else{ 50 | $$ = ["grammar_and",$1,$3]; 51 | } 52 | } | e; 53 | 54 | e: "(" grammar_and_ ")" {$$= ["parentheses", $2];} | IDENTIFIER {$$= ["grammar_var",$1];} | STRING_LITERAL 55 | {$$ = yytext;}; 56 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/racc_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | "class" return 'class' 11 | "rule" return 'rule' 12 | "end" return 'end' 13 | "|" return '|' 14 | ":" return ':' 15 | "(" return '(' 16 | ")" return ')' 17 | "{" return '{' 18 | "}" return '}' 19 | "[" return '[' 20 | "]" return ']' 21 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 22 | <> return 'EOF' 23 | . return 'INVALID' 24 | 25 | /lex 26 | /* operator associations and precedence */ 27 | 28 | 29 | %start expressions 30 | 31 | %% /* language grammar */ 32 | 33 | expressions 34 | : statements EOF 35 | {return $1;} 36 | ; 37 | 38 | statements: grammar_statements {$$ = ["top_level_statements",[$1]]}; 39 | 40 | grammar_statements: "class" IDENTIFIER "rule" statements_ "end" {$$=["grammar_statements",$2,["statements",$4]];}; 41 | 42 | statements_: 43 | IDENTIFIER ":" grammar_and_ {$$= [["grammar_statement",$1,$3]]} | IDENTIFIER ":" grammar_and_ statements_ {$$= [["grammar_statement",$1,$3]].concat($4)}; 44 | 45 | grammar_and_: grammar_and_ "|" e {$$= ["grammar_or",$1,$3]} | grammar_and_ e { 46 | if(Array.isArray($1) && $1[0] == "grammar_or"){ 47 | $$ = ["grammar_or",$1[1],["grammar_and",$1[2],$2]]; 48 | } 49 | else{ 50 | $$ = ["grammar_and",$1,$2]; 51 | } 52 | } | e; 53 | 54 | e: "(" grammar_and_ ")" {$$= ["parentheses", $2];} | IDENTIFIER {$$= ["grammar_var",$1];} | STRING_LITERAL 55 | {$$ = yytext;}; 56 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/ohm_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | "ometa" return 'ometa' 11 | ";" return ';' 12 | "," return ',' 13 | "|" return '|' 14 | "=" return '=' 15 | "(" return '(' 16 | ")" return ')' 17 | "{" return '{' 18 | "}" return '}' 19 | "[" return '[' 20 | "]" return ']' 21 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 22 | <> return 'EOF' 23 | . return 'INVALID' 24 | 25 | /lex 26 | /* operator associations and precedence */ 27 | 28 | 29 | %start expressions 30 | 31 | %% /* language grammar */ 32 | 33 | expressions 34 | : statements EOF 35 | {return $1;} 36 | ; 37 | 38 | 39 | statements_: IDENTIFIER "=" grammar_or statements_ {$$ = [["grammar_statement",$1,$3]].concat($4);} | statement {$$ = 40 | [$1];}; 41 | 42 | statements: grammar_statements {$$ = ["top_level_statements",[$1]]}; 43 | 44 | grammar_statements: IDENTIFIER "{" statements_ "}" {$$=["grammar_statements",$1,["statements",$3]];}; 45 | 46 | 47 | statement: 48 | IDENTIFIER "=" grammar_or {$$ = ["grammar_statement",$1,$3]}; 49 | 50 | parameters: IDENTIFIER "," parameters {$$ = [$1].concat($3);} | IDENTIFIER {$$ = 51 | [$1];} | {$$ = [];}; 52 | 53 | grammar_and: 54 | grammar_and "," e {$$= ["grammar_and",$1,$3]} | e; 55 | 56 | grammar_or: 57 | grammar_or "|" grammar_and {$$= ["grammar_or",$1,$3]} | grammar_and; 58 | 59 | e: grammar_var | STRING_LITERAL 60 | {$$ = yytext;}; 61 | 62 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 63 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/pegjs_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | ";" return ';' 11 | "," return ',' 12 | ":" return ':' 13 | "/" return '/' 14 | "=" return '=' 15 | "*" return '*' 16 | "(" return '(' 17 | ")" return ')' 18 | "{" return '{' 19 | "}" return '}' 20 | "[" return '[' 21 | "]" return ']' 22 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 23 | <> return 'EOF' 24 | . return 'INVALID' 25 | 26 | /lex 27 | /* operator associations and precedence */ 28 | 29 | 30 | %start expressions 31 | 32 | %% /* language grammar */ 33 | 34 | expressions 35 | : statements EOF 36 | {return $1;} 37 | ; 38 | 39 | statements: grammar_statements {$$ = ["top_level_statements",$1]}; 40 | 41 | grammar_statements: 42 | IDENTIFIER "=" grammar_and_ {$$= [["grammar_statement",$1,$3]]} | IDENTIFIER "=" grammar_and_ grammar_statements {$$= [["grammar_statement",$1,$3]].concat($4)}; 43 | 44 | grammar_and_: grammar_and_ "/" e {$$= ["grammar_or",$1,$3]} | grammar_and_ e { 45 | if(Array.isArray($1) && $1[0] == "grammar_or"){ 46 | $$ = ["grammar_or",$1[1],["grammar_and",$1[2],$2]]; 47 | } 48 | else{ 49 | $$ = ["grammar_and",$1,$2]; 50 | } 51 | } | e; 52 | 53 | e: "*" e {$$= ["grammar_optional", $2];} | "(" grammar_and_ ")" {$$= ["parentheses", $2];} | grammar_var ":" IDENTIFIER {$$ = ["function_call",$3,[$1]];} | grammar_var | STRING_LITERAL 54 | {$$ = yytext;}; 55 | 56 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 57 | -------------------------------------------------------------------------------- /translated_functions/javascript_functions.java: -------------------------------------------------------------------------------- 1 | public class JavaScript{ 2 | private Object self; 3 | public Python(Object self){ 4 | this.self = self; 5 | } 6 | public String substring(int start,int end){ 7 | return this.self.substring(start,end); 8 | } 9 | public class Math{ 10 | public static int min(int... args){ 11 | int to_return = 0; 12 | for(var i = 0; i < args.length; i++){ 13 | if(args[i] < to_return){ 14 | to_return = args[i]; 15 | } 16 | } 17 | return args[i]; 18 | } 19 | public static int max(int... args){ 20 | int to_return = 0; 21 | for(var i = 0; i < args.length; i++){ 22 | if(args[i] > to_return){ 23 | to_return = args[i]; 24 | } 25 | } 26 | return args[i]; 27 | } 28 | } 29 | } 30 | public class Python{ 31 | private Object self; 32 | public static String str(int a){ 33 | return Integer.parseInt(a); 34 | } 35 | public static String type(Object obj){ 36 | return obj!=null && obj.getClass().isArray() 37 | ? "list" 38 | :""; 39 | } 40 | static void print(String a) { 41 | System.out.println(a); 42 | } 43 | public Python(Object self){ 44 | this.self = self; 45 | } 46 | public String replace(char old_char,char new_char){ 47 | return str.replace(old_str,new_str); 48 | } 49 | public int find(String to_find){ 50 | return this.self.indexOf(toFind); 51 | } 52 | public class math{ 53 | public static double Random(){ 54 | return Math.random(); 55 | } 56 | public static T sin(T a) { 57 | return sin(a); 58 | } 59 | } 60 | public static String upper(String a){ 61 | return a.toUpperCase(a); 62 | } 63 | public String[] split(String separator){ 64 | return this.self.split(separator); 65 | } 66 | public static String lower(String a){ 67 | return a.toUpperCase(a); 68 | } 69 | public class re{ 70 | public static boolean search(String regex, String str){ 71 | return str.matches(regex); 72 | } 73 | public static String sub(String foo, String bar,String s){ 74 | return s.replaceAll(foo,bar); 75 | } 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/jison_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | "$"[0-9]+("."[0-9]+)?\b return 'GRAMMAR_INDEX' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "$$" return '$$' 10 | ":" return ':' 11 | ";" return ';' 12 | "," return ',' 13 | "|" return '|' 14 | "=" return '=' 15 | "(" return '(' 16 | ")" return ')' 17 | "{" return '{' 18 | "}" return '}' 19 | "[" return '[' 20 | "]" return ']' 21 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 22 | <> return 'EOF' 23 | . return 'INVALID' 24 | 25 | /lex 26 | /* operator associations and precedence */ 27 | 28 | 29 | %start expressions 30 | 31 | %% /* language grammar */ 32 | 33 | expressions 34 | : statements EOF 35 | {return $1;} 36 | ; 37 | 38 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 39 | [$1];}; 40 | 41 | statements: statements_ {$$ = ["top_level_statements",$1]}; 42 | 43 | 44 | 45 | 46 | statement: 47 | IDENTIFIER ":" grammar_or ";" {$$ = ["grammar_statement",$1,$3]}; 48 | 49 | grammar_or: 50 | grammar_and_ "|" grammar_or {$$= ["grammar_or",$1,$3]} | grammar_and_; 51 | 52 | grammar_and_: grammar_and | grammar_and output_array {$$ = ["grammar_output",$1,$2]}; 53 | 54 | output_array: "{" "$$" "=" "[" grammar_indices "]" ";" "}" {$$ = $5;}; 55 | 56 | grammar_indices: grammar_index_ "," grammar_indices {$$ = [$1].concat($3);} | grammar_index_ {$$ = [$1];}; 57 | grammar_index_: GRAMMAR_INDEX {$$ = ["grammar_index", $1.substring(1)];} | STRING_LITERAL; 58 | 59 | grammar_and: 60 | e grammar_and {$$= ["grammar_and",$1,$2]} | e; 61 | 62 | e: "(" grammar_or ")" {$$= ["parentheses", $2];} | grammar_var | STRING_LITERAL 63 | {$$ = yytext;}; 64 | 65 | grammar_var: IDENTIFIER {$$= ["grammar_var",$1];}; 66 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.cs: -------------------------------------------------------------------------------- 1 | public class Interpreters{ 2 | public class Python{ 3 | public static string type(bool a){ 4 | return "bool"; 5 | } 6 | public static string type(string a){ 7 | return "str" 8 | } 9 | public int index(String a){ 10 | returm this.self.index(a); 11 | } 12 | public static string type(int a){ 13 | return "int" 14 | } 15 | public class re{ 16 | public static System.Text.RegularExpressions.Regex compile(String a){ 17 | return new System.Text.RegularExpressions.Regex(a); 18 | } 19 | public static findall(String pattern,String text){ 20 | return re.findall(re.compile(pattern),text); 21 | } 22 | public static findall(System.Text.RegularExpressions.Regex pattern,String text){ 23 | return pattern.matches(text); 24 | } 25 | public static search(System.Text.RegularExpressions.Regex pattern,String text){ 26 | return System.Text.RegularExpressions.Regex.Match(text); 27 | } 28 | } 29 | public class math{ 30 | public static T sin(T a){ 31 | return Math.sin(a); 32 | } 33 | public static T cos(T a){ 34 | return Math.cos(a); 35 | } 36 | public static T tan(T a){ 37 | return Math.tan(a); 38 | } 39 | public String replace(char old_char,char new_char){ 40 | return str.replace(old_str,new_str); 41 | } 42 | public static int min(params int args){ 43 | int to_return = 0; 44 | for(var i = 0; i < args.length; i++){ 45 | if(args[i] < to_return){ 46 | to_return = args[i]; 47 | } 48 | } 49 | return args[i]; 50 | } 51 | public static int max(params int args){ 52 | int to_return = 0; 53 | for(var i = 0; i < args.length; i++){ 54 | if(args[i] > to_return){ 55 | to_return = args[i]; 56 | } 57 | } 58 | return args[i]; 59 | } 60 | } 61 | } 62 | public class Java{ 63 | public class Math{ 64 | 65 | } 66 | } 67 | public class Lua{ 68 | public static String type(int a){ 69 | return "number"; 70 | } 71 | public static String type(double a){ 72 | return "number"; 73 | } 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/protobuf_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | (\s+|\/\/+.*\n) /* skip whitespace and line comments */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "service" return 'service' 9 | "enum" return "enum" 10 | "required" return "required" 11 | "optional" return "optional" 12 | "void" return "void" 13 | "const" return "const" 14 | "message" return "message" 15 | "switch" return "switch" 16 | "," return ',' 17 | ";" return ';' 18 | "." return '.' 19 | ":" return ':' 20 | "=" return '=' 21 | "-" return '-' 22 | "{" return '{' 23 | "}" return '}' 24 | "[" return '[' 25 | "]" return ']' 26 | "(" return '(' 27 | ")" return ')' 28 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 29 | <> return 'EOF' 30 | . return 'INVALID' 31 | 32 | /lex 33 | 34 | /* operator associations and precedence */ 35 | 36 | %right '?' 37 | %left '||' 38 | %left '&&' 39 | %left '<' '<=' '>' '>=' '==' '!=' 40 | %left ('<' '<') ('>' '>') 41 | %left '+' '-' 42 | %left '*' '/' '%' 43 | %left UMINUS 44 | 45 | %start expressions 46 | 47 | %% /* language grammar */ 48 | 49 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 50 | 51 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 52 | [$1];}; 53 | 54 | struct_statements: struct_statement struct_statements {$$ = [$1].concat($2);} | struct_statement {$$ = 55 | [$1];}; 56 | 57 | struct_statement: parameter ";"; 58 | 59 | statements: statements_ {$$ = ["statements",$1]}; 60 | 61 | statement 62 | : 63 | "message" IDENTIFIER "{" struct_statements "}" {$$ = ["struct",$2,["struct_statements",$4]]} 64 | | "enum" IDENTIFIER "{" enum_statements "}" {$$ = ["enum","public",$2,$4];}; 65 | 66 | 67 | type: "void" | IDENTIFIER; 68 | parameter: type IDENTIFIER "=" NUMBER {$$ = ["protobuf_parameter",$4,$1,$2];}; 69 | 70 | enum_statements: enum_statement "," enum_statements {$$ = [$1].concat($3);} | enum_statement {$$ = [$1];}; 71 | enum_statement: IDENTIFIER "=" NUMBER {$$ = ["enum_statement",$1,$3]}; 72 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.php: -------------------------------------------------------------------------------- 1 | class Python{ 2 | private $self; 3 | public $re; 4 | public $math; 5 | public function __construct($self){ 6 | $this->$self = $self; 7 | $this->$re = new class { 8 | static public function match($the_pattern,$the_string){ 9 | return preg_match($the_pattern,$the_string); 10 | } 11 | }; 12 | $this->$math = new class { 13 | static public function log($a){ 14 | return log($a); 15 | } 16 | }; 17 | } 18 | public function keys(){ 19 | return array_keys($this->self); 20 | } 21 | public function pop(){ 22 | return array_pop($this->self); 23 | } 24 | static public function any($the_list){ 25 | return in_array(true,$the_list); 26 | } 27 | static public function all($the_list){ 28 | foreach ($the_list as $value){ 29 | if(Python::type($value) !== "bool" || $value !== true){ 30 | return false; 31 | } 32 | } 33 | return true; 34 | } 35 | 36 | static public function reversed($the_list){ 37 | return array_reverse($the_list); 38 | } 39 | public function count($a){ 40 | return substr_count($this->self,$a); 41 | } 42 | public function tolower(){ 43 | return strtolower($this->self); 44 | } 45 | public function toupper(){ 46 | return strtoupper($this->self); 47 | } 48 | static public function print($a){ 49 | echo $a; 50 | } 51 | static public function filter($func,$array){ 52 | return array_filter($array,$func); 53 | } 54 | static public function type($a){ 55 | if(gettype($a) === "string"){ 56 | return "str"; 57 | } 58 | else if(gettype($a) === "integer"){ 59 | return "int"; 60 | } 61 | else if(gettype($a) === "array"){ 62 | return "list"; 63 | } 64 | else if(gettype($a) === "double"){ 65 | return "float"; 66 | } 67 | } 68 | static function len($a){ 69 | if(Python::type($a) === "str"){ 70 | return strlen($a); 71 | } 72 | else if(Python::type($a) === "list"){ 73 | return sizeof($a); 74 | } 75 | } 76 | function join($the_arr){ 77 | return implode($this->self,$the_arr); 78 | } 79 | } 80 | 81 | class Prolog{ 82 | static public function number($a){ 83 | return is_numeric($a) && gettype($a) !== "string"; 84 | } 85 | static public function append($a,$b,$c){ 86 | return (Python.type($a) === "str") && $a . $b == $c; 87 | } 88 | static public function member($a,$b){ 89 | return in_array($a,$b); 90 | } 91 | } 92 | 93 | class SQL{ 94 | static public function REVERSE($a){ 95 | return strrev($a); 96 | } 97 | } 98 | Python::print(Python::type(3.0)); 99 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/dot_expr.pl: -------------------------------------------------------------------------------- 1 | dot_expr(Data,bool,startswith(Str1,Str2)) --> 2 | startswith_(Data,[ 3 | parentheses_expr(Data,string,Str1), 4 | parentheses_expr(Data,string,Str2) 5 | ]). 6 | 7 | 8 | 9 | dot_expr(Data,bool,endswith(Str1,Str2)) --> 10 | endswith_(Data,[ 11 | parentheses_expr(Data,string,Str1), 12 | expr(Data,string,Str2) 13 | ]). 14 | 15 | dot_expr(Data,string,join_(Array,Separator)) --> 16 | join_(Data,[ 17 | parentheses_expr(Data,[array,string],Array), 18 | parentheses_expr(Data,string,Separator) 19 | ]). 20 | 21 | dot_expr(Data,int,random_int_in_range(Start,End)) --> 22 | random_int_in_range(Data,[ 23 | expr(Data,int,Start), 24 | expr(Data,int,End) 25 | ]). 26 | 27 | dot_expr(Data,double,sqrt(Exp1)) --> 28 | sqrt(Data,[expr(Data,double,Exp1)]). 29 | 30 | 31 | dot_expr(Data,Type,list_comprehension(Result,Var,Condition,Array)) --> 32 | list_comprehension_(Data,[ 33 | var_name_(Data,Type,Var), 34 | expr(Data,[array,Type],Array), 35 | expr(Data,Type,Result), 36 | expr(Data,bool,Condition) 37 | ]). 38 | 39 | dot_expr(Data,[array,Type],reverse_list(List,Type)) --> 40 | reverse_list_(Data,[ 41 | parentheses_expr(Data,[array,Type],List) 42 | ]),!. 43 | 44 | dot_expr(Data,string,reverse_string(Str)) --> 45 | reverse_string_(Data,[ 46 | expr(Data,string,Str) 47 | ]),!. 48 | 49 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 50 | dot_expr(Data,string,trim(Str)) --> 51 | trim_(Data,[ 52 | parentheses_expr(Data,string,Str) 53 | ]),!. 54 | 55 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 56 | dot_expr(Data,string,lstrip(Str)) --> 57 | lstrip_(Data,[ 58 | parentheses_expr(Data,string,Str) 59 | ]),!. 60 | 61 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 62 | dot_expr(Data,string,rstrip(Str)) --> 63 | rstrip_(Data,[ 64 | parentheses_expr(Data,string,Str) 65 | ]),!. 66 | 67 | %all characters to lowercase 68 | dot_expr(Data,string,lowercase(Str)) --> 69 | lowercase_(Data,[ 70 | parentheses_expr(Data,string,Str) 71 | ]),!. 72 | 73 | %all characters to uppercase 74 | dot_expr(Data,string,uppercase(Str)) --> 75 | uppercase_(Data,[ 76 | parentheses_expr(Data,string,Str) 77 | ]),!. 78 | 79 | dot_expr(Data,int,strlen(A)) --> 80 | strlen_(Data,[parentheses_expr(Data,string,A)]). 81 | 82 | dot_expr(Data,int,array_length(A,Type)) --> 83 | array_length(Data,[ 84 | parentheses_expr(Data,[array,Type],A) 85 | ]). 86 | 87 | dot_expr(Data,Type,parentheses_expr(A)) --> 88 | parentheses_expr(Data,Type,A). 89 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/dot_expr.pl: -------------------------------------------------------------------------------- 1 | dot_expr(Data,bool,startswith(Str1,Str2)) --> 2 | startswith_(Data,[ 3 | parentheses_expr(Data,string,Str1), 4 | parentheses_expr(Data,string,Str2) 5 | ]). 6 | 7 | 8 | 9 | dot_expr(Data,bool,endswith(Str1,Str2)) --> 10 | endswith_(Data,[ 11 | parentheses_expr(Data,string,Str1), 12 | expr(Data,string,Str2) 13 | ]). 14 | 15 | dot_expr(Data,[array,Type],array_slice(Str,Index1,Index2)) --> 16 | array_slice_(Data,[ 17 | parentheses_expr(Data,[array,Type],Str), 18 | parentheses_expr(Data,int,Index1), 19 | parentheses_expr(Data,int,Index2) 20 | ]). 21 | 22 | dot_expr(Data,string,join_(Array,Separator)) --> 23 | join_(Data,[ 24 | parentheses_expr(Data,[array,string],Array), 25 | parentheses_expr(Data,string,Separator) 26 | ]). 27 | 28 | dot_expr(Data,int,random_int_in_range(Start,End)) --> 29 | random_int_in_range(Data,[ 30 | expr(Data,int,Start), 31 | expr(Data,int,End) 32 | ]). 33 | 34 | dot_expr(Data,double,sqrt(Exp1)) --> 35 | sqrt(Data,[expr(Data,double,Exp1)]). 36 | 37 | 38 | dot_expr(Data,Type,list_comprehension(Result,Var,Condition,Array)) --> 39 | list_comprehension_(Data,[ 40 | var_name_(Data,Type,Var), 41 | expr(Data,[array,Type],Array), 42 | expr(Data,Type,Result), 43 | expr(Data,bool,Condition) 44 | ]). 45 | 46 | dot_expr(Data,[array,Type],reverse_list(List,Type)) --> 47 | reverse_list_(Data,[ 48 | parentheses_expr(Data,[array,Type],List) 49 | ]),!. 50 | 51 | dot_expr(Data,string,reverse_string(Str)) --> 52 | reverse_string_(Data,[ 53 | expr(Data,string,Str) 54 | ]),!. 55 | 56 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 57 | dot_expr(Data,string,trim(Str)) --> 58 | trim_(Data,[ 59 | parentheses_expr(Data,string,Str) 60 | ]),!. 61 | 62 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 63 | dot_expr(Data,string,lstrip(Str)) --> 64 | lstrip_(Data,[ 65 | parentheses_expr(Data,string,Str) 66 | ]),!. 67 | 68 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 69 | dot_expr(Data,string,rstrip(Str)) --> 70 | rstrip_(Data,[ 71 | parentheses_expr(Data,string,Str) 72 | ]),!. 73 | 74 | %all characters to lowercase 75 | dot_expr(Data,string,lowercase(Str)) --> 76 | lowercase_(Data,[ 77 | parentheses_expr(Data,string,Str) 78 | ]),!. 79 | 80 | %all characters to uppercase 81 | dot_expr(Data,string,uppercase(Str)) --> 82 | uppercase_(Data,[ 83 | parentheses_expr(Data,string,Str) 84 | ]),!. 85 | 86 | dot_expr(Data,int,strlen(A)) --> 87 | strlen_(Data,[parentheses_expr(Data,string,A)]). 88 | 89 | dot_expr(Data,int,array_length(A,Type)) --> 90 | array_length(Data,[ 91 | parentheses_expr(Data,[array,Type],A) 92 | ]). 93 | 94 | dot_expr(Data,Type,parentheses_expr(A)) --> 95 | parentheses_expr(Data,Type,A). 96 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/dot_expr.pl: -------------------------------------------------------------------------------- 1 | dot_expr(Data,bool,startswith(Str1,Str2)) --> 2 | startswith_(Data,[ 3 | parentheses_expr(Data,string,Str1), 4 | parentheses_expr(Data,string,Str2) 5 | ]). 6 | 7 | 8 | 9 | dot_expr(Data,bool,endswith(Str1,Str2)) --> 10 | endswith_(Data,[ 11 | parentheses_expr(Data,string,Str1), 12 | expr(Data,string,Str2) 13 | ]). 14 | 15 | dot_expr(Data,[array,Type],array_slice(Str,Index1,Index2)) --> 16 | array_slice_(Data,[ 17 | parentheses_expr(Data,[array,Type],Str), 18 | parentheses_expr(Data,int,Index1), 19 | parentheses_expr(Data,int,Index2) 20 | ]). 21 | 22 | dot_expr(Data,string,join_(Array,Separator)) --> 23 | join_(Data,[ 24 | parentheses_expr(Data,[array,string],Array), 25 | parentheses_expr(Data,string,Separator) 26 | ]). 27 | 28 | dot_expr(Data,int,random_int_in_range(Start,End)) --> 29 | random_int_in_range(Data,[ 30 | expr(Data,int,Start), 31 | expr(Data,int,End) 32 | ]). 33 | 34 | dot_expr(Data,double,sqrt(Exp1)) --> 35 | sqrt(Data,[expr(Data,double,Exp1)]). 36 | 37 | 38 | dot_expr(Data,Type,list_comprehension(Result,Var,Condition,Array)) --> 39 | list_comprehension_(Data,[ 40 | var_name_(Data,Type,Var), 41 | expr(Data,[array,Type],Array), 42 | expr(Data,Type,Result), 43 | expr(Data,bool,Condition) 44 | ]). 45 | 46 | dot_expr(Data,[array,Type],reverse_list(List,Type)) --> 47 | reverse_list_(Data,[ 48 | parentheses_expr(Data,[array,Type],List) 49 | ]),!. 50 | 51 | dot_expr(Data,string,reverse_string(Str)) --> 52 | reverse_string_(Data,[ 53 | expr(Data,string,Str) 54 | ]),!. 55 | 56 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 57 | dot_expr(Data,string,trim(Str)) --> 58 | trim_(Data,[ 59 | parentheses_expr(Data,string,Str) 60 | ]),!. 61 | 62 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 63 | dot_expr(Data,string,lstrip(Str)) --> 64 | lstrip_(Data,[ 65 | parentheses_expr(Data,string,Str) 66 | ]),!. 67 | 68 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 69 | dot_expr(Data,string,rstrip(Str)) --> 70 | rstrip_(Data,[ 71 | parentheses_expr(Data,string,Str) 72 | ]),!. 73 | 74 | %all characters to lowercase 75 | dot_expr(Data,string,lowercase(Str)) --> 76 | lowercase_(Data,[ 77 | parentheses_expr(Data,string,Str) 78 | ]),!. 79 | 80 | %all characters to uppercase 81 | dot_expr(Data,string,uppercase(Str)) --> 82 | uppercase_(Data,[ 83 | parentheses_expr(Data,string,Str) 84 | ]),!. 85 | 86 | dot_expr(Data,int,strlen(A)) --> 87 | strlen_(Data,[parentheses_expr(Data,string,A)]). 88 | 89 | dot_expr(Data,int,array_length(A,Type)) --> 90 | array_length(Data,[ 91 | parentheses_expr(Data,[array,Type],A) 92 | ]). 93 | 94 | dot_expr(Data,Type,parentheses_expr(A)) --> 95 | parentheses_expr(Data,Type,A). 96 | -------------------------------------------------------------------------------- /translated_functions/cpp/prolog.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | 7 | namespace C_sharp{ 8 | namespace Convert{ 9 | template std::string ToString(T a){ 10 | return std::to_string(a); 11 | } 12 | } 13 | } 14 | 15 | namespace Python { 16 | template void print(T a) { 17 | std::cout << a << "\n"; 18 | } 19 | 20 | template int abs(T a){ 21 | return std::abs(a); 22 | } 23 | 24 | template int len(T a){ 25 | return a.size(); 26 | } 27 | 28 | template T __add__(T A,T B){ 29 | return A+B; 30 | } 31 | 32 | template T __mul__(T A,T B){ 33 | return A*B; 34 | } 35 | 36 | std::string type(std::string a){ 37 | return "str"; 38 | } 39 | 40 | } 41 | 42 | namespace Java{ 43 | namespace Integer{ 44 | std::string toString(int a){ 45 | return std::to_string(a); 46 | } 47 | } 48 | namespace System{ 49 | namespace out{ 50 | template void println(T a) { 51 | std::cout << a << "\n"; 52 | } 53 | } 54 | } 55 | } 56 | 57 | namespace Ruby{ 58 | template void puts(T A){ 59 | std::cout << A << "\n"; 60 | } 61 | } 62 | 63 | namespace PHP{ 64 | std::string gettype(int a){ 65 | return "integer"; 66 | } 67 | std::string gettype(std::string a){ 68 | return "string"; 69 | } 70 | std::string gettype(bool a){ 71 | return "bool"; 72 | } 73 | template void echo(T a){ 74 | Ruby::puts(a); 75 | } 76 | } 77 | 78 | namespace Lua{ 79 | std::string type(std::string a){ 80 | return "string"; 81 | } 82 | std::string type(bool a){ 83 | return "boolean"; 84 | } 85 | std::string type(int a){ 86 | return "number"; 87 | } 88 | } 89 | 90 | namespace JavaScript{ 91 | 92 | template class console { 93 | public: 94 | static void log(T a){ 95 | Ruby::puts(a); 96 | } 97 | }; 98 | 99 | template class Math { 100 | public: 101 | static int round(T A){ 102 | return round(A); 103 | } 104 | static int floor(T A){ 105 | return floor(A); 106 | } 107 | }; 108 | } 109 | 110 | namespace Prolog{ 111 | bool integer(int a){ 112 | return true; 113 | } 114 | template void writeln(T a){ 115 | Ruby::puts(a); 116 | } 117 | } 118 | 119 | int main () 120 | { 121 | 122 | Ruby::puts(PHP::gettype(1)); 123 | Ruby::puts(PHP::gettype(2)); 124 | Ruby::puts(3); 125 | JavaScript::console::log("Length of a is:"); 126 | std::string a = "3"; 127 | JavaScript::console::log(Python::len(a)); 128 | //JavaScript::console::log(C_sharp::Convert::ToString(3)); 129 | Java::System::out::println(3); 130 | //JavaScript::console::log(JavaScript::Math::round(4.5)); 131 | Prolog::writeln(Prolog::integer(3)); 132 | return 0; 133 | } 134 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/thrift_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | (\s+|\/\/+.*\n) /* skip whitespace and line comments */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "service" return 'service' 9 | "required" return 'required' 10 | "optional" return 'optional' 11 | "enum" return 'enum' 12 | "void" return "void" 13 | "const" return "const" 14 | "struct" return "struct" 15 | "," return ',' 16 | ";" return ';' 17 | "." return '.' 18 | ":" return ':' 19 | "--" return '--' 20 | "-" return '-' 21 | "{" return '{' 22 | "}" return '}' 23 | "[" return '[' 24 | "]" return ']' 25 | "(" return '(' 26 | ")" return ')' 27 | "=" return '=' 28 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 29 | <> return 'EOF' 30 | . return 'INVALID' 31 | 32 | /lex 33 | 34 | /* operator associations and precedence */ 35 | 36 | %right '?' 37 | %left '||' 38 | %left '&&' 39 | %left '<' '<=' '>' '>=' '==' '!=' 40 | %left ('<' '<') ('>' '>') 41 | %left '+' '-' 42 | %left '*' '/' '%' 43 | %left UMINUS 44 | 45 | %start expressions 46 | 47 | %% /* language grammar */ 48 | 49 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 50 | 51 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 52 | [$1];}; 53 | 54 | comma_or_semicolon: "," | ";"; 55 | 56 | struct_statements: struct_statement comma_or_semicolon struct_statements {$$ = [$1].concat($3);} | struct_statement {$$ = 57 | [$1];}; 58 | 59 | struct_statement: parameter | type IDENTIFIER "(" parameters ")" {$$ = ["interface_static_method","public",$1,$2,$4]}; 60 | 61 | statements: statements_ {$$ = ["statements",$1]}; 62 | 63 | statement 64 | : 65 | "struct" IDENTIFIER "{" struct_statements "}" {$$ = ["struct",$2,["struct_statements",$4]]} 66 | | "service" IDENTIFIER "{" struct_statements "}" {$$ = ["protobuf_service",$2,["struct_statements",$4]]} 67 | | "enum" IDENTIFIER "{" enum_statements "}" {$$ = ["enum","public",$2,$4];} 68 | ; 69 | 70 | required_or_optional:"required"|"optional"; 71 | type: "void" | IDENTIFIER; 72 | parameter: NUMBER ":" type IDENTIFIER {$$ = ["protobuf_parameter",$1,$3,$4];} | NUMBER ":" required_or_optional type IDENTIFIER {$$ = ["protobuf_optional_parameter",$1,$3,$4,$5];}; 73 | parameters: parameter "," parameters {$$ = [$1].concat($3);} | parameter {$$ = 74 | [$1];} | {$$ = [];}; 75 | 76 | enum_statements: enum_statement "," enum_statements {$$ = [$1].concat($3);} | enum_statement {$$ = [$1];}; 77 | enum_statement: IDENTIFIER "=" NUMBER {$$ = ["enum_statement",$1,$3]}; 78 | -------------------------------------------------------------------------------- /translated_functions/cpp/translated_functions.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | 7 | namespace C_sharp{ 8 | namespace Convert{ 9 | template std::string ToString(T a){ 10 | return std::to_string(a); 11 | } 12 | } 13 | } 14 | 15 | namespace Python { 16 | template void print(T a) { 17 | std::cout << a << "\n"; 18 | } 19 | 20 | template int abs(T a){ 21 | return std::abs(a); 22 | } 23 | 24 | template int len(T a){ 25 | return a.size(); 26 | } 27 | 28 | template T __add__(T A,T B){ 29 | return A+B; 30 | } 31 | 32 | template T __mul__(T A,T B){ 33 | return A*B; 34 | } 35 | 36 | std::string type(std::string a){ 37 | return "str"; 38 | } 39 | 40 | } 41 | 42 | namespace Java{ 43 | namespace Integer{ 44 | std::string toString(int a){ 45 | return std::to_string(a); 46 | } 47 | } 48 | namespace System{ 49 | namespace out{ 50 | template void println(T a) { 51 | std::cout << a << "\n"; 52 | } 53 | } 54 | } 55 | } 56 | 57 | namespace Ruby{ 58 | template void puts(T A){ 59 | std::cout << A << "\n"; 60 | } 61 | } 62 | 63 | namespace PHP{ 64 | std::string gettype(int a){ 65 | return "integer"; 66 | } 67 | std::string gettype(std::string a){ 68 | return "string"; 69 | } 70 | std::string gettype(bool a){ 71 | return "bool"; 72 | } 73 | template void echo(T a){ 74 | Ruby::puts(a); 75 | } 76 | } 77 | 78 | namespace Lua{ 79 | std::string type(std::string a){ 80 | return "string"; 81 | } 82 | std::string type(bool a){ 83 | return "boolean"; 84 | } 85 | std::string type(int a){ 86 | return "number"; 87 | } 88 | } 89 | 90 | namespace JavaScript{ 91 | 92 | template class console { 93 | public: 94 | static void log(T a){ 95 | Ruby::puts(a); 96 | } 97 | }; 98 | 99 | template class Math { 100 | public: 101 | static int round(T A){ 102 | return round(A); 103 | } 104 | static int floor(T A){ 105 | return floor(A); 106 | } 107 | }; 108 | } 109 | 110 | namespace Prolog{ 111 | bool integer(int a){ 112 | return true; 113 | } 114 | template void writeln(T a){ 115 | Ruby::puts(a); 116 | } 117 | } 118 | 119 | int main () 120 | { 121 | 122 | Ruby::puts(PHP::gettype(1)); 123 | Ruby::puts(PHP::gettype(2)); 124 | Ruby::puts(3); 125 | JavaScript::console::log("Length of a is:"); 126 | std::string a = "3"; 127 | JavaScript::console::log(Python::len(a)); 128 | //JavaScript::console::log(C_sharp::Convert::ToString(3)); 129 | Java::System::out::println(3); 130 | //JavaScript::console::log(JavaScript::Math::round(4.5)); 131 | Prolog::writeln(Prolog::integer(3)); 132 | return 0; 133 | } 134 | -------------------------------------------------------------------------------- /javascript/runtime_type_inference.js: -------------------------------------------------------------------------------- 1 | function array_type(a){ 2 | if(Array.isArray(a)){ 3 | return array_type(a[0]); 4 | } 5 | else{ 6 | return GLSL_type(a); 7 | } 8 | } 9 | 10 | function array_dimensions(a){ 11 | if(Array.isArray(a)){ 12 | return "["+a.length+"]"+array_dimensions(a[0]); 13 | } 14 | else{ 15 | return ""; 16 | } 17 | } 18 | function GLSL_type(a){ 19 | let the_type = typeof a; 20 | if(the_type == "number"){ 21 | return "float"; 22 | } 23 | else if(the_type == "boolean"){ 24 | return "bool"; 25 | } 26 | else if(Array.isArray(a)){ 27 | return array_type(a)+array_dimensions(a); 28 | } 29 | } 30 | 31 | //from https://stackoverflow.com/questions/1249531/how-to-get-a-javascript-objects-class 32 | var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg; 33 | var ARGUMENT_NAMES = /([^\s,]+)/g; 34 | function getParamNames(func) { 35 | var fnStr = func.toString().replace(STRIP_COMMENTS, ''); 36 | var result = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(ARGUMENT_NAMES); 37 | if(result === null) 38 | result = []; 39 | return result; 40 | } 41 | 42 | var annotated_functions = []; 43 | function infer_types(func,args){ 44 | //to do: generate a type signature from this input 45 | let input_types = args.map(x => GLSL_type(x)); 46 | let function_source = func.toString(); 47 | let parameter_names = getParamNames(func); 48 | let type_signature = ""; 49 | for(let i = 0; i < parameter_names.length; i++){ 50 | type_signature += parameter_names[i]+":"+input_types[i]; 51 | if(i < parameter_names.length -1) type_signature += "," 52 | } 53 | //return type_signature; 54 | let result = func.apply(this, args); 55 | var annotated = function_source.replace(/\(.*\)/, "("+type_signature+")"+":"+GLSL_type(result)); 56 | annotated_functions.push(annotated); 57 | return result; 58 | } 59 | 60 | function decorator_return_types(func){ 61 | //return a function that infers the types and then returns the result 62 | return function(){ 63 | return infer_types(func,Array.prototype.slice.call(arguments)); 64 | } 65 | } 66 | //to do: define a function that decorates all functions in the current scope. 67 | //to get all functions of an object: https://stackoverflow.com/questions/7548291/get-all-functions-of-an-object-in-javascript 68 | 69 | class Example{ 70 | static sine1(x){ 71 | return Example.sine(x); 72 | } 73 | static sine(x){ 74 | return Math.sin(x); 75 | } 76 | } 77 | function decorate_all(class_name){ 78 | let all_methods = Object.getOwnPropertyNames(class_name).filter(function (p) { 79 | return typeof class_name[p] === 'function'; 80 | }); 81 | for(let x of all_methods){ 82 | console.log(x); 83 | class_name[x] = decorator_return_types(class_name[x]); 84 | } 85 | } 86 | decorate_all(Example); 87 | 88 | 89 | //Example.sine = decorator_return_types(Example.sine); 90 | //infer_types(sine,[3]); 91 | Example.sine1(3); 92 | console.log(annotated_functions.join("\n")); 93 | 94 | //alert(GLSL_type([[1,2,3]])); 95 | //alert(GLSL_type([true,false,false])); 96 | -------------------------------------------------------------------------------- /prolog/simplified translator/input.txt: -------------------------------------------------------------------------------- 1 | function distance(x1,y1,x2,y2){ 2 | return Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2)); 3 | } 4 | 5 | function index_in_array(the_arr,to_find){ 6 | var i = 0; 7 | while(i < the_arr.length){ 8 | if(the_arr[i]+0 === to_find){ 9 | return the_arr[i]; 10 | } 11 | else{ 12 | i++; 13 | } 14 | } 15 | } 16 | 17 | function matches_pattern(arr,pattern){ 18 | if(pattern.length !== arr.length){ 19 | return false; 20 | } 21 | else{ 22 | var i = 0; 23 | while(i " + b; 122 | } 123 | else{ 124 | return "(> "+a+" "+b+")"; 125 | } 126 | } 127 | 128 | function indent_line(line,number_of_indents){ 129 | var i = 0; 130 | while(i < number_of_indents){ 131 | line = " "+line; 132 | i++; 133 | } 134 | return line; 135 | } 136 | -------------------------------------------------------------------------------- /map.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2012 William Swanson 3 | * 4 | * Permission is hereby granted, free of charge, to any person 5 | * obtaining a copy of this software and associated documentation 6 | * files (the "Software"), to deal in the Software without 7 | * restriction, including without limitation the rights to use, copy, 8 | * modify, merge, publish, distribute, sublicense, and/or sell copies 9 | * of the Software, and to permit persons to whom the Software is 10 | * furnished to do so, subject to the following conditions: 11 | * 12 | * The above copyright notice and this permission notice shall be 13 | * included in all copies or substantial portions of the Software. 14 | * 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY 19 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 20 | * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 22 | * 23 | * Except as contained in this notice, the names of the authors or 24 | * their institutions shall not be used in advertising or otherwise to 25 | * promote the sale, use or other dealings in this Software without 26 | * prior written authorization from the authors. 27 | */ 28 | 29 | #ifndef MAP_H_INCLUDED 30 | #define MAP_H_INCLUDED 31 | 32 | #define EVAL0(...) __VA_ARGS__ 33 | #define EVAL1(...) EVAL0(EVAL0(EVAL0(__VA_ARGS__))) 34 | #define EVAL2(...) EVAL1(EVAL1(EVAL1(__VA_ARGS__))) 35 | #define EVAL3(...) EVAL2(EVAL2(EVAL2(__VA_ARGS__))) 36 | #define EVAL4(...) EVAL3(EVAL3(EVAL3(__VA_ARGS__))) 37 | #define EVAL(...) EVAL4(EVAL4(EVAL4(__VA_ARGS__))) 38 | 39 | #define MAP_END(...) 40 | #define MAP_OUT 41 | #define MAP_COMMA , 42 | 43 | #define MAP_GET_END2() 0, MAP_END 44 | #define MAP_GET_END1(...) MAP_GET_END2 45 | #define MAP_GET_END(...) MAP_GET_END1 46 | #define MAP_NEXT0(test, next, ...) next MAP_OUT 47 | #define MAP_NEXT1(test, next) MAP_NEXT0(test, next, 0) 48 | #define MAP_NEXT(test, next) MAP_NEXT1(MAP_GET_END test, next) 49 | 50 | #define MAP0(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP1)(f, peek, __VA_ARGS__) 51 | #define MAP1(f, x, peek, ...) f(x) MAP_NEXT(peek, MAP0)(f, peek, __VA_ARGS__) 52 | 53 | #define MAP_LIST_NEXT1(test, next) MAP_NEXT0(test, MAP_COMMA next, 0) 54 | #define MAP_LIST_NEXT(test, next) MAP_LIST_NEXT1(MAP_GET_END test, next) 55 | 56 | #define MAP_LIST0(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST1)(f, peek, __VA_ARGS__) 57 | #define MAP_LIST1(f, x, peek, ...) f(x) MAP_LIST_NEXT(peek, MAP_LIST0)(f, peek, __VA_ARGS__) 58 | 59 | /** 60 | * Applies the function macro `f` to each of the remaining parameters. 61 | */ 62 | #define MAP(f, ...) EVAL(MAP1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) 63 | 64 | /** 65 | * Applies the function macro `f` to each of the remaining parameters and 66 | * inserts commas between the results. 67 | */ 68 | #define MAP_LIST(f, ...) EVAL(MAP_LIST1(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /prolog/simplified translator/tests.pl: -------------------------------------------------------------------------------- 1 | :- use_module(transpiler). 2 | :- set_prolog_flag(double_quotes,chars). 3 | :- initialization(main). 4 | :- use_module(library(prolog_stack)). 5 | :- use_module(library(error)). 6 | 7 | user:prolog_exception_hook(Exception, Exception, Frame, _) :- 8 | ( Exception = error(Term) 9 | ; Exception = error(Term, _)), 10 | get_prolog_backtrace(Frame, 20, Trace), 11 | format(user_error, 'Error: ~p', [Term]), nl(user_error), 12 | print_prolog_backtrace(user_error, Trace), nl(user_error), fail. 13 | 14 | %list_of_langs(['javascript','java','c#','php','lua','ruby','perl','python','haxe','c++','c','erlang','prolog']). 15 | list_of_langs(['javascript','php','java','ruby']). 16 | 17 | main :- 18 | read_file_to_codes('javascript_source.js',Input,[]), 19 | list_of_langs(Langs), 20 | %test_statement(Input,python,'java'). 21 | %Statements_to_test = [Input,"b = math.acos(3)","in_arr = 3 in [1,2,3]","randomly_chosen = random.choice([1,2,3])", "str1 = str2.join([\"hi\",\"hi\"])", "str_arr = str1.split(str2)", "a_string += \"stuff\"","a_string=str1.replace(str2,str3)","bool_var = (3 != 4)","string_var = (\"3\" != \"4\")","a+=1","a*=1","a-=1","a*=1"], 22 | %Statements_to_test = [Input,"b = (3)**(2)","z=math.sqrt(1)","a=math.asin(3)","a=math.acos(3)","a=math.atan(3)"], 23 | Statements_to_test = [Input], 24 | profile(test_statements_in_langs(Statements_to_test,'javascript',Langs)). 25 | 26 | write_to_file(Text,File_name) :- 27 | open(File_name,write,Stream), 28 | write(Stream,Text), 29 | close(Stream). 30 | 31 | test_statements_in_langs(Statements,Lang1,[A]) :- 32 | test_statements(Statements,Lang1,A). 33 | 34 | test_statements_in_langs(Statements,Lang1,[A|B]) :- 35 | test_statements(Statements,Lang1,A),!,test_statements_in_langs(Statements,Lang1,B). 36 | 37 | test_statements([A],Lang1,Lang2) :- 38 | test_statement(A,Lang1,Lang2). 39 | test_statements([A|B],Lang1,Lang2) :- 40 | test_statement(A,Lang1,Lang2),!,test_statements(B,Lang1,Lang2). 41 | 42 | test_statement(Input,Lang1,Lang2) :- 43 | writeln('\n'), 44 | writeln([translate,Lang1,to,Lang2]), 45 | atom_codes(Input1,Input), 46 | atom_chars(Input1,Input2), 47 | transpiler:translate(Lang1,Lang2,Input2,Output),!,atom_chars(Output1,Output),writeln(Output1),write_output_to_file(Lang2,Output1). 48 | 49 | write_output_to_file(perl,Text) :- 50 | write_to_file(Text,'perl_source.pl'). 51 | write_output_to_file(java,Text) :- 52 | write_to_file(Text,'java_source.java'). 53 | write_output_to_file(javascript,Text) :- 54 | write_to_file(Text,'javascript_source.js'). 55 | write_output_to_file(php,Text) :- 56 | write_to_file(Text,'php_source.php'). 57 | write_output_to_file(lua,Text) :- 58 | write_to_file(Text,'lua_source.lua'). 59 | write_output_to_file('c++',Text) :- 60 | write_to_file(Text,'cpp_source.cpp'). 61 | write_output_to_file('scala',Text) :- 62 | write_to_file(Text,'scala_source.txt'). 63 | write_output_to_file('erlang',Text) :- 64 | write_to_file(Text,'erlang_source.txt'). 65 | write_output_to_file('c',Text) :- 66 | write_to_file(Text,'c_source.c'). 67 | write_output_to_file('ruby',Text) :- 68 | write_to_file(Text,'ruby_source.rb'). 69 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.lua: -------------------------------------------------------------------------------- 1 | c_math = { 2 | sin = function(a) return math.sin(a) end, 3 | cos = function(a) return math.cos(a) end, 4 | tan = function(a) return math.cos(a) end, 5 | abs = function(x) 6 | return x >= 0 and x or -x 7 | end 8 | } 9 | 10 | python = { 11 | filter = function(func, tbl) 12 | local newtbl= {} 13 | for i,v in pairs(tbl) do 14 | if func(v) then 15 | newtbl[i]=v 16 | end 17 | end 18 | return newtbl 19 | end, 20 | statistics = { 21 | mean = function(t) 22 | local sum = 0 23 | local count= 0 24 | 25 | for k,v in pairs(t) do 26 | if type(v) == 'number' then 27 | sum = sum + v 28 | count = count + 1 29 | end 30 | end 31 | 32 | return (sum / count) 33 | end 34 | }, 35 | math = c_math, 36 | map = function(predicate, t) 37 | --http://inmatarian.github.io/2015/08/09/send_more_money/ 38 | local result = {} 39 | for i = 1, #t do 40 | result[i] = predicate(t) 41 | end 42 | return result 43 | end, 44 | print = function(a) print(a) end, 45 | } 46 | php = { 47 | array_merge = function(t1,t2) 48 | for i=1,#t2 do 49 | t1[#t1+1] = t2[i] 50 | end 51 | return t1 52 | end, 53 | is_numeric = function(a) return tonumber(a) ~= nil end, 54 | array_keys = function(tab) 55 | --from https://stackoverflow.com/questions/12674345/lua-retrieve-list-of-keys-in-a-table 56 | local keyset={} 57 | local n=0 58 | for k,v in pairs(tab) do 59 | n=n+1 60 | keyset[n]=k 61 | end 62 | return keyset 63 | end, 64 | levenshtein = function(s,t) 65 | -- from https://rosettacode.org/wiki/Levenshtein_distance#Lua 66 | if s == '' then return t:len() end 67 | if t == '' then return s:len() end 68 | 69 | local s1 = s:sub(2, -1) 70 | local t1 = t:sub(2, -1) 71 | 72 | if s:sub(0, 1) == t:sub(0, 1) then 73 | return leven(s1, t1) 74 | end 75 | 76 | return 1 + math.min( 77 | leven(s1, t1), 78 | leven(s, t1), 79 | leven(s1, t ) 80 | ) 81 | end, 82 | strtolower = function(a) return a:lower() end, 83 | strtoupper = function(a) return a:upper() end, 84 | explode = function(sep,inputstr) 85 | if sep == nil then 86 | sep = "%s" 87 | end 88 | local t={} 89 | for str in string.gmatch(inputstr, "([^"..sep.."]+)") do 90 | table.insert(t, str) 91 | end 92 | return t 93 | end, 94 | trim = function(a) return trim(a) end, 95 | strlen = function(a) return len end, 96 | echo = function(a) print(a) end 97 | } 98 | c = c_math 99 | ruby = {puts=function(a) print(a) end} 100 | perl = {uc = php.strtoupper,lc=php.strtolower} 101 | python.abs = c_math.abs 102 | 103 | 104 | -- Get the mean value of a table 105 | 106 | 107 | -- Get the mode of a table. Returns a table of values. 108 | -- Works on anything (not just numbers). 109 | 110 | 111 | print(python.print(1)) 112 | print(ruby.puts(1)) 113 | print(perl.uc("Hi")) 114 | print(perl.lc("Hi")) 115 | print(python.abs(3)) 116 | print(python.statistics.mean({1,2,5})) 117 | -------------------------------------------------------------------------------- /prolog/dot_expr.pl: -------------------------------------------------------------------------------- 1 | dot_expr(Data,bool,startswith(Str1,Str2)) --> 2 | startswith_(Data,[ 3 | parentheses_expr(Data,string,Str1), 4 | parentheses_expr(Data,string,Str2) 5 | ]). 6 | 7 | dot_expr(Data,bool,endswith(Str1,Str2)) --> 8 | endswith_(Data,[ 9 | parentheses_expr(Data,string,Str1), 10 | expr(Data,string,Str2) 11 | ]). 12 | 13 | dot_expr(Data,[array,Type],array_slice(Str,Index1,Index2)) --> 14 | array_slice_(Data,[ 15 | parentheses_expr(Data,[array,Type],Str), 16 | parentheses_expr(Data,int,Index1), 17 | parentheses_expr(Data,int,Index2) 18 | ]). 19 | 20 | dot_expr(Data,string,join_(Array,Separator)) --> 21 | join_(Data,[ 22 | parentheses_expr(Data,[array,string],Array), 23 | parentheses_expr(Data,string,Separator) 24 | ]). 25 | 26 | dot_expr(Data,int,random_int_in_range(Start,End)) --> 27 | random_int_in_range(Data,[ 28 | expr(Data,int,Start), 29 | expr(Data,int,End) 30 | ]). 31 | 32 | dot_expr(Data,string,get_user_input) --> 33 | get_user_input_(Data). 34 | 35 | dot_expr(Data,double,sqrt(Exp1)) --> 36 | sqrt(Data,[expr(Data,double,Exp1)]). 37 | 38 | 39 | dot_expr(Data,Type,list_comprehension(Result,Var,Condition,Array)) --> 40 | list_comprehension_(Data,[ 41 | var_name_(Data,Type,Var), 42 | expr(Data,[array,Type],Array), 43 | expr(Data,Type,Result), 44 | expr(Data,bool,Condition) 45 | ]). 46 | 47 | dot_expr(Data,Type,list_comprehension_1(Result,Var,Array)) --> 48 | list_comprehension_1_(Data,[ 49 | var_name_(Data,Type,Var), 50 | expr(Data,[array,Type],Array), 51 | expr(Data,Type,Result) 52 | ]). 53 | 54 | dot_expr(Data,[array,Type],reverse_list(List,Type)) --> 55 | reverse_list_(Data,[ 56 | parentheses_expr(Data,[array,Type],List) 57 | ]),!. 58 | 59 | dot_expr(Data,string,reverse_string(Str)) --> 60 | reverse_string_(Data,[ 61 | expr(Data,string,Str) 62 | ]),!. 63 | 64 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 65 | dot_expr(Data,string,trim(Str)) --> 66 | trim_(Data,[ 67 | parentheses_expr(Data,string,Str) 68 | ]),!. 69 | 70 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 71 | dot_expr(Data,string,lstrip(Str)) --> 72 | lstrip_(Data,[ 73 | parentheses_expr(Data,string,Str) 74 | ]),!. 75 | 76 | %https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim 77 | dot_expr(Data,string,rstrip(Str)) --> 78 | rstrip_(Data,[ 79 | parentheses_expr(Data,string,Str) 80 | ]),!. 81 | 82 | %all characters to lowercase 83 | dot_expr(Data,string,lowercase(Str)) --> 84 | lowercase_(Data,[ 85 | parentheses_expr(Data,string,Str) 86 | ]),!. 87 | 88 | %all characters to uppercase 89 | dot_expr(Data,string,uppercase(Str)) --> 90 | uppercase_(Data,[ 91 | parentheses_expr(Data,string,Str) 92 | ]),!. 93 | 94 | dot_expr(Data,int,strlen(A)) --> 95 | strlen_(Data,[parentheses_expr(Data,string,A)]). 96 | 97 | dot_expr(Data,int,array_length(A,Type)) --> 98 | array_length(Data,[ 99 | parentheses_expr(Data,[array,Type],A) 100 | ]). 101 | 102 | dot_expr(Data,[array,Type],remove_duplicates(A,Type)) --> 103 | remove_duplicates(Data,[ 104 | parentheses_expr(Data,[array,Type],A) 105 | ]). 106 | 107 | dot_expr(Data,Type,parentheses_expr(A)) --> 108 | parentheses_expr(Data,Type,A). 109 | -------------------------------------------------------------------------------- /prolog/simplified translator/ruby_source.rb: -------------------------------------------------------------------------------- 1 | 2 | 3 | def infix_arithmetic_langs(lang) 4 | return ["javascript","perl","python","java","lua","c","c++","perl","ruby","haxe"].include?(lang) 5 | end 6 | def last_char(the_string) 7 | return the_string[(the_string.size)-1] 8 | end 9 | def index_in_array(the_arr,to_find) 10 | i=0 11 | while(i=",a,b) 88 | end 89 | def greater_than(lang,a,b) 90 | return infix_operator(lang,">",a,b) 91 | end 92 | def compare(lang,a,b) 93 | return infix_operator(lang,"==",a,b) 94 | end 95 | def concatenate_string(lang,a,b) 96 | if ["lua"].include?(lang) then 97 | return infix_operator(lang,"..",a,b) 98 | elsif ["php","perl"].include?(lang) 99 | return infix_operator(lang,".",a,b) 100 | elsif ["haskell"].include?(lang) 101 | return infix_operator(lang,"++",a,b) 102 | else 103 | return infix_operator(lang,"+",a,b) 104 | end 105 | end 106 | def compare_strings(lang,a,b) 107 | if ["php","javascript"].include?(lang) then 108 | return infix_operator(lang,"===",a,b) 109 | elsif ["prolog"].include?(lang) 110 | return infix_operator(lang,"=",a,b) 111 | elsif ["python"].include?(lang) 112 | return infix_operator(lang,"==",a,b) 113 | else 114 | return "undefined" 115 | end 116 | end 117 | def indent_line(line,number_of_indents) 118 | i=0 119 | while(i "+b; 111 | } 112 | else{ 113 | return "(> "+a+" "+b+")"; 114 | } 115 | } 116 | public static String indent_line(String line,double number_of_indents){ 117 | double i=0; 118 | while(i=" return '>=' 13 | ">" return '>' 14 | "<=" return '<=' 15 | "<" return '<' 16 | "=>" return '=>' 17 | "==" return '==' 18 | "=" return '=' 19 | "*=" return '*=' 20 | "*" return '*' 21 | "/=" return '/=' 22 | "/" return '/' 23 | "-=" return '-=' 24 | "--" return '--' 25 | "-" return '-' 26 | "++" return '++' 27 | "+=" return '+=' 28 | "+" return '+' 29 | "^" return '^' 30 | "{" return '{' 31 | "}" return '}' 32 | "[" return '[' 33 | "]" return ']' 34 | "(" return '(' 35 | ")" return ')' 36 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 37 | <> return 'EOF' 38 | . return 'INVALID' 39 | 40 | /lex 41 | 42 | /* operator associations and precedence */ 43 | 44 | %left '->' 45 | %left ';' 46 | %left ',' 47 | %left '<' '=<' '>' '>=' '=' '==' 'is' 48 | %left '+' '-' 49 | %left '*' '/' 50 | %left UMINUS 51 | 52 | %start expressions 53 | 54 | %% /* language grammar */ 55 | 56 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 57 | 58 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 59 | [$1];}; 60 | 61 | statements: statements_ {$$ = ["top_level_statements",$1]}; 62 | 63 | statement: 64 | "(" "defn" IDENTIFIER "[" parameters "]" statement ")" {$$ = ["function","public","Object",$3,$5,$7]} 65 | | e {$$=["statements",[["semicolon",["return",$1]]]];}; 66 | 67 | operator: 68 | | "not" {$$ = "!"} 69 | | "or" {$$ = "logic_or";} 70 | | "and" {$$ = "logic_and";} 71 | | ">=" 72 | | ">" 73 | | "<=" 74 | | "<" 75 | | "*" 76 | | "/" 77 | | "+" 78 | | "-"; 79 | 80 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 81 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 82 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 83 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 84 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 85 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 86 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 87 | 88 | e: 89 | '(' '=' e equal_exprs ')' {$$ = [$2,$3,$4];} 90 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 91 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 92 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 93 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 94 | | '(' 'or' e or_exprs ')' {$$ = ["logic_or",$3,$4];} 95 | | '(' 'and' e and_exprs ')' {$$ = ["logic_and",$3,$4];} 96 | | function_call 97 | | NUMBER 98 | {$$ = yytext;} 99 | | var_name 100 | {$$ = yytext;} 101 | | STRING_LITERAL 102 | {$$ = yytext;}; 103 | 104 | parameter: var_name {$$ = ["Object", $1];}; 105 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 106 | [$1];}; 107 | 108 | function_call: 109 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 110 | 111 | var_name: IDENTIFIER; 112 | 113 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 114 | -------------------------------------------------------------------------------- /prolog/simplified translator/php_source.php: -------------------------------------------------------------------------------- 1 | 2 | 3 | function infix_arithmetic_langs($lang){ 4 | return in_array($lang,array("javascript","perl","python","java","lua","c","c++","perl","ruby","haxe")); 5 | } 6 | function last_char($the_string){ 7 | return $the_string[(strlen($the_string))-1]; 8 | } 9 | function index_in_array($the_arr,$to_find){ 10 | $i=0; 11 | while($i=",$a,$b); 95 | } 96 | function greater_than($lang,$a,$b){ 97 | return infix_operator($lang,">",$a,$b); 98 | } 99 | function compare($lang,$a,$b){ 100 | return infix_operator($lang,"==",$a,$b); 101 | } 102 | function concatenate_string($lang,$a,$b){ 103 | if(in_array($lang,array("lua"))){ 104 | return infix_operator($lang,"..",$a,$b); 105 | } 106 | else if(in_array($lang,array("php","perl"))){ 107 | return infix_operator($lang,".",$a,$b); 108 | } 109 | else if(in_array($lang,array("haskell"))){ 110 | return infix_operator($lang,"++",$a,$b); 111 | } 112 | else{ 113 | return infix_operator($lang,"+",$a,$b); 114 | } 115 | } 116 | function compare_strings($lang,$a,$b){ 117 | if(in_array($lang,array("php","javascript"))){ 118 | return infix_operator($lang,"===",$a,$b); 119 | } 120 | else if(in_array($lang,array("prolog"))){ 121 | return infix_operator($lang,"=",$a,$b); 122 | } 123 | else if(in_array($lang,array("python"))){ 124 | return infix_operator($lang,"==",$a,$b); 125 | } 126 | else{ 127 | return "undefined"; 128 | } 129 | } 130 | function indent_line($line,$number_of_indents){ 131 | $i=0; 132 | while($i<$number_of_indents){ 133 | $line=" ".$line; 134 | $i++; 135 | } 136 | return $line; 137 | } -------------------------------------------------------------------------------- /prolog/simplified translator/javascript_source.js: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | function infix_arithmetic_langs(lang){ 6 | return ["javascript","perl","python","java","lua","c","c++","perl","ruby","haxe"].indexOf(lang) !== -1; 7 | } 8 | 9 | function last_char(the_string){ 10 | return the_string.charAt((the_string.length) - 1); 11 | } 12 | 13 | function index_in_array(the_arr,to_find){ 14 | var i = 0; 15 | while(i < the_arr.length){ 16 | var the_index = the_arr[i]; 17 | if(the_index+0 === to_find){ 18 | return the_arr[i]; 19 | } 20 | else{ 21 | i++; 22 | } 23 | } 24 | return -1; 25 | } 26 | 27 | function matches_pattern(arr,pattern){ 28 | if(pattern.length !== arr.length){ 29 | return false; 30 | } 31 | else{ 32 | var i = 0; 33 | while(i=",a,b); 111 | } 112 | 113 | function greater_than(lang,a,b){ 114 | return infix_operator(lang,">",a,b); 115 | } 116 | 117 | function compare(lang,a,b){ 118 | return infix_operator(lang,"==",a,b); 119 | } 120 | 121 | function concatenate_string(lang,a,b){ 122 | if(["lua"].indexOf(lang) !== -1){ 123 | return infix_operator(lang,"..",a,b); 124 | } 125 | else if(["php","perl"].indexOf(lang) !== -1){ 126 | return infix_operator(lang,".",a,b); 127 | } 128 | else if(["haskell"].indexOf(lang) !== -1){ 129 | return infix_operator(lang,"++",a,b); 130 | } 131 | else{ 132 | return infix_operator(lang,"+",a,b); 133 | } 134 | } 135 | 136 | function compare_strings(lang,a,b){ 137 | if(['php','javascript'].indexOf(lang) !== -1){ 138 | return infix_operator(lang,"===",a,b); 139 | } 140 | else if(['prolog'].indexOf(lang) !== -1){ 141 | return infix_operator(lang,"=",a,b); 142 | } 143 | else if(['python'].indexOf(lang) !== -1){ 144 | return infix_operator(lang,"==",a,b); 145 | } 146 | else{ 147 | return "undefined"; 148 | } 149 | } 150 | 151 | function indent_line(line,number_of_indents){ 152 | var i = 0; 153 | while(i < number_of_indents){ 154 | line = " "+line; 155 | i++; 156 | } 157 | return line; 158 | } 159 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/pddl_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | ":action" return ':action' 9 | ":parameters" return ':parameters' 10 | ":precondition" return ':precondition' 11 | ":effect" return ':effect' 12 | "assert" return 'assert' 13 | "not" return 'not' 14 | "and" return 'and' 15 | "?" return '?' 16 | ">=" return '>=' 17 | ">" return '>' 18 | "<=" return '<=' 19 | "<" return '<' 20 | "=>" return '=>' 21 | "==" return '==' 22 | "=" return '=' 23 | "*=" return '*=' 24 | "*" return '*' 25 | "/=" return '/=' 26 | "/" return '/' 27 | "-=" return '-=' 28 | "--" return '--' 29 | "-" return '-' 30 | "++" return '++' 31 | "+=" return '+=' 32 | "+" return '+' 33 | "^" return '^' 34 | "{" return '{' 35 | "}" return '}' 36 | "[" return '[' 37 | "]" return ']' 38 | "(" return '(' 39 | ")" return ')' 40 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 41 | <> return 'EOF' 42 | . return 'INVALID' 43 | 44 | /lex 45 | 46 | /* operator associations and precedence */ 47 | 48 | %left '->' 49 | %left ';' 50 | %left ',' 51 | %left '<' '=<' '>' '>=' '=' '==' 'is' 52 | %left '+' '-' 53 | %left '*' '/' 54 | %left UMINUS 55 | 56 | %start expressions 57 | 58 | %% /* language grammar */ 59 | 60 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 61 | 62 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 63 | [$1];}; 64 | 65 | statements: statements_ {$$ = ["top_level_statements",$1]}; 66 | 67 | statement 68 | : defrule 69 | | "(" "deffunction" IDENTIFIER "(" parameters ")" e ")"; 70 | 71 | 72 | 73 | operator: 74 | | "not" {$$ = "!"} 75 | | "or" {$$ = "logic_or";} 76 | | "and" {$$ = "logic_and";} 77 | | ">=" 78 | | ">" 79 | | "<=" 80 | | "<" 81 | | "*" 82 | | "/" 83 | | "+" 84 | | "-"; 85 | 86 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 87 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 88 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 89 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 90 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 91 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 92 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 93 | 94 | e: 95 | '(' '=' e equal_exprs ')' {$$ = [$2,$3,$4];} 96 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 97 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 98 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 99 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 100 | | '(' 'or' e or_exprs ')' {$$ = ["logic_or",$3,$4];} 101 | | '(' 'and' e and_exprs ')' {$$ = ["logic_and",$3,$4];} 102 | | function_call 103 | | NUMBER 104 | {$$ = yytext;} 105 | | var_name 106 | {$$ = yytext;} 107 | | STRING_LITERAL 108 | {$$ = yytext;}; 109 | 110 | parameter: var_name {$$ = ["Object", $1];}; 111 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 112 | [$1];}; 113 | 114 | function_call: 115 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 116 | 117 | var_name: "?" IDENTIFIER {$$ = $2}; 118 | 119 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 120 | 121 | defrule: 122 | "(" ":action" IDENTIFIER ":parameters" e ":precondition" e ":effect" e ")" {$$= ["defrule",$3,$7,$9]}; 123 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/picat_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "forall" return 'forall' 9 | "if" return "if" 10 | "is" return "is" 11 | "," return ',' 12 | ";" return ';' 13 | "=>" return '=>' 14 | "@" return '@' 15 | "-->" return '-->' 16 | "->" return '->' 17 | "." return '.' 18 | ":" return ':' 19 | ">=" return '>=' 20 | ">" return '>' 21 | "=<" return '=<' 22 | "<" return '<' 23 | "==" return '==' 24 | "=" return '=' 25 | "*=" return '*=' 26 | "*" return '*' 27 | "/=" return '/=' 28 | "/" return '/' 29 | "-=" return '-=' 30 | "--" return '--' 31 | "-" return '-' 32 | "++" return '++' 33 | "+=" return '+=' 34 | "+" return '+' 35 | "^" return '^' 36 | "{" return '{' 37 | "}" return '}' 38 | "|" return '|' 39 | "[" return '[' 40 | "]" return ']' 41 | "(" return '(' 42 | ")" return ')' 43 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 44 | <> return 'EOF' 45 | . return 'INVALID' 46 | 47 | /lex 48 | 49 | /* operator associations and precedence */ 50 | 51 | %left '->' 52 | %left ';' 53 | %left ',' 54 | %left '<' '=<' '>' '>=' '=' '==' 'is' 55 | %left '+' '-' 56 | %left '*' '/' 57 | %left UMINUS 58 | 59 | %start expressions 60 | 61 | %% /* language grammar */ 62 | 63 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 64 | 65 | statements_: statement "." statements_ {$$ = [$1].concat($3);} | statement "." {$$ = 66 | [$1];}; 67 | 68 | statements: statements_ {$$ = ["top_level_statements",$1]}; 69 | 70 | statement 71 | : predicate | function_call; 72 | 73 | predicate: 74 | IDENTIFIER "(" exprs ")" "=>" e {$$ = ["predicate",$1,$3,$6]} 75 | | IDENTIFIER "=>" e {$$ = ["predicate",$1,[],$3]}; 76 | 77 | e 78 | : 79 | "forall" "(" "member" "(" IDENTIFIER "," IDENTIFIER ")" "," e ")" {$$ = ["foreach","Object",$5,$7,$10];} 80 | |e '->' e 81 | {$$ = ["implies",$1,$3]} 82 | |e ';' e 83 | {$$ = ['logic_or',$1,$3];} 84 | |e ',' e 85 | {$$ = ['logic_and',$1,$3];} 86 | |e '=' e 87 | {$$ = ['logic_equals',$1,$3];} 88 | |e 'is' e 89 | {$$ = ['logic_equals',$1,$3];} 90 | |e '==' e 91 | {$$ = ['logic_equals',$1,$3];} 92 | |e '=<' e 93 | {$$ = ['<=',$1,$3];} 94 | |e '<' e 95 | {$$ = ['>',$1,$3];} 96 | | e '>=' e 97 | {$$ = ['>=',$1,$3];} 98 | |e '>' e 99 | {$$ = [$2,$1,$3];} 100 | | e '+' e 101 | {$$ = [$2,$1,$3];} 102 | | e '-' e 103 | {$$ = [$2,$1,$3];} 104 | | e '*' e 105 | {$$ = [$2,$1,$3];} 106 | | e '/' e 107 | {$$ = [$2,$1,$3];} 108 | | '-' e %prec UMINUS 109 | {$$ = ["-",$2];} 110 | | parentheses_expr 111 | ; 112 | 113 | parameter: IDENTIFIER {$$ = ["Object", $1];}; 114 | parameters: parameter "," parameters {$$ = [$1].concat($3);} | parameter {$$ = 115 | [$1];} | {$$ = []}; 116 | 117 | function_call: 118 | IDENTIFIER "(" ")" {$$ = ["function_call",$1,[]];} | IDENTIFIER "(" exprs ")" {$$ = ["function_call",$1,$3];}; 119 | 120 | parentheses_expr: 121 | function_call 122 | | '(' e ')' {$$ = $2;} 123 | | "[" "]" {$$ = ["initializer_list","Object",[]];} 124 | | "[" exprs "]" {$$ = ["initializer_list","Object",$2];} 125 | | "[" dot_expr "|" exprs "]" {$$ = ["list_head_tail","Object",$2,["initializer_list","Object",$4]];} 126 | | NUMBER 127 | {$$ = yytext;} 128 | | IDENTIFIER 129 | {$$ = yytext;} 130 | | STRING_LITERAL 131 | {$$ = yytext;}; 132 | 133 | exprs: exprs "," parentheses_expr {$$ = $1.concat([$3]);} | parentheses_expr {$$ = [$1];}; 134 | -------------------------------------------------------------------------------- /translated_functions/translated_functions.js: -------------------------------------------------------------------------------- 1 | var pampy = require('pampy'); 2 | const randexp = require('randexp'); 3 | //var Algebrite = require('algebrite'); 4 | //var logicjs = require('logicjs'); 5 | //var mathjs = require('mathjs'); 6 | //var lp_solver = require('javascript-lp-solver'); 7 | //var lzma = require('lzma'); 8 | 9 | 10 | class C_math{ 11 | static sin(a){ 12 | return Math.sin(a); 13 | } 14 | static cos(a){ 15 | return Math.cos(a); 16 | } 17 | static tan(a){ 18 | return Math.tan(a); 19 | } 20 | static floor(a){ 21 | return Math.floor(a); 22 | } 23 | static ceil(a){ 24 | return Math.ceil(a); 25 | } 26 | static log(a){ 27 | return Math.log(a); 28 | } 29 | static sqrt(a){ 30 | return Math.sqrt(a); 31 | } 32 | static exp(a){ 33 | return Math.exp(a); 34 | } 35 | } 36 | 37 | class Prolog { 38 | static nonvar(variable) { 39 | return (typeof variable !== 'undefined'); 40 | } 41 | static length(the_list,the_length){ 42 | return list.length === the_length; 43 | } 44 | //unfortunately, functions in JavaScript can't be named "var" 45 | } 46 | 47 | class Php{ 48 | static isNumeric(n) { 49 | //from https://stackoverflow.com/questions/18082/validate-decimal-numbers-in-javascript-isnumeric 50 | return !isNaN(parseFloat(n)) && isFinite(n); 51 | } 52 | static in_array(needle,haystack){ 53 | return haystack.includes(needle); 54 | } 55 | static array_merge(arr1,arr2){ 56 | return arr1.concat(arr2); 57 | } 58 | static array_map(fun,iter){ 59 | return Python.map(fun,iter); 60 | } 61 | static JSON_decode(a){ 62 | return JSON.parse(a); 63 | } 64 | static JSON_encode(a){ 65 | return JSON.stringify(a); 66 | } 67 | //unfortunately, functions in JavaScript can't be named "var" 68 | } 69 | 70 | class Python { 71 | constructor(self){ 72 | this.self = self; 73 | } 74 | any(variable){ 75 | return this.self.includes(variable); 76 | } 77 | static print(a){ 78 | console.log(a); 79 | } 80 | append(variable){ 81 | this.self.push(variable); 82 | } 83 | static map(fun,iter){ 84 | return iter.map(fun); 85 | } 86 | static type(a){ 87 | if(Array.isArray(a)){ 88 | return "list" 89 | } 90 | else if(typeof(a) === "boolean"){ 91 | return "bool"; 92 | } 93 | else if(typeof(a) === "string"){ 94 | return "str"; 95 | } 96 | } 97 | static is_instance(a,b){ 98 | return A instanceof B; 99 | } 100 | split(separator){ 101 | return this.self.split(separator); 102 | } 103 | upper(){ 104 | return this.self.toUpperCase(); 105 | } 106 | lower(){ 107 | return this.self.toLowerCase(); 108 | } 109 | join(the_list){ 110 | return the_list.join(this.self); 111 | } 112 | find(to_find){ 113 | return this.self.indexOf(to_find); 114 | } 115 | pop(variable){ 116 | //what should it return? 117 | this.self.pop(variable); 118 | } 119 | reverse(variable){ 120 | //what should it return? 121 | this.self.reverse(variable); 122 | } 123 | //unfortunately, functions in JavaScript can't be named "var" 124 | } 125 | 126 | class JavaScript{} 127 | 128 | JavaScript.json = class { 129 | static loads(a){ 130 | return JSON.stringify(a); 131 | } 132 | } 133 | 134 | class Java{ 135 | 136 | } 137 | Java.Math = class { 138 | static min(a,b){ 139 | return Math.min(a,b); 140 | } 141 | static max(a,b){ 142 | return Math.max(a,b); 143 | } 144 | }; 145 | 146 | class C_Sharp{ 147 | 148 | } 149 | C_Sharp.Math = class { 150 | static min(a,b){ 151 | return Math.min(a,b); 152 | } 153 | static max(a,b){ 154 | return Math.max(a,b); 155 | } 156 | } 157 | 158 | class Lua{ 159 | 160 | } 161 | Lua.math = class { 162 | static max(){ 163 | return Math.max(arguments); 164 | } 165 | static min(){ 166 | return Math.min(arguments); 167 | } 168 | static random(){ 169 | return Math.random(); 170 | } 171 | }; 172 | 173 | class Ruby{ 174 | 175 | } 176 | Ruby.Math = class extends C_math{ 177 | 178 | } 179 | 180 | Ruby.JSON = class{ 181 | static parse(a){ 182 | return JSON.parse(a); 183 | } 184 | } 185 | 186 | function replaceAll(str,mapObj){ 187 | var re = new RegExp(Object.keys(mapObj).join("|"),"gi"); 188 | 189 | return str.replace(re, function(matched){ 190 | return mapObj[matched.toLowerCase()]; 191 | }); 192 | } 193 | 194 | Python.print(replaceAll("This person is here",{"person":"GUY"})) 195 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/clojure_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "'(" return "'(" 9 | "defn" return 'defn' 10 | "not" return 'not' 11 | "and" return 'and' 12 | "cond" return 'cond' 13 | ":else" return ':else' 14 | "?" return '?' 15 | ">=" return '>=' 16 | ">" return '>' 17 | "<=" return '<=' 18 | "<" return '<' 19 | "=>" return '=>' 20 | "==" return '==' 21 | "=" return '=' 22 | "*=" return '*=' 23 | "*" return '*' 24 | "/=" return '/=' 25 | "/" return '/' 26 | "-=" return '-=' 27 | "--" return '--' 28 | "-" return '-' 29 | "++" return '++' 30 | "+=" return '+=' 31 | "+" return '+' 32 | "^" return '^' 33 | "{" return '{' 34 | "}" return '}' 35 | "[" return '[' 36 | "]" return ']' 37 | "(" return '(' 38 | ")" return ')' 39 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 40 | <> return 'EOF' 41 | . return 'INVALID' 42 | 43 | /lex 44 | 45 | /* operator associations and precedence */ 46 | 47 | %left '->' 48 | %left ';' 49 | %left ',' 50 | %left '<' '=<' '>' '>=' '=' '==' 'is' 51 | %left '+' '-' 52 | %left '*' '/' 53 | %left UMINUS 54 | 55 | %start expressions 56 | 57 | %% /* language grammar */ 58 | 59 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 60 | 61 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 62 | [$1];}; 63 | 64 | statements: statements_ {$$ = ["top_level_statements",$1]}; 65 | 66 | statement: 67 | "(" "defn" IDENTIFIER "[" parameters "]" statement ")" {$$ = ["function","public","Object",$3,$5,$7]} 68 | | e {$$=["statements",[["semicolon",["return",$1]]]];} 69 | | "(" "if" e bracket_statements bracket_statements ")" {$$ = ["if",$3,$4];} 70 | | "(" "cond" e bracket_statements elif ")" {$$ = ["if",$3,$4,$5];}; 71 | 72 | elif: 73 | e bracket_statements elif {$$ = ["elif",$1,$2,$3]} 74 | | ":else" bracket_statements {$$ = ["else",$2];}; 75 | 76 | bracket_statements: statement {$$= ["statements",[$1]];}; 77 | 78 | 79 | operator: 80 | | "not" {$$ = "!"} 81 | | "or" {$$ = "logic_or";} 82 | | "and" {$$ = "logic_and";} 83 | | "*" 84 | | "/" 85 | | "+" 86 | | "-" 87 | | comparison_operator; 88 | 89 | comparison_operator: 90 | ">=" 91 | | ">" 92 | | "<=" 93 | | "<"; 94 | 95 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 96 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 97 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 98 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 99 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 100 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 101 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 102 | 103 | e: 104 | '(' '=' e equal_exprs ')' {$$ = [$2,$3,$4];} 105 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 106 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 107 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 108 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 109 | | '(' 'or' e or_exprs ')' {$$ = ["||",$3,$4];} 110 | | '(' 'and' e and_exprs ')' {$$ = ["&&",$3,$4];} 111 | | '(' comparison_operator e e ')' {$$ = [$2,$3,$4];} 112 | | function_call 113 | | "'(" exprs ")" {$$ = ["initializer_list","Object",$2]} 114 | | NUMBER 115 | {$$ = yytext;} 116 | | var_name 117 | {$$ = yytext;} 118 | | STRING_LITERAL 119 | {$$ = yytext;}; 120 | 121 | parameter: var_name {$$ = ["Object", $1];}; 122 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 123 | [$1];}; 124 | 125 | function_call: 126 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 127 | 128 | var_name: IDENTIFIER; 129 | 130 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 131 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/statement.pl: -------------------------------------------------------------------------------- 1 | optional_indent(Data,Indent,Data1) --> 2 | { 3 | indent_data(Indent,Data,Data1) 4 | }, 5 | optional_indent(Data,Indent),!. 6 | 7 | statement(Data,Type1,function(Name,Type,Params1,Body)) --> 8 | %put this at the beginning of each statement without a semicolon 9 | namespace(Data,Data1,Name1,Indent), 10 | function_(Data,[ 11 | function_name(Data,Type,Name,Params1), 12 | type(Data,Type), 13 | parameters(Data1,Params1), 14 | statements(Data1,Type,Body), 15 | Indent 16 | ]),!. 17 | 18 | %java-like class statements 19 | statement(Data,Name,class(Name,Body)) --> 20 | optional_indent(Data,Indent,Data1), 21 | class_(Data,[ 22 | symbol(Name), 23 | class_statements(Data1,Name,Body), 24 | Indent 25 | ]),!. 26 | 27 | statement(Data,C1,class_extends(C2,B)) --> 28 | namespace(Data,Data1,C1,Indent), 29 | class_extends_(Data,[ 30 | symbol(C1), 31 | symbol(C2), 32 | class_statements(Data1,C1,B), 33 | Indent 34 | ]),!. 35 | 36 | statement(Data,Return_type,semicolon(A)) --> 37 | {Data = [_,_,_,Indent],offside_rule_langs(Offside_rule_langs)}, 38 | optional_indent(Data,Indent,_), 39 | semicolon_(Data,[ 40 | statement_with_semicolon(Data,Return_type,A) 41 | ]),!. 42 | 43 | statement(Data,Return_type,for(Statement1,Expr,Statement2,Body)) --> 44 | optional_indent(Data,Indent,Data1), 45 | for_(Data,[ 46 | statement_with_semicolon(Data,Return_type,Statement1), 47 | expr(Data,bool,Expr), 48 | statement_with_semicolon(Data,Return_type,Statement2), 49 | statements(Data1,Return_type,Body), 50 | Indent 51 | ]),!. 52 | 53 | statement(Data,Return_type,foreach_with_index(Array,Var,Index,Body,Type)) --> 54 | optional_indent(Data,Indent,Data1), 55 | foreach_with_index_(Data,[ 56 | expr(Data,[array,Type],Array), 57 | var_name_(Data,Type,Var), 58 | expr(Data,int,Index), 59 | type(Data,Type), 60 | statements(Data1,Return_type,Body), 61 | Indent 62 | ]),!. 63 | 64 | statement(Data,Return_type,foreach(Array,Var,Body,Type)) --> 65 | optional_indent(Data,Indent,Data1), 66 | foreach_(Data,[ 67 | expr(Data,[array,Type],Array), 68 | var_name_(Data,Type,Var), 69 | type(Data,Type), 70 | statements(Data1,Return_type,Body), 71 | Indent 72 | ]),!. 73 | 74 | statement(Data,Return_type,try_catch(Body1,Name,Body2)) --> 75 | optional_indent(Data,Indent,Data1), 76 | try_catch_(Data,[ 77 | statements(Data1,Return_type,Body1), 78 | var_name_(Data1,int,Name), 79 | statements(Data1,Return_type,Body2), 80 | Indent 81 | ]),!. 82 | 83 | statement(Data,Return_type,while(Expr,Body)) --> 84 | optional_indent(Data,Indent,Data1), 85 | while_(Data,[ 86 | expr(Data,bool,Expr), 87 | statements(Data1,Return_type,Body), 88 | Indent 89 | ]),!. 90 | 91 | statement(Data,Return_type,do_while(Expr,Body)) --> 92 | optional_indent(Data,Indent,Data1), 93 | do_while_(Data,[ 94 | expr(Data,bool,Expr), 95 | statements(Data1,Return_type,Body), 96 | Indent 97 | ]),!. 98 | 99 | 100 | statement(Data,Return_type,if(Expr_,Statements_,Elif_or_else_,Else_)) --> 101 | optional_indent(Data,Indent,Data1), 102 | if(Data,[ 103 | expr(Data,bool,Expr_), 104 | statements(Data1,Return_type,Statements_), 105 | elif_statements(Data,Return_type,Elif_or_else_), 106 | else(Data,Return_type,Else_), 107 | Indent 108 | ]),!. 109 | 110 | statement(Data,Return_type,if_without_else(Expr_,Statements_,Elif_or_else_,Else_)) --> 111 | optional_indent(Data,Indent,Data1), 112 | if_without_else_(Data,[ 113 | expr(Data,bool,Expr_), 114 | statements(Data1,Return_type,Statements_), 115 | Indent 116 | ]),!. 117 | 118 | statement(Data,Return_type, switch(Expr_,Expr1_,Statements_,Case_or_default_)) --> 119 | optional_indent(Data,Indent,Data1), 120 | switch_(Data,[ 121 | parentheses_expr(Data,int,Expr_), 122 | first_case(Data1,Return_type,Expr_,int,[Expr1_,Statements_,Case_or_default_]), 123 | Indent 124 | ]),!. 125 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/statement.pl: -------------------------------------------------------------------------------- 1 | optional_indent(Data,Indent,Data1) --> 2 | { 3 | indent_data(Indent,Data,Data1) 4 | }, 5 | optional_indent(Data,Indent),!. 6 | 7 | statement(Data,Type1,function(Name,Type,Params1,Body)) --> 8 | %put this at the beginning of each statement without a semicolon 9 | namespace(Data,Data1,Name1,Indent), 10 | function_(Data,[ 11 | function_name(Data,Type,Name,Params1), 12 | type(Data,Type), 13 | parameters(Data1,Params1), 14 | statements(Data1,Type,Body), 15 | Indent 16 | ]),!. 17 | 18 | %java-like class statements 19 | statement(Data,Name,class(Name,Body)) --> 20 | optional_indent(Data,Indent,Data1), 21 | class_(Data,[ 22 | symbol(Name), 23 | class_statements(Data1,Name,Body), 24 | Indent 25 | ]),!. 26 | 27 | statement(Data,C1,class_extends(C2,B)) --> 28 | namespace(Data,Data1,C1,Indent), 29 | class_extends_(Data,[ 30 | symbol(C1), 31 | symbol(C2), 32 | class_statements(Data1,C1,B), 33 | Indent 34 | ]),!. 35 | 36 | statement(Data,Return_type,semicolon(A)) --> 37 | {Data = [_,_,_,Indent],offside_rule_langs(Offside_rule_langs)}, 38 | optional_indent(Data,Indent,_), 39 | semicolon_(Data,[ 40 | statement_with_semicolon(Data,Return_type,A) 41 | ]),!. 42 | 43 | statement(Data,Return_type,for(Statement1,Expr,Statement2,Body)) --> 44 | optional_indent(Data,Indent,Data1), 45 | for_(Data,[ 46 | statement_with_semicolon(Data,Return_type,Statement1), 47 | expr(Data,bool,Expr), 48 | statement_with_semicolon(Data,Return_type,Statement2), 49 | statements(Data1,Return_type,Body), 50 | Indent 51 | ]),!. 52 | 53 | statement(Data,Return_type,foreach_with_index(Array,Var,Index,Body,Type)) --> 54 | optional_indent(Data,Indent,Data1), 55 | foreach_with_index_(Data,[ 56 | expr(Data,[array,Type],Array), 57 | var_name_(Data,Type,Var), 58 | expr(Data,int,Index), 59 | type(Data,Type), 60 | statements(Data1,Return_type,Body), 61 | Indent 62 | ]),!. 63 | 64 | statement(Data,Return_type,foreach(Array,Var,Body,Type)) --> 65 | optional_indent(Data,Indent,Data1), 66 | foreach_(Data,[ 67 | expr(Data,[array,Type],Array), 68 | var_name_(Data,Type,Var), 69 | type(Data,Type), 70 | statements(Data1,Return_type,Body), 71 | Indent 72 | ]),!. 73 | 74 | statement(Data,Return_type,try_catch(Body1,Name,Body2)) --> 75 | optional_indent(Data,Indent,Data1), 76 | try_catch_(Data,[ 77 | statements(Data1,Return_type,Body1), 78 | var_name_(Data1,int,Name), 79 | statements(Data1,Return_type,Body2), 80 | Indent 81 | ]),!. 82 | 83 | statement(Data,Return_type,while(Expr,Body)) --> 84 | optional_indent(Data,Indent,Data1), 85 | while_(Data,[ 86 | expr(Data,bool,Expr), 87 | statements(Data1,Return_type,Body), 88 | Indent 89 | ]),!. 90 | 91 | statement(Data,Return_type,do_while(Expr,Body)) --> 92 | optional_indent(Data,Indent,Data1), 93 | do_while_(Data,[ 94 | expr(Data,bool,Expr), 95 | statements(Data1,Return_type,Body), 96 | Indent 97 | ]),!. 98 | 99 | 100 | statement(Data,Return_type,if(Expr_,Statements_,Elif_or_else_,Else_)) --> 101 | optional_indent(Data,Indent,Data1), 102 | if(Data,[ 103 | expr(Data,bool,Expr_), 104 | statements(Data1,Return_type,Statements_), 105 | elif_statements(Data,Return_type,Elif_or_else_), 106 | else(Data,Return_type,Else_), 107 | Indent 108 | ]),!. 109 | 110 | statement(Data,Return_type,if_without_else(Expr_,Statements_,Elif_or_else_,Else_)) --> 111 | optional_indent(Data,Indent,Data1), 112 | if_without_else_(Data,[ 113 | expr(Data,bool,Expr_), 114 | statements(Data1,Return_type,Statements_), 115 | Indent 116 | ]),!. 117 | 118 | statement(Data,Return_type, switch(Expr_,Expr1_,Statements_,Case_or_default_)) --> 119 | optional_indent(Data,Indent,Data1), 120 | switch_(Data,[ 121 | parentheses_expr(Data,int,Expr_), 122 | first_case(Data1,Return_type,Expr_,int,[Expr1_,Statements_,Case_or_default_]), 123 | Indent 124 | ]),!. 125 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/statement.pl: -------------------------------------------------------------------------------- 1 | optional_indent(Data,Indent,Data1) --> 2 | { 3 | indent_data(Indent,Data,Data1) 4 | }, 5 | optional_indent(Data,Indent),!. 6 | 7 | statement(Data,Type1,function(Name,Type,Params1,Body)) --> 8 | %put this at the beginning of each statement without a semicolon 9 | namespace(Data,Data1,Name1,Indent), 10 | function_(Data,[ 11 | function_name(Data,Type,Name,Params1), 12 | type(Data,Type), 13 | parameters(Data1,Params1), 14 | statements(Data1,Type,Body), 15 | Indent 16 | ]),!. 17 | 18 | %java-like class statements 19 | statement(Data,Name,class(Name,Body)) --> 20 | optional_indent(Data,Indent,Data1), 21 | class_(Data,[ 22 | symbol(Name), 23 | class_statements(Data1,Name,Body), 24 | Indent 25 | ]),!. 26 | 27 | statement(Data,C1,class_extends(C2,B)) --> 28 | namespace(Data,Data1,C1,Indent), 29 | class_extends_(Data,[ 30 | symbol(C1), 31 | symbol(C2), 32 | class_statements(Data1,C1,B), 33 | Indent 34 | ]),!. 35 | 36 | statement(Data,Return_type,semicolon(A)) --> 37 | {Data = [_,_,_,Indent],offside_rule_langs(Offside_rule_langs)}, 38 | optional_indent(Data,Indent,_), 39 | semicolon_(Data,[ 40 | statement_with_semicolon(Data,Return_type,A) 41 | ]),!. 42 | 43 | statement(Data,Return_type,for(Statement1,Expr,Statement2,Body)) --> 44 | optional_indent(Data,Indent,Data1), 45 | for_(Data,[ 46 | statement_with_semicolon(Data,Return_type,Statement1), 47 | expr(Data,bool,Expr), 48 | statement_with_semicolon(Data,Return_type,Statement2), 49 | statements(Data1,Return_type,Body), 50 | Indent 51 | ]),!. 52 | 53 | statement(Data,Return_type,foreach_with_index(Array,Var,Index,Body,Type)) --> 54 | optional_indent(Data,Indent,Data1), 55 | foreach_with_index_(Data,[ 56 | expr(Data,[array,Type],Array), 57 | var_name_(Data,Type,Var), 58 | expr(Data,int,Index), 59 | type(Data,Type), 60 | statements(Data1,Return_type,Body), 61 | Indent 62 | ]),!. 63 | 64 | statement(Data,Return_type,foreach(Array,Var,Body,Type)) --> 65 | optional_indent(Data,Indent,Data1), 66 | foreach_(Data,[ 67 | expr(Data,[array,Type],Array), 68 | var_name_(Data,Type,Var), 69 | type(Data,Type), 70 | statements(Data1,Return_type,Body), 71 | Indent 72 | ]),!. 73 | 74 | statement(Data,Return_type,try_catch(Body1,Name,Body2)) --> 75 | optional_indent(Data,Indent,Data1), 76 | try_catch_(Data,[ 77 | statements(Data1,Return_type,Body1), 78 | var_name_(Data1,int,Name), 79 | statements(Data1,Return_type,Body2), 80 | Indent 81 | ]),!. 82 | 83 | statement(Data,Return_type,while(Expr,Body)) --> 84 | optional_indent(Data,Indent,Data1), 85 | while_(Data,[ 86 | expr(Data,bool,Expr), 87 | statements(Data1,Return_type,Body), 88 | Indent 89 | ]),!. 90 | 91 | statement(Data,Return_type,do_while(Expr,Body)) --> 92 | optional_indent(Data,Indent,Data1), 93 | do_while_(Data,[ 94 | expr(Data,bool,Expr), 95 | statements(Data1,Return_type,Body), 96 | Indent 97 | ]),!. 98 | 99 | 100 | statement(Data,Return_type,if(Expr_,Statements_,Elif_or_else_,Else_)) --> 101 | optional_indent(Data,Indent,Data1), 102 | if(Data,[ 103 | expr(Data,bool,Expr_), 104 | statements(Data1,Return_type,Statements_), 105 | elif_statements(Data,Return_type,Elif_or_else_), 106 | else(Data,Return_type,Else_), 107 | Indent 108 | ]),!. 109 | 110 | statement(Data,Return_type,if_without_else(Expr_,Statements_,Elif_or_else_,Else_)) --> 111 | optional_indent(Data,Indent,Data1), 112 | if_without_else_(Data,[ 113 | expr(Data,bool,Expr_), 114 | statements(Data1,Return_type,Statements_), 115 | Indent 116 | ]),!. 117 | 118 | statement(Data,Return_type, switch(Expr_,Expr1_,Statements_,Case_or_default_)) --> 119 | optional_indent(Data,Indent,Data1), 120 | switch_(Data,[ 121 | parentheses_expr(Data,int,Expr_), 122 | first_case(Data1,Return_type,Expr_,int,[Expr1_,Statements_,Case_or_default_]), 123 | Indent 124 | ]),!. 125 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/core_logic_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "'(" return "'(" 9 | "defne" return 'defne' 10 | "not" return 'not' 11 | "and" return 'and' 12 | "conde" return 'conde' 13 | ":else" return ':else' 14 | "?" return '?' 15 | ">=" return '>=' 16 | ">" return '>' 17 | "<=" return '<=' 18 | "<" return '<' 19 | "=>" return '=>' 20 | "==" return '==' 21 | "=" return '=' 22 | "*=" return '*=' 23 | "*" return '*' 24 | "/=" return '/=' 25 | "/" return '/' 26 | "-=" return '-=' 27 | "--" return '--' 28 | "-" return '-' 29 | "++" return '++' 30 | "+=" return '+=' 31 | "+" return '+' 32 | "^" return '^' 33 | "{" return '{' 34 | "}" return '}' 35 | "[" return '[' 36 | "]" return ']' 37 | "(" return '(' 38 | ")" return ')' 39 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 40 | <> return 'EOF' 41 | . return 'INVALID' 42 | 43 | /lex 44 | 45 | /* operator associations and precedence */ 46 | 47 | %left '->' 48 | %left ';' 49 | %left ',' 50 | %left '<' '=<' '>' '>=' '=' '==' 'is' 51 | %left '+' '-' 52 | %left '*' '/' 53 | %left UMINUS 54 | 55 | %start expressions 56 | 57 | %% /* language grammar */ 58 | 59 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 60 | 61 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 62 | [$1];}; 63 | 64 | statements: statements_ {$$ = ["top_level_statements",$1]}; 65 | 66 | statement: 67 | "(" "defne" IDENTIFIER "[" parameters "]" statement ")" {$$ = ["function","public","Object",$3,$5,$7]} 68 | | e {$$=["statements",[["semicolon",["return",$1]]]];} 69 | | "(" "if" e bracket_statements bracket_statements ")" {$$ = ["if",$3,$4];} 70 | | "(" "cond" e bracket_statements elif ")" {$$ = ["if",$3,$4,$5];}; 71 | 72 | elif: 73 | e bracket_statements elif {$$ = ["elif",$1,$2,$3]} 74 | | ":else" bracket_statements {$$ = ["else",$2];}; 75 | 76 | bracket_statements: statement {$$= ["statements",[$1]];}; 77 | 78 | 79 | operator: 80 | | "not" {$$ = "!"} 81 | | "or" {$$ = "logic_or";} 82 | | "and" {$$ = "logic_and";} 83 | | "*" 84 | | "/" 85 | | "+" 86 | | "-" 87 | | comparison_operator; 88 | 89 | comparison_operator: 90 | ">=" 91 | | ">" 92 | | "<=" 93 | | "<"; 94 | 95 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 96 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 97 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 98 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 99 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 100 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 101 | or_exprs: or_exprs or_expr {$$ = ["logic_or",$1,$2]} | or_expr; 102 | or_expr: "[" and_exprs "]" {$$ = $2}; 103 | 104 | e: 105 | '(' '==' e equal_exprs ')' {$$ = ["logic_equals",$3,$4];} 106 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 107 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 108 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 109 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 110 | | '(' 'conde' or_exprs ')' {$$ = $3;} 111 | | '(' 'and' e and_exprs ')' {$$ = ["logic_and",$3,$4];} 112 | | '(' comparison_operator e e ')' {$$ = [$2,$3,$4];} 113 | | function_call 114 | | "'(" exprs ")" {$$ = ["initializer_list","Object",$2]} 115 | | NUMBER 116 | {$$ = yytext;} 117 | | var_name 118 | {$$ = yytext;} 119 | | STRING_LITERAL 120 | {$$ = yytext;}; 121 | 122 | parameter: var_name {$$ = ["Object", $1];}; 123 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 124 | [$1];}; 125 | 126 | function_call: 127 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 128 | 129 | var_name: IDENTIFIER; 130 | 131 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 132 | -------------------------------------------------------------------------------- /prolog/simplified translator/java_source.java: -------------------------------------------------------------------------------- 1 | 2 | 3 | public static boolean infix_arithmetic_langs(String lang){ 4 | return Arrays.asList(new String[]{"javascript","perl","python","java","lua","c","c++","perl","ruby","haxe"}).contains(lang); 5 | } 6 | public static char last_char(String the_string){ 7 | return the_string.charAt((the_string.length())-1); 8 | } 9 | public static double index_in_array(double[] the_arr,double to_find){ 10 | int i=0; 11 | while(i=",a,b); 95 | } 96 | public static String greater_than(String lang,String a,String b){ 97 | return infix_operator(lang,">",a,b); 98 | } 99 | public static String compare(String lang,String a,String b){ 100 | return infix_operator(lang,"==",a,b); 101 | } 102 | public static String concatenate_string(String lang,String a,String b){ 103 | if(Arrays.asList(new String[]{"lua"}).contains(lang)){ 104 | return infix_operator(lang,"..",a,b); 105 | } 106 | else if(Arrays.asList(new String[]{"php","perl"}).contains(lang)){ 107 | return infix_operator(lang,".",a,b); 108 | } 109 | else if(Arrays.asList(new String[]{"haskell"}).contains(lang)){ 110 | return infix_operator(lang,"++",a,b); 111 | } 112 | else{ 113 | return infix_operator(lang,"+",a,b); 114 | } 115 | } 116 | public static String compare_strings(String lang,String a,String b){ 117 | if(Arrays.asList(new String[]{"php","javascript"}).contains(lang)){ 118 | return infix_operator(lang,"===",a,b); 119 | } 120 | else if(Arrays.asList(new String[]{"prolog"}).contains(lang)){ 121 | return infix_operator(lang,"=",a,b); 122 | } 123 | else if(Arrays.asList(new String[]{"python"}).contains(lang)){ 124 | return infix_operator(lang,"==",a,b); 125 | } 126 | else{ 127 | return "undefined"; 128 | } 129 | } 130 | public static String indent_line(String line,double number_of_indents){ 131 | double i=0; 132 | while(i" return '<=>' 16 | "!" return "!" 17 | "?" return "?" 18 | "@" return '@' 19 | "=>" return '=>' 20 | ":-" return ':-' 21 | "." return '.' 22 | ":" return ':' 23 | ">=" return '>=' 24 | ">" return '>' 25 | "=<" return '=<' 26 | "<" return '<' 27 | "==" return '==' 28 | "=" return '=' 29 | "*=" return '*=' 30 | "*" return '*' 31 | "~" return '~' 32 | "\\=" return '\\=' 33 | "/" return '/' 34 | "-=" return '-=' 35 | "--" return '--' 36 | "-" return '-' 37 | "++" return '++' 38 | "+=" return '+=' 39 | "+" return '+' 40 | "^" return '^' 41 | "{" return '{' 42 | "}" return '}' 43 | "|" return '|' 44 | "[" return '[' 45 | "]" return ']' 46 | "(" return '(' 47 | ")" return ')' 48 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 49 | <> return 'EOF' 50 | . return 'INVALID' 51 | 52 | /lex 53 | 54 | /* operator associations and precedence */ 55 | 56 | %left '=>' '<=>' 57 | %left '|' 58 | %left '&' 59 | %left '<' '=<' '>' '>=' '=' '==' '\\=' 'is' 60 | %left '+' '-' 61 | %left '*' '/' 62 | %left UMINUS 63 | 64 | %start expressions 65 | 66 | %% /* language grammar */ 67 | 68 | expressions: top_level_statements_ EOF {return ["top_level_statements",$1]}; 69 | 70 | top_level_statements_: top_level_statement "." top_level_statements_ {$$ = [$1].concat($3);} | top_level_statement "." {$$ = 71 | [$1];}; 72 | 73 | top_level_statements: top_level_statements_ {$$ = ["top_level_statements",$1]}; 74 | 75 | top_level_statement 76 | : forall_statement | function_call; 77 | e 78 | : 79 | e '<=>' e 80 | {$$ = ['iff',$1,$3];} 81 | |e '=>' e 82 | {$$ = ["implies",$1,$3]} 83 | |e '|' e 84 | {$$ = ['logic_or',$1,$3];} 85 | |e '&' e 86 | {$$ = ['logic_and',$1,$3];} 87 | |e '=' e 88 | {$$ = ['logic_equals',$1,$3];} 89 | |e '\\=' e 90 | {$$ = ['!=',$1,$3];} 91 | |e '=<' e 92 | {$$ = ['<=',$1,$3];} 93 | |e '<' e 94 | {$$ = [$2,$1,$3];} 95 | | e '>=' e 96 | {$$ = ['>=',$1,$3];} 97 | |e '>' e 98 | {$$ = [$2,$1,$3];} 99 | | e '+' e 100 | {$$ = [$2,$1,$3];} 101 | | e '-' e 102 | {$$ = [$2,$1,$3];} 103 | | e '*' e 104 | {$$ = [$2,$1,$3];} 105 | | e '/' e 106 | {$$ = [$2,$1,$3];} 107 | | '-' e %prec UMINUS 108 | {$$ = ["-",$2];} 109 | | not_expr 110 | ; 111 | 112 | not_expr: "~" parentheses_expr {$$ = ["!",$2];} | parentheses_expr {$$ = $1;}; 113 | 114 | parameter: IDENTIFIER {$$ = ["Object", $1];}; 115 | parameters: parameter "," parameters {$$ = [$1].concat($3);} | parameter {$$ = 116 | [$1];} | {$$ = []}; 117 | 118 | function_call: 119 | IDENTIFIER "(" ")" {$$ = ["function_call",$1,[]];} | IDENTIFIER "(" exprs ")" {$$ = ["function_call",$1,$3];}; 120 | 121 | forall_statement: "(" "!" "[" e "]" ":" e ")" {$$ = ["forall",$4,$7];}; 122 | 123 | parentheses_expr: 124 | forall_statement 125 | | function_call 126 | | '(' e ')' {$$ = $2;} 127 | | "[" "]" {$$ = ["initializer_list","Object",[]];} 128 | | "[" exprs "]" {$$ = ["initializer_list","Object",$2];} 129 | | "[" dot_expr "|" exprs "]" {$$ = ["list_head_tail","Object",$2,["initializer_list","Object",$4]];} 130 | | NUMBER 131 | {$$ = yytext;} 132 | | IDENTIFIER 133 | {$$ = yytext;} 134 | | STRING_LITERAL 135 | {$$ = yytext;}; 136 | 137 | exprs: exprs "," parentheses_expr {$$ = $1.concat([$3]);} | parentheses_expr {$$ = [$1];}; 138 | -------------------------------------------------------------------------------- /prolog/optimized_java_parser/statement_with_semicolon.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | statement_with_semicolon(Data,Type,println(Expr,Type)) --> 4 | println_(Data,[ 5 | expr(Data,Type,Expr), 6 | Type 7 | ]). 8 | 9 | statement_with_semicolon(Data,Return_type,return(To_return)) --> 10 | return_(Data,[ 11 | expr(Data,Return_type,To_return) 12 | ]). 13 | 14 | statement_with_semicolon(Data,_,plus_plus(Name)) --> 15 | plus_plus_(Data,[ 16 | var_name_(Data,int,Name) 17 | ]),!. 18 | 19 | statement_with_semicolon(Data,_,minus_minus(Name)) --> 20 | minus_minus_(Data,[var_name_(Data,int,Name)]),!. 21 | 22 | statement_with_semicolon(Data,_,initialize_constant(Type,Name,Expr)) --> 23 | initialize_constant_(Data,[ 24 | var_name_(Data,Type,Name), 25 | type(Data,Type), 26 | expr(Data,Type,Expr) 27 | ]). 28 | 29 | 30 | statement_with_semicolon(Data,_,set_array_size(Name,Size,Type)) --> 31 | set_array_size_(Data,[ 32 | var_name_(Data,Name,[array,Type]), 33 | expr(Data,int,Size), 34 | type(Data,Type) 35 | ]). 36 | 37 | statement_with_semicolon(Data,_,set_dict(Name,Index,Expr,Type)) --> 38 | set_dict_(Data,[ 39 | var_name_(Data,[dict,Type],Name), 40 | parentheses_expr(Data,string,Index), 41 | expr(Data,Type,Expr) 42 | ]). 43 | statement_with_semicolon(Data,_,set_array_index(Name,Index,Expr,Type)) --> 44 | set_array_index_(Data,[ 45 | var_name_(Data,[array,Type],Name), 46 | parentheses_expr(Data,int,Index), 47 | parentheses_expr(Data,Type,Expr) 48 | ]). 49 | 50 | 51 | statement_with_semicolon(Data,_,set_var(Name,Expr,Type)) --> 52 | set_var_(Data,[ 53 | var_name_(Data,Type,Name), 54 | expr(Data,Type,Expr) 55 | ]). 56 | 57 | statement_with_semicolon(Data,_,set_instance_var(Name,Expr,Type)) --> 58 | set_var_(Data,[ 59 | expr(Data,Type,this(Name)), 60 | expr(Data,Type,Expr) 61 | ]). 62 | 63 | statement_with_semicolon(Data,_,initialize_empty_var(Type,Name)) --> 64 | initialize_empty_var_(Data,[ 65 | var_name_(Data,Type,Name), 66 | type(Data,Type) 67 | ]). 68 | 69 | statement_with_semicolon(Data,_,throw(Expr)) --> 70 | throw_(Data,expr(Data,string,Expr)). 71 | 72 | statement_with_semicolon(Data,_,initialize_var(Name,Expr,Type)) --> 73 | initialize_var_(Data,[ 74 | var_name_(Data,Type,Name), 75 | expr(Data,Type,Expr), 76 | type(Data,Type) 77 | ]). 78 | 79 | statement_with_semicolon(Data,_,append_to_array(Name,Expr,Type)) --> 80 | append_to_array_(Data,[ 81 | var_name_(Data,[array,Type],Name), 82 | expr(Data,Type,Expr) 83 | ]). 84 | 85 | statement_with_semicolon(Data,_,reverse_list_in_place(List,Type)) --> 86 | reverse_list_in_place_(Data,[ 87 | parentheses_expr(Data,[array,Type],List) 88 | ]). 89 | 90 | 91 | statement_with_semicolon(Data,_,plus_equals(Name,Expr)) --> 92 | plus_equals_(Data,[ 93 | var_name_(Data,int,Name), 94 | expr(Data,int,Expr) 95 | ]). 96 | 97 | statement_with_semicolon(Data,_,divide_equals(Name,Expr)) --> 98 | divide_equals_(Data,[ 99 | var_name_(Data,int,Name), 100 | expr(Data,int,Expr) 101 | ]). 102 | 103 | 104 | statement_with_semicolon(Data,_,modulo_equals(Name,Expr)) --> 105 | modulo_equals_(Data,[ 106 | var_name_(Data,int,Name), 107 | expr(Data,int,Expr) 108 | ]). 109 | 110 | statement_with_semicolon(Data,_,array_plus_equals(Name,Expr,Type)) --> 111 | array_plus_equals_(Data,[ 112 | var_name_(Data,[array,Type],Name), 113 | expr(Data,[array,Type],Expr) 114 | ]). 115 | 116 | statement_with_semicolon(Data,_,string_plus_equals(Name,Expr)) --> 117 | string_plus_equals_(Data,[ 118 | var_name_(Data,string,Name), 119 | expr(Data,string,Expr) 120 | ]). 121 | 122 | statement_with_semicolon(Data,_,minus_equals(Name,Expr)) --> 123 | minus_equals_(Data,[ 124 | var_name_(Data,int,Name), 125 | expr(Data,int,Expr) 126 | ]). 127 | statement_with_semicolon(Data,_,append_to_string(Name,Expr)) --> 128 | append_to_string_(Data,[ 129 | var_name_(Data,string,Name), 130 | expr(Data,string,Expr) 131 | ]). 132 | 133 | 134 | statement_with_semicolon(Data,_,times_equals(Name,Expr)) --> 135 | times_equals_(Data,[ 136 | var_name_(Data,int,Name), 137 | expr(Data,int,Expr) 138 | ]). 139 | 140 | statement_with_semicolon(Data,_,assert(Expr)) --> 141 | assert_(Data,[expr(Data,bool,Expr)]). 142 | 143 | statement_with_semicolon(Data,Type, function_call(Name,Params1,Params2)) --> 144 | function_call_(Data,[ 145 | function_name(Data,Type,Name,Params2), 146 | function_call_parameters(Data,Params1,Params2) 147 | ]). 148 | -------------------------------------------------------------------------------- /prolog/optimized_javascript_parser/statement_with_semicolon.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | statement_with_semicolon(Data,Return_type,return(To_return)) --> 4 | return_(Data,[ 5 | expr(Data,Return_type,To_return) 6 | ]). 7 | 8 | statement_with_semicolon(Data,_,plus_plus(Name)) --> 9 | plus_plus_(Data,[ 10 | var_name_(Data,int,Name) 11 | ]),!. 12 | 13 | statement_with_semicolon(Data,_,minus_minus(Name)) --> 14 | minus_minus_(Data,[var_name_(Data,int,Name)]),!. 15 | 16 | statement_with_semicolon(Data,_,initialize_constant(Type,Name,Expr)) --> 17 | initialize_constant_(Data,[ 18 | var_name_(Data,Type,Name), 19 | type(Data,Type), 20 | expr(Data,Type,Expr) 21 | ]). 22 | 23 | 24 | statement_with_semicolon(Data,_,set_array_size(Name,Size,Type)) --> 25 | set_array_size_(Data,[ 26 | var_name_(Data,Name,[array,Type]), 27 | expr(Data,int,Size), 28 | type(Data,Type) 29 | ]). 30 | 31 | statement_with_semicolon(Data,_,set_dict(Name,Index,Expr,Type)) --> 32 | set_dict_(Data,[ 33 | var_name_(Data,[dict,Type],Name), 34 | parentheses_expr(Data,string,Index), 35 | expr(Data,Type,Expr) 36 | ]). 37 | statement_with_semicolon(Data,_,set_array_index(Name,Index,Expr,Type)) --> 38 | set_array_index_(Data,[ 39 | var_name_(Data,[array,Type],Name), 40 | parentheses_expr(Data,int,Index), 41 | parentheses_expr(Data,Type,Expr) 42 | ]). 43 | 44 | 45 | statement_with_semicolon(Data,_,set_var(Name,Expr,Type)) --> 46 | set_var_(Data,[ 47 | var_name_(Data,Type,Name), 48 | expr(Data,Type,Expr) 49 | ]). 50 | 51 | statement_with_semicolon(Data,_,set_instance_var(Name,Expr,Type)) --> 52 | set_var_(Data,[ 53 | expr(Data,Type,this(Name)), 54 | expr(Data,Type,Expr) 55 | ]). 56 | 57 | statement_with_semicolon(Data,_,initialize_empty_var(Type,Name)) --> 58 | initialize_empty_var_(Data,[ 59 | var_name_(Data,Type,Name), 60 | type(Data,Type) 61 | ]). 62 | 63 | statement_with_semicolon(Data,_,throw(Expr)) --> 64 | throw_(Data,expr(Data,string,Expr)). 65 | 66 | statement_with_semicolon(Data,_,initialize_var(Name,Expr,Type)) --> 67 | initialize_var_(Data,[ 68 | var_name_(Data,Type,Name), 69 | expr(Data,Type,Expr), 70 | type(Data,Type) 71 | ]). 72 | 73 | statement_with_semicolon(Data,_,append_to_array(Name,Expr,Type)) --> 74 | append_to_array_(Data,[ 75 | var_name_(Data,[array,Type],Name), 76 | expr(Data,Type,Expr) 77 | ]). 78 | 79 | statement_with_semicolon(Data,_,reverse_list_in_place(List,Type)) --> 80 | reverse_list_in_place_(Data,[ 81 | parentheses_expr(Data,[array,Type],List) 82 | ]). 83 | 84 | 85 | statement_with_semicolon(Data,_,plus_equals(Name,Expr)) --> 86 | plus_equals_(Data,[ 87 | var_name_(Data,int,Name), 88 | expr(Data,int,Expr) 89 | ]). 90 | 91 | statement_with_semicolon(Data,_,divide_equals(Name,Expr)) --> 92 | divide_equals_(Data,[ 93 | var_name_(Data,int,Name), 94 | expr(Data,int,Expr) 95 | ]). 96 | 97 | 98 | statement_with_semicolon(Data,_,modulo_equals(Name,Expr)) --> 99 | modulo_equals_(Data,[ 100 | var_name_(Data,int,Name), 101 | expr(Data,int,Expr) 102 | ]). 103 | 104 | statement_with_semicolon(Data,_,array_plus_equals(Name,Expr,Type)) --> 105 | array_plus_equals_(Data,[ 106 | var_name_(Data,[array,Type],Name), 107 | expr(Data,[array,Type],Expr) 108 | ]). 109 | 110 | statement_with_semicolon(Data,_,string_plus_equals(Name,Expr)) --> 111 | string_plus_equals_(Data,[ 112 | var_name_(Data,string,Name), 113 | expr(Data,string,Expr) 114 | ]). 115 | 116 | statement_with_semicolon(Data,_,minus_equals(Name,Expr)) --> 117 | minus_equals_(Data,[ 118 | var_name_(Data,int,Name), 119 | expr(Data,int,Expr) 120 | ]). 121 | statement_with_semicolon(Data,_,append_to_string(Name,Expr)) --> 122 | append_to_string_(Data,[ 123 | var_name_(Data,string,Name), 124 | expr(Data,string,Expr) 125 | ]). 126 | 127 | 128 | statement_with_semicolon(Data,_,times_equals(Name,Expr)) --> 129 | times_equals_(Data,[ 130 | var_name_(Data,int,Name), 131 | expr(Data,int,Expr) 132 | ]). 133 | 134 | statement_with_semicolon(Data,_,assert(Expr)) --> 135 | assert_(Data,[expr(Data,bool,Expr)]). 136 | 137 | 138 | statement_with_semicolon(Data,Type,println(Expr,Type)) --> 139 | println_(Data,[ 140 | expr(Data,Type,Expr), 141 | Type 142 | ]). 143 | 144 | statement_with_semicolon(Data,Type, function_call(Name,Params1,Params2)) --> 145 | function_call_(Data,[ 146 | function_name(Data,Type,Name,Params2), 147 | function_call_parameters(Data,Params1,Params2) 148 | ]). 149 | -------------------------------------------------------------------------------- /prolog/optimized_python_parser/statement_with_semicolon.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | statement_with_semicolon(Data,Return_type,return(To_return)) --> 4 | return_(Data,[ 5 | expr(Data,Return_type,To_return) 6 | ]). 7 | 8 | statement_with_semicolon(Data,_,plus_plus(Name)) --> 9 | plus_plus_(Data,[ 10 | var_name_(Data,int,Name) 11 | ]),!. 12 | 13 | statement_with_semicolon(Data,_,minus_minus(Name)) --> 14 | minus_minus_(Data,[var_name_(Data,int,Name)]),!. 15 | 16 | statement_with_semicolon(Data,_,initialize_constant(Type,Name,Expr)) --> 17 | initialize_constant_(Data,[ 18 | var_name_(Data,Type,Name), 19 | type(Data,Type), 20 | expr(Data,Type,Expr) 21 | ]). 22 | 23 | 24 | statement_with_semicolon(Data,_,set_array_size(Name,Size,Type)) --> 25 | set_array_size_(Data,[ 26 | var_name_(Data,Name,[array,Type]), 27 | expr(Data,int,Size), 28 | type(Data,Type) 29 | ]). 30 | 31 | statement_with_semicolon(Data,_,set_dict(Name,Index,Expr,Type)) --> 32 | set_dict_(Data,[ 33 | var_name_(Data,[dict,Type],Name), 34 | parentheses_expr(Data,string,Index), 35 | expr(Data,Type,Expr) 36 | ]). 37 | statement_with_semicolon(Data,_,set_array_index(Name,Index,Expr,Type)) --> 38 | set_array_index_(Data,[ 39 | var_name_(Data,[array,Type],Name), 40 | parentheses_expr(Data,int,Index), 41 | parentheses_expr(Data,Type,Expr) 42 | ]). 43 | 44 | 45 | statement_with_semicolon(Data,_,set_var(Name,Expr,Type)) --> 46 | set_var_(Data,[ 47 | var_name_(Data,Type,Name), 48 | expr(Data,Type,Expr) 49 | ]). 50 | 51 | statement_with_semicolon(Data,_,set_instance_var(Name,Expr,Type)) --> 52 | set_var_(Data,[ 53 | expr(Data,Type,this(Name)), 54 | expr(Data,Type,Expr) 55 | ]). 56 | 57 | statement_with_semicolon(Data,_,initialize_empty_var(Type,Name)) --> 58 | initialize_empty_var_(Data,[ 59 | var_name_(Data,Type,Name), 60 | type(Data,Type) 61 | ]). 62 | 63 | statement_with_semicolon(Data,_,throw(Expr)) --> 64 | throw_(Data,expr(Data,string,Expr)). 65 | 66 | statement_with_semicolon(Data,_,initialize_var(Name,Expr,Type)) --> 67 | initialize_var_(Data,[ 68 | var_name_(Data,Type,Name), 69 | expr(Data,Type,Expr), 70 | type(Data,Type) 71 | ]). 72 | 73 | statement_with_semicolon(Data,_,append_to_array(Name,Expr,Type)) --> 74 | append_to_array_(Data,[ 75 | var_name_(Data,[array,Type],Name), 76 | expr(Data,Type,Expr) 77 | ]). 78 | 79 | statement_with_semicolon(Data,_,reverse_list_in_place(List,Type)) --> 80 | reverse_list_in_place_(Data,[ 81 | parentheses_expr(Data,[array,Type],List) 82 | ]). 83 | 84 | 85 | statement_with_semicolon(Data,_,plus_equals(Name,Expr)) --> 86 | plus_equals_(Data,[ 87 | var_name_(Data,int,Name), 88 | expr(Data,int,Expr) 89 | ]). 90 | 91 | statement_with_semicolon(Data,_,divide_equals(Name,Expr)) --> 92 | divide_equals_(Data,[ 93 | var_name_(Data,int,Name), 94 | expr(Data,int,Expr) 95 | ]). 96 | 97 | 98 | statement_with_semicolon(Data,_,modulo_equals(Name,Expr)) --> 99 | modulo_equals_(Data,[ 100 | var_name_(Data,int,Name), 101 | expr(Data,int,Expr) 102 | ]). 103 | 104 | statement_with_semicolon(Data,_,array_plus_equals(Name,Expr,Type)) --> 105 | array_plus_equals_(Data,[ 106 | var_name_(Data,[array,Type],Name), 107 | expr(Data,[array,Type],Expr) 108 | ]). 109 | 110 | statement_with_semicolon(Data,_,string_plus_equals(Name,Expr)) --> 111 | string_plus_equals_(Data,[ 112 | var_name_(Data,string,Name), 113 | expr(Data,string,Expr) 114 | ]). 115 | 116 | statement_with_semicolon(Data,_,minus_equals(Name,Expr)) --> 117 | minus_equals_(Data,[ 118 | var_name_(Data,int,Name), 119 | expr(Data,int,Expr) 120 | ]). 121 | statement_with_semicolon(Data,_,append_to_string(Name,Expr)) --> 122 | append_to_string_(Data,[ 123 | var_name_(Data,string,Name), 124 | expr(Data,string,Expr) 125 | ]). 126 | 127 | 128 | statement_with_semicolon(Data,_,times_equals(Name,Expr)) --> 129 | times_equals_(Data,[ 130 | var_name_(Data,int,Name), 131 | expr(Data,int,Expr) 132 | ]). 133 | 134 | statement_with_semicolon(Data,_,assert(Expr)) --> 135 | assert_(Data,[expr(Data,bool,Expr)]). 136 | 137 | 138 | statement_with_semicolon(Data,Type,println(Expr,Type)) --> 139 | println_(Data,[ 140 | expr(Data,Type,Expr), 141 | Type 142 | ]). 143 | 144 | statement_with_semicolon(Data,Type, function_call(Name,Params1,Params2)) --> 145 | function_call_(Data,[ 146 | function_name(Data,Type,Name,Params2), 147 | function_call_parameters(Data,Params1,Params2) 148 | ]). 149 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/coq_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "Fixpoint" return 'Fixpoint' 9 | "Definition" return 'Definition' 10 | "Lemma" return 'Lemma' 11 | "forall" return 'forall' 12 | "if" return "if" 13 | "is" return "is" 14 | "," return ',' 15 | "\\/" return '\\/' 16 | "/\\" return '/\\' 17 | "==>" return '==>' 18 | "<=>" return '<=>' 19 | "->" return '->' 20 | ":=" return ':=' 21 | ":-" return ':-' 22 | ":" return ':' 23 | "." return '.' 24 | ">=" return '>=' 25 | ">" return '>' 26 | "=<" return '=<' 27 | "<" return '<' 28 | "==" return '==' 29 | "=" return '=' 30 | "*=" return '*=' 31 | "*" return '*' 32 | "/=" return '/=' 33 | "/" return '/' 34 | "-=" return '-=' 35 | "--" return '--' 36 | "-" return '-' 37 | "++" return '++' 38 | "+=" return '+=' 39 | "+" return '+' 40 | "^" return '^' 41 | "{" return '{' 42 | "}" return '}' 43 | "[" return '[' 44 | "]" return ']' 45 | "(" return '(' 46 | ")" return ')' 47 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 48 | <> return 'EOF' 49 | . return 'INVALID' 50 | 51 | /lex 52 | 53 | /* operator associations and precedence */ 54 | 55 | %left '->' 56 | %left '\\/' 57 | %left '/\\' 58 | %left '<' '=<' '>' '>=' '=' '==' 'is' 59 | %left '+' '-' 60 | %left '*' '/' 61 | %left UMINUS 62 | 63 | %start expressions 64 | 65 | %% /* language grammar */ 66 | 67 | expressions: top_level_statements_ EOF {return ["top_level_statements",$1]}; 68 | 69 | top_level_statements_: top_level_statement "." top_level_statements_ {$$ = [$1].concat($3);} | top_level_statement "." {$$ = 70 | [$1];}; 71 | 72 | top_level_statements: top_level_statements_ {$$ = ["top_level_statements",$1]}; 73 | 74 | top_level_statement 75 | : predicate 76 | | "Lemma" IDENTIFIER ":" e {$$ = ["lemma",$2,$4]} 77 | | "Class" IDENTIFIER ID; 78 | 79 | statement: 80 | statement_with_semicolon {$$ = ["semicolon",$1];}; 81 | 82 | statement_with_semicolon: 83 | e {$$=["return", $1];}; 84 | 85 | statements: statement {$$ = ["statements",[$1]];}; 86 | 87 | predicate: 88 | "Fixpoint" IDENTIFIER parameters ":" IDENTIFIER ":=" statements {$$ = ["function","public",$5,$2,$3,$7]} 89 | | "Definition" IDENTIFIER parameters ":" IDENTIFIER ":=" statements {$$ = ["function","public",$5,$2,$3,$7]}; 90 | 91 | 92 | e 93 | : 94 | e '->' e 95 | {$$ = ["implies",$1,$3]} 96 | |e '\\/' e 97 | {$$ = ['||',$1,$3];} 98 | |e '/\\' e 99 | {$$ = ['&&',$1,$3];} 100 | |e '=' e 101 | {$$ = ['logic_equals',$1,$3];} 102 | |e 'is' e 103 | {$$ = ['logic_equals',$1,$3];} 104 | |e '==' e 105 | {$$ = ['logic_equals',$1,$3];} 106 | |e '=<' e 107 | {$$ = ['<=',$1,$3];} 108 | |e '<' e 109 | {$$ = ['>',$1,$3];} 110 | | e '>=' e 111 | {$$ = ['>=',$1,$3];} 112 | |e '>' e 113 | {$$ = [$2,$1,$3];} 114 | | e '+' e 115 | {$$ = [$2,$1,$3];} 116 | | e '-' e 117 | {$$ = [$2,$1,$3];} 118 | | e '*' e 119 | {$$ = [$2,$1,$3];} 120 | | e '/' e 121 | {$$ = [$2,$1,$3];} 122 | | '-' e %prec UMINUS 123 | {$$ = ["-",$2];} 124 | | "(" "forall" IDENTIFIER ":" IDENTIFIER "," e ")" {$$ = ["forall",["instanceof",$5,$3],$7];} 125 | | "(" "forall" "(" IDENTIFIER ":" IDENTIFIER ")" "," e ")" {$$ = ["forall",["instanceof",$4,$6],$9];} 126 | | parentheses_expr 127 | ; 128 | 129 | parameter: "(" IDENTIFIER ":" IDENTIFIER ")" {$$ = [$4, $2];}; 130 | parameters: parameter parameters {$$ = [$1].concat($2);} | parameter {$$ = 131 | [$1];}; 132 | 133 | function_call: 134 | IDENTIFIER "(" ")" {$$ = ["function_call",$1,[]];} | IDENTIFIER "(" exprs ")" {$$ = ["function_call",$1,$3];}; 135 | 136 | parentheses_expr: 137 | function_call 138 | | '(' e ')' {$$ = $2;} 139 | | NUMBER 140 | {$$ = yytext;} 141 | | IDENTIFIER 142 | {$$ = yytext;} 143 | | STRING_LITERAL 144 | {$$ = yytext;}; 145 | 146 | exprs: exprs "," parentheses_expr {$$ = $1.concat([$3]);} | parentheses_expr {$$ = [$1];}; 147 | -------------------------------------------------------------------------------- /prolog/statement.pl: -------------------------------------------------------------------------------- 1 | optional_indent(Data,Indent,Data1) --> 2 | { 3 | indent_data(Indent,Data,Data1) 4 | }, 5 | optional_indent(Data,Indent),!. 6 | 7 | statement(Data,enum(Name,Body)) --> 8 | namespace(Data,Data1,Name,Indent), 9 | enum_(Data,[ 10 | symbol(Name), 11 | enum_list(Data1,Body), 12 | Indent 13 | ]),!. 14 | 15 | statement(Data,Type1,function(Name,Type,Params1,Body)) --> 16 | %put this at the beginning of each statement without a semicolon 17 | namespace(Data,Data1,Name1,Indent), 18 | function_(Data,[ 19 | function_name(Data,Type,Name,Params1), 20 | type(Data,Type), 21 | parameters(Data1,Params1), 22 | statements(Data1,Type,Body), 23 | Indent 24 | ]),!. 25 | 26 | %java-like class statements 27 | statement(Data,Name,class(Name,Body)) --> 28 | optional_indent(Data,Indent,Data1), 29 | class_(Data,[ 30 | symbol(Name), 31 | class_statements(Data1,Name,Body), 32 | Indent 33 | ]),!. 34 | 35 | statement(Data,C1,class_extends(C2,B)) --> 36 | namespace(Data,Data1,C1,Indent), 37 | class_extends_(Data,[ 38 | symbol(C1), 39 | symbol(C2), 40 | class_statements(Data1,C1,B), 41 | Indent 42 | ]),!. 43 | 44 | statement(Data,Return_type,semicolon(A)) --> 45 | {Data = [_,_,_,Indent],offside_rule_langs(Offside_rule_langs)}, 46 | optional_indent(Data,Indent,_), 47 | semicolon_(Data,[ 48 | statement_with_semicolon(Data,Return_type,A) 49 | ]),!. 50 | 51 | statement(Data,Return_type,for(Statement1,Expr,Statement2,Body)) --> 52 | optional_indent(Data,Indent,Data1), 53 | for_(Data,[ 54 | statement_with_semicolon(Data,Return_type,Statement1), 55 | expr(Data,bool,Expr), 56 | statement_with_semicolon(Data,Return_type,Statement2), 57 | statements(Data1,Return_type,Body), 58 | Indent 59 | ]),!. 60 | 61 | statement(Data,Return_type,foreach_with_index(Array,Var,Index,Body,Type)) --> 62 | optional_indent(Data,Indent,Data1), 63 | foreach_with_index_(Data,[ 64 | expr(Data,[array,Type],Array), 65 | var_name_(Data,Type,Var), 66 | expr(Data,int,Index), 67 | type(Data,Type), 68 | statements(Data1,Return_type,Body), 69 | Indent 70 | ]),!. 71 | 72 | statement(Data,Return_type,foreach(Array,Var,Body,Type)) --> 73 | optional_indent(Data,Indent,Data1), 74 | foreach_(Data,[ 75 | expr(Data,[array,Type],Array), 76 | var_name_(Data,Type,Var), 77 | type(Data,Type), 78 | statements(Data1,Return_type,Body), 79 | Indent 80 | ]),!. 81 | 82 | statement(Data,Return_type,try_catch(Body1,Name,Body2)) --> 83 | optional_indent(Data,Indent,Data1), 84 | try_catch_(Data,[ 85 | statements(Data1,Return_type,Body1), 86 | var_name_(Data1,int,Name), 87 | statements(Data1,Return_type,Body2), 88 | Indent 89 | ]),!. 90 | 91 | statement(Data,Return_type,while(Expr,Body)) --> 92 | optional_indent(Data,Indent,Data1), 93 | while_(Data,[ 94 | expr(Data,bool,Expr), 95 | statements(Data1,Return_type,Body), 96 | Indent 97 | ]),!. 98 | 99 | statement(Data,Return_type,do_while(Expr,Body)) --> 100 | optional_indent(Data,Indent,Data1), 101 | do_while_(Data,[ 102 | expr(Data,bool,Expr), 103 | statements(Data1,Return_type,Body), 104 | Indent 105 | ]),!. 106 | 107 | 108 | statement(Data,Return_type,if(Expr_,Statements_,Elif_or_else_,Else_)) --> 109 | optional_indent(Data,Indent,Data1), 110 | if(Data,[ 111 | expr(Data,bool,Expr_), 112 | statements(Data1,Return_type,Statements_), 113 | elif_statements(Data,Return_type,Elif_or_else_), 114 | else(Data,Return_type,Else_), 115 | Indent 116 | ]),!. 117 | 118 | statement(Data,Return_type,if_without_else(Expr_,Statements_,Elif_or_else_,Else_)) --> 119 | optional_indent(Data,Indent,Data1), 120 | if_without_else_(Data,[ 121 | expr(Data,bool,Expr_), 122 | statements(Data1,Return_type,Statements_), 123 | Indent 124 | ]),!. 125 | 126 | statement(Data,Return_type,unless(Expr_,Statements_,Elif_or_else_,Else_)) --> 127 | optional_indent(Data,Indent,Data1), 128 | unless_(Data,[ 129 | expr(Data,bool,Expr_), 130 | statements(Data1,Return_type,Statements_), 131 | Indent 132 | ]),!. 133 | 134 | statement(Data,Return_type, switch(Expr_,Expr1_,Statements_,Case_or_default_)) --> 135 | optional_indent(Data,Indent,Data1), 136 | switch_(Data,[ 137 | parentheses_expr(Data,int,Expr_), 138 | first_case(Data1,Return_type,Expr_,int,[Expr1_,Statements_,Case_or_default_]), 139 | Indent 140 | ]),!. 141 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/tex_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* skip whitespace */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "if" return "if" 9 | "else" return "else" 10 | "return" return "return" 11 | "void" return "void" 12 | "case" return "case" 13 | "printf" return "printf" 14 | "while" return "while" 15 | "const" return "const" 16 | "struct" return "struct" 17 | "switch" return "switch" 18 | "for" return "for" 19 | "," return ',' 20 | "⊃" return '⊃' 21 | "⊂" return '⊂' 22 | "\\forall" return '\\forall' 23 | ";" return ';' 24 | "." return '.' 25 | ":" return ':' 26 | "\\lnot" return '\\lnot' 27 | "\\land" return '\\land' 28 | "\\lor" return '\\lor' 29 | "\\neq" return '\\neq' 30 | "\\neg" return '\\neg' 31 | "\\geq" return '\\geq' 32 | ">>" return '>>' 33 | ">" return '>' 34 | "\\leq" return '\\leq' 35 | "<" return '<' 36 | "=" return '=' 37 | "=" return '=' 38 | "*=" return '*=' 39 | "*" return '*' 40 | "%" return '%' 41 | "/=" return '/=' 42 | "/" return '/' 43 | "-=" return '-=' 44 | "--" return '--' 45 | "-" return '-' 46 | "++" return '++' 47 | "+=" return '+=' 48 | "+" return '+' 49 | "^" return '^' 50 | "?" return '?' 51 | "{" return '{' 52 | "}" return '}' 53 | "[" return '[' 54 | "]" return ']' 55 | "(" return '(' 56 | ")" return ')' 57 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 58 | <> return 'EOF' 59 | . return 'INVALID' 60 | 61 | /lex 62 | 63 | /* operator associations and precedence */ 64 | 65 | %left '\\lor' 66 | %left '\\land' 67 | %left '<' '\\leq' '>' '\\geq' '=' '\\neq' '⊃' '⊂' 68 | %left '+' '-' 69 | %left '*' '/' '%' 70 | %left '^' 71 | %left UMINUS 72 | 73 | %start expressions 74 | 75 | %% /* language grammar */ 76 | 77 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 78 | 79 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 80 | [$1];}; 81 | 82 | statements: statements_ {$$ = ["statements",$1]}; 83 | 84 | statement 85 | : 86 | IDENTIFIER "(" parameters ")" "=" "{" e "}" {$$ = ["function","public","double",$1,$3,["statements",[["semicolon",["return",$7]]]]];} 87 | | IDENTIFIER "(" parameters ")" "=" e {$$ = ["function","public","double",$1,$3,["statements",[["semicolon",["return",$6]]]]];}; 88 | 89 | e 90 | : 91 | e '\\lor' e 92 | {$$ = ["||",$1,$3];} 93 | |e '\\land' e 94 | {$$ = ["&&",$1,$3];} 95 | |e '⊃' e 96 | {$$ = ['⊃',$1,$3];} 97 | |e '⊂' e 98 | {$$ = ['⊂',$1,$3];} 99 | |e '\\leq' e 100 | {$$ = ["<=",$1,$3];} 101 | |e '<' e 102 | {$$ = [$2,$1,$3];} 103 | | e '\\geq' e 104 | {$$ = [">=",$1,$3];} 105 | |e '>' e 106 | {$$ = [$2,$1,$3];} 107 | | e '=' e 108 | {$$ = [$2,$1,$3];} 109 | | e '\\neq' e 110 | {$$ = ["!=",$1,$3];} 111 | | arithmetic_expr; 112 | 113 | arithmetic_expr: 114 | e '+' e 115 | {$$ = [$2,$1,$3];} 116 | | e '-' e 117 | {$$ = [$2,$1,$3];} 118 | | e '%' e 119 | {$$ = [$2,$1,$3];} 120 | | e '*' e 121 | {$$ = [$2,$1,$3];} 122 | | e '/' e 123 | {$$ = [$2,$1,$3];} 124 | | e '^' e 125 | {$$ = ["function_call","**",[$1,$3]];} 126 | | '-' e %prec UMINUS 127 | {$$ = ["-",$2];} 128 | | not_expr 129 | ; 130 | 131 | 132 | not_expr: '\\forall' IDENTIFIER parentheses_expr 133 | {$$ = ['forall',$2,$3];} | "\\lnot" parentheses_expr {$$ = ["!", [".",$2]];} | "\\lneg" parentheses_expr {$$ = ["!", [".",$2]];} | parentheses_expr; 134 | 135 | 136 | parentheses_expr: 137 | =IDENTIFIER "(" ")" {$$ = ["function_call",$1,[]];} 138 | | IDENTIFIER "(" exprs ")" {$$ = ["function_call",$1,$3];} 139 | | '(' e ')' {$$ = ["parentheses",$2];} 140 | | parentheses_expr_; 141 | 142 | parentheses_expr_: 143 | NUMBER 144 | {$$ = yytext;} 145 | | IDENTIFIER 146 | {$$ = yytext;} 147 | | STRING_LITERAL 148 | {$$ = yytext;}; 149 | 150 | 151 | parameter: IDENTIFIER {$$ = ["double",$1];}; 152 | parameters: parameter "," parameters {$$ = [$1].concat($3);} | parameter {$$ = 153 | [$1];} | "void" {$$ = [];} | {$$ = [];}; 154 | exprs: e "," exprs {$$ = [$1].concat($3);} | e {$$ = [$1];}; 155 | -------------------------------------------------------------------------------- /prolog/statement_with_semicolon.pl: -------------------------------------------------------------------------------- 1 | %The grammar files are saved in grammars.pl 2 | 3 | statement_with_semicolon(Data,Return_type,return(To_return)) --> 4 | return_(Data,[ 5 | expr(Data,Return_type,To_return) 6 | ]). 7 | 8 | statement_with_semicolon(Data,_,plus_plus(Name)) --> 9 | plus_plus_(Data,[ 10 | var_name_(Data,int,Name) 11 | ]),!. 12 | 13 | statement_with_semicolon(Data,_,minus_minus(Name)) --> 14 | minus_minus_(Data,[var_name_(Data,int,Name)]),!. 15 | 16 | statement_with_semicolon(Data,_,initialize_constant(Type,Name,Expr)) --> 17 | initialize_constant_(Data,[ 18 | var_name_(Data,Type,Name), 19 | type(Data,Type), 20 | expr(Data,Type,Expr) 21 | ]). 22 | 23 | 24 | statement_with_semicolon(Data,_,set_array_size(Name,Size,Type)) --> 25 | set_array_size_(Data,[ 26 | var_name_(Data,Name,[array,Type]), 27 | expr(Data,int,Size), 28 | type(Data,Type) 29 | ]). 30 | 31 | statement_with_semicolon(Data,_,set_dict(Name,Index,Expr,Type)) --> 32 | set_dict_(Data,[ 33 | var_name_(Data,[dict,Type],Name), 34 | parentheses_expr(Data,string,Index), 35 | expr(Data,Type,Expr) 36 | ]). 37 | statement_with_semicolon(Data,_,set_array_index(Name,Index,Expr,Type)) --> 38 | set_array_index_(Data,[ 39 | var_name_(Data,[array,Type],Name), 40 | parentheses_expr(Data,int,Index), 41 | parentheses_expr(Data,Type,Expr) 42 | ]). 43 | 44 | 45 | statement_with_semicolon(Data,_,set_var(Name,Expr,Type)) --> 46 | set_var_(Data,[ 47 | var_name_(Data,Type,Name), 48 | expr(Data,Type,Expr) 49 | ]). 50 | 51 | statement_with_semicolon(Data,_,set_instance_var(Name,Expr,Type)) --> 52 | set_var_(Data,[ 53 | expr(Data,Type,this(Name)), 54 | expr(Data,Type,Expr) 55 | ]). 56 | 57 | statement_with_semicolon(Data,_,initialize_empty_var(Type,Name)) --> 58 | initialize_empty_var_(Data,[ 59 | var_name_(Data,Type,Name), 60 | type(Data,Type) 61 | ]). 62 | 63 | statement_with_semicolon(Data,_,throw(Expr)) --> 64 | throw_(Data,expr(Data,string,Expr)). 65 | 66 | statement_with_semicolon(Data,_,initialize_var(Name,Expr,Type)) --> 67 | initialize_var_(Data,[ 68 | var_name_(Data,Type,Name), 69 | expr(Data,Type,Expr), 70 | type(Data,Type) 71 | ]). 72 | 73 | statement_with_semicolon(Data,_,append_to_array(Name,Expr,Type)) --> 74 | append_to_array_(Data,[ 75 | var_name_(Data,[array,Type],Name), 76 | expr(Data,Type,Expr) 77 | ]). 78 | 79 | statement_with_semicolon(Data,_,reverse_list_in_place(List,Type)) --> 80 | reverse_list_in_place_(Data,[ 81 | parentheses_expr(Data,[array,Type],List) 82 | ]). 83 | 84 | 85 | statement_with_semicolon(Data,_,plus_equals(Name,Expr)) --> 86 | plus_equals_(Data,[ 87 | var_name_(Data,int,Name), 88 | expr(Data,int,Expr) 89 | ]). 90 | 91 | statement_with_semicolon(Data,_,divide_equals(Name,Expr)) --> 92 | divide_equals_(Data,[ 93 | var_name_(Data,int,Name), 94 | expr(Data,int,Expr) 95 | ]). 96 | 97 | statement_with_semicolon(Data,_,exponent_equals(Name,Expr)) --> 98 | exponent_equals_(Data,[ 99 | var_name_(Data,int,Name), 100 | expr(Data,int,Expr) 101 | ]). 102 | 103 | statement_with_semicolon(Data,_,modulo_equals(Name,Expr)) --> 104 | modulo_equals_(Data,[ 105 | var_name_(Data,int,Name), 106 | expr(Data,int,Expr) 107 | ]). 108 | 109 | statement_with_semicolon(Data,_,array_plus_equals(Name,Expr,Type)) --> 110 | array_plus_equals_(Data,[ 111 | var_name_(Data,[array,Type],Name), 112 | expr(Data,[array,Type],Expr) 113 | ]). 114 | 115 | statement_with_semicolon(Data,_,dict_plus_equals(Name,Expr,Type)) --> 116 | dict_plus_equals_(Data,[ 117 | var_name_(Data,[dict,Type],Name), 118 | expr(Data,[dict,Type],Expr) 119 | ]). 120 | 121 | statement_with_semicolon(Data,_,string_plus_equals(Name,Expr)) --> 122 | string_plus_equals_(Data,[ 123 | var_name_(Data,string,Name), 124 | expr(Data,string,Expr) 125 | ]). 126 | 127 | statement_with_semicolon(Data,_,minus_equals(Name,Expr)) --> 128 | minus_equals_(Data,[ 129 | var_name_(Data,int,Name), 130 | expr(Data,int,Expr) 131 | ]). 132 | statement_with_semicolon(Data,_,append_to_string(Name,Expr)) --> 133 | append_to_string_(Data,[ 134 | var_name_(Data,string,Name), 135 | expr(Data,string,Expr) 136 | ]). 137 | 138 | 139 | 140 | statement_with_semicolon(Data,_,shuffle_array(List,Type)) --> 141 | shuffle_array_(Data,[ 142 | parentheses_expr(Data,[array,Type],List) 143 | ]). 144 | 145 | statement_with_semicolon(Data,_,get_user_input_with_prompt(Var,Prompt)) --> 146 | get_user_input_with_prompt_(Data,[ 147 | var_name_(Data,string,Var), 148 | expr(Data,string,Prompt) 149 | ]). 150 | 151 | statement_with_semicolon(Data,_,times_equals(Name,Expr)) --> 152 | times_equals_(Data,[ 153 | var_name_(Data,int,Name), 154 | expr(Data,int,Expr) 155 | ]). 156 | 157 | statement_with_semicolon(Data,_,assert(Expr)) --> 158 | assert_(Data,[expr(Data,bool,Expr)]). 159 | 160 | 161 | statement_with_semicolon(Data,Type,println(Expr,Type)) --> 162 | println_(Data,[ 163 | expr(Data,Type,Expr), 164 | Type 165 | ]). 166 | 167 | statement_with_semicolon(Data,Type, function_call(Name,Params1,Params2)) --> 168 | function_call_(Data,[ 169 | function_name(Data,Type,Name,Params2), 170 | function_call_parameters(Data,Params1,Params2) 171 | ]). 172 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/kif_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | (\s+|\;+.*\n) /* skip whitespace and line comments */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "deffunction" return 'deffunction' 9 | "defrelation" return 'defrelation' 10 | "forall" return 'forall' 11 | "assert" return 'assert' 12 | "default" return 'default' 13 | "implies" return 'implies' 14 | "switch" return 'switch' 15 | "not" return 'not' 16 | "and" return 'and' 17 | "if" return 'if' 18 | "then" return 'then' 19 | "else" return 'else' 20 | "case" return 'case' 21 | "?" return '?' 22 | ">=" return '>=' 23 | ">" return '>' 24 | "=<" return '=<' 25 | "<" return '<' 26 | "=>" return '=>' 27 | "==" return '==' 28 | ":=" return ':=' 29 | "=" return '=' 30 | "*=" return '*=' 31 | "*" return '*' 32 | "/=" return '/=' 33 | "/" return '/' 34 | "-=" return '-=' 35 | "--" return '--' 36 | "-" return '-' 37 | "++" return '++' 38 | "+=" return '+=' 39 | "+" return '+' 40 | "^" return '^' 41 | "{" return '{' 42 | "}" return '}' 43 | "[" return '[' 44 | "]" return ']' 45 | "(" return '(' 46 | ")" return ')' 47 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 48 | <> return 'EOF' 49 | . return 'INVALID' 50 | 51 | /lex 52 | 53 | /* operator associations and precedence */ 54 | 55 | %left '->' 56 | %left ';' 57 | %left ',' 58 | %left '<' '=<' '>' '>=' '=' '==' 'is' 59 | %left '+' '-' 60 | %left '*' '/' 61 | %left UMINUS 62 | 63 | %start expressions 64 | 65 | %% /* language grammar */ 66 | 67 | expressions: top_level_statements_ EOF {return ["top_level_statements",$1]}; 68 | 69 | top_level_statements_: top_level_statement top_level_statements_ {$$ = [$1].concat($2);} | top_level_statement {$$ = 70 | [$1];}; 71 | 72 | top_level_statements: top_level_statements_ {$$ = ["top_level_top_level_statements",$1]}; 73 | 74 | top_level_statement 75 | : "(" "deffunction" IDENTIFIER "(" parameters ")" ":=" statements ")" {$$ = ["function","public","Object",$3,$5,$8]} 76 | | "(" "defrelation" IDENTIFIER "(" parameters ")" ":=" statements ")" {$$ = ["predicate","Object",$3,$5,$8]} 77 | | e; 78 | 79 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 80 | [$1];}; 81 | 82 | statements: 83 | statements_ {$$ = ["statements",$1]} 84 | ; 85 | 86 | statement: 87 | statement_with_semicolon {$$ = ["semicolon",$1]} 88 | | "(" "cond" "(" e bracket_statements ")" elif ")" {$$ = ["if",$4,$5,$7];} 89 | ; 90 | 91 | elif: 92 | "(" e bracket_statements ")" elif {$$ = ["elif",$2,$3,$5]} 93 | | "(" "t" bracket_statements ")" {$$ = ["else",$3];}; 94 | 95 | bracket_statements: statement {$$= ["statements",[$1]];}; 96 | 97 | statement_with_semicolon: 98 | e {$$ = ["return",$1];} 99 | ; 100 | 101 | operator: 102 | | "not" {$$ = "!"} 103 | | "or" {$$ = "logic_or";} 104 | | "and" {$$ = "logic_and";} 105 | | "*" 106 | | "/" 107 | | "+" 108 | | "-" 109 | | comparison_operator; 110 | 111 | comparison_operator: 112 | ">=" 113 | | ">" 114 | | "<"; 115 | 116 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 117 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 118 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 119 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 120 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 121 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 122 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 123 | 124 | e: 125 | '(' '=' e equal_exprs ')' {$$ = [$2,$3,$4];} 126 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 127 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 128 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 129 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 130 | | '(' "=<" e e ')' {$$ = ["<=",$3,$4];} 131 | | '(' comparison_operator e e ')' {$$ = [$2,$3,$4];} 132 | | '(' "implies" e e ')' {$$ = ["implies",$3,$4];} 133 | | '(' "=>" e e ')' {$$ = ["implies",$3,$4];} 134 | | '(' "exists" e ')' {$$ = ["exists",$3];} 135 | | '(' 'or' e or_exprs ')' {$$ = ["logic_or",$3,$4];} 136 | | '(' 'and' e and_exprs ')' {$$ = ["logic_and",$3,$4];} 137 | | "(" "forall" "(" e ")" e ")" {$$ = ["forall",$4,$6];} 138 | | function_call 139 | | NUMBER 140 | {$$ = yytext;} 141 | | var_name 142 | {$$ = yytext;} 143 | | STRING_LITERAL 144 | {$$ = yytext;}; 145 | 146 | parameter: var_name {$$ = ["Object", $1];}; 147 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 148 | [$1];}; 149 | 150 | function_call: 151 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 152 | 153 | var_name: "?" IDENTIFIER {$$ = $2}; 154 | 155 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 156 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/smt_lib_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | \s+ /* IGNORE */ 6 | ";".* /* IGNORE */ 7 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 8 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 9 | "Array" return 'Array' 10 | "implies" return 'implies' 11 | "define-fun-rec" return 'define-fun-rec' 12 | "define-fun" return 'define-fun' 13 | "define-sort" return 'define-sort' 14 | "declare-const" return 'declare-const' 15 | "forall" return 'forall' 16 | "assert" return 'assert' 17 | "not" return 'not' 18 | "ite" return 'ite' 19 | "if" return 'if' 20 | "and" return 'and' 21 | "or" return 'or' 22 | "?" return '?' 23 | ">=" return '>=' 24 | ">" return '>' 25 | "<=" return '<=' 26 | "<" return '<' 27 | "=>" return '=>' 28 | "==" return '==' 29 | "=" return '=' 30 | "*=" return '*=' 31 | "*" return '*' 32 | "/=" return '/=' 33 | "/" return '/' 34 | "-=" return '-=' 35 | "--" return '--' 36 | "-" return '-' 37 | "++" return '++' 38 | "+=" return '+=' 39 | "+" return '+' 40 | "^" return '^' 41 | "{" return '{' 42 | "}" return '}' 43 | "[" return '[' 44 | "]" return ']' 45 | "(" return '(' 46 | ")" return ')' 47 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 48 | <> return 'EOF' 49 | . return 'INVALID' 50 | 51 | /lex 52 | 53 | /* operator associations and precedence */ 54 | 55 | %left '->' 56 | %left ';' 57 | %left ',' 58 | %left '<' '=<' '>' '>=' '=' '==' 'is' 59 | %left '+' '-' 60 | %left '*' '/' 61 | %left UMINUS 62 | 63 | %start expressions 64 | 65 | %% /* language grammar */ 66 | 67 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 68 | 69 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 70 | [$1];}; 71 | 72 | data_type_and: IDENTIFIER data_type_and {$$ = ["data_type_and",$1,$2];} | IDENTIFIER {$$ = 73 | $1;}; 74 | 75 | statements: statements_ {$$ = ["top_level_statements",$1]}; 76 | 77 | statement: 78 | "(" "declare-const" IDENTIFIER type ")" {$$ = ["semicolon",["initialize_empty_vars",$4,[$3]]];} 79 | | "(" "define-fun" IDENTIFIER "(" ")" type e ")" {$$ = ["function","public",$6,$3,[],["semicolon",["return",$7]]]} 80 | | "(" "define-fun" IDENTIFIER "(" parameters ")" type e ")" {$$ = ["function","public",$7,$3,$5,["semicolon",["return",$8]]]} 81 | | "(" "define-fun-rec" IDENTIFIER "(" ")" type e ")" {$$ = ["function","public",$6,$3,[],["semicolon",["return",$7]]]} 82 | | "(" "define-fun-rec" IDENTIFIER "(" parameters ")" type e ")" {$$ = ["function","public",$7,$3,$5,["semicolon",["return",$8]]]} 83 | | "(" "assert" e ")" {$$ = ["semicolon",["function_call","assert",[$3]]]} 84 | | "(" "define-sort" "(" ")" IDENTIFIER "(" data_type_and ")" ")" {$$ = ["algebraic_data_type",$5,$7]}; 85 | 86 | type: 87 | "(" "Array" type type ")" {$$ = ["Array",[$3,$4]];} 88 | | IDENTIFIER; 89 | 90 | 91 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 92 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 93 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 94 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 95 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 96 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 97 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 98 | 99 | logic_operator: ">" | "<" | ">=" | "<="; 100 | 101 | implication: "=>"|"implies"; 102 | 103 | e: 104 | '(' implication e e ')' {$$ = ["implies",$3,$4];} 105 | | '(' logic_operator e e ')' {$$ = [$2,$3,$4];} 106 | | '(' '=' e equal_exprs ')' {$$ = ["logic_equals",$3,$4];} 107 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 108 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 109 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 110 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 111 | | '(' 'or' e or_exprs ')' {$$ = ["logic_or",$3,$4];} 112 | | '(' 'and' e and_exprs ')' {$$ = ["logic_and",$3,$4];} 113 | | '(' 'not' e ')' {$$ = ["!",$3];} 114 | | '(' "forall" '(' forall_parameters ')' e ')' {$$ = ['z3_forall',$4,$6];} 115 | | "(" "if" e e e ")" {$$ = ["ternary_operator",$3,$4,$5];} 116 | | "(" "ite" e e e ")" {$$ = ["ternary_operator",$3,$4,$5];} 117 | | function_call 118 | | NUMBER 119 | {$$ = yytext;} 120 | | var_name 121 | {$$ = yytext;} 122 | | STRING_LITERAL 123 | {$$ = yytext;}; 124 | 125 | forall_parameter: "(" IDENTIFIER type ")" {$$ = ["forall_parameter", $3,$2];}; 126 | forall_parameters: forall_parameters forall_parameter {$$ = $1.concat([$2]);} | forall_parameter {$$ = 127 | [$1];}; 128 | 129 | 130 | parameter: '(' var_name type ')' {$$ = [$3, $2];}; 131 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 132 | [$1];}; 133 | 134 | function_call: 135 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 136 | 137 | var_name: IDENTIFIER; 138 | 139 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 140 | -------------------------------------------------------------------------------- /javascript/js_transpiler/jison_parsers/emacs_lisp_parser.jison: -------------------------------------------------------------------------------- 1 | /* lexical grammar */ 2 | %lex 3 | %% 4 | 5 | (\s+|\;+.*\n) /* skip whitespace and line comments */ 6 | [0-9]+("."[0-9]+)?\b return 'NUMBER' 7 | \"([^\\\"]|\\.)*\" return 'STRING_LITERAL' 8 | "'(" return "'(" 9 | "defmacro" return 'defmacro' 10 | "defun" return 'defun' 11 | "while" return 'while' 12 | "cond" return 'cond' 13 | "loop" return 'loop' 14 | "setf" return 'setf' 15 | "setq" return 'setq' 16 | "if" return 'if' 17 | "do" return 'do' 18 | "t" return 't' 19 | "let" return 'let' 20 | "not" return 'not' 21 | "and" return 'and' 22 | "?" return '?' 23 | ">=" return '>=' 24 | ">" return '>' 25 | "<=" return '<=' 26 | "<" return '<' 27 | "=>" return '=>' 28 | "==" return '==' 29 | "=" return '=' 30 | "*=" return '*=' 31 | "*" return '*' 32 | "/=" return '/=' 33 | "/" return '/' 34 | "-=" return '-=' 35 | "--" return '--' 36 | "-" return '-' 37 | "++" return '++' 38 | "+=" return '+=' 39 | "+" return '+' 40 | "^" return '^' 41 | "{" return '{' 42 | "}" return '}' 43 | "[" return '[' 44 | "]" return ']' 45 | "(" return '(' 46 | ")" return ')' 47 | [a-zA-Z_][a-zA-Z0-9_]* return 'IDENTIFIER' 48 | <> return 'EOF' 49 | . return 'INVALID' 50 | 51 | /lex 52 | 53 | /* operator associations and precedence */ 54 | 55 | %left '->' 56 | %left ';' 57 | %left ',' 58 | %left '<' '=<' '>' '>=' '=' '==' 'is' 59 | %left '+' '-' 60 | %left '*' '/' 61 | %left UMINUS 62 | 63 | %start expressions 64 | 65 | %% /* language grammar */ 66 | 67 | expressions: statements_ EOF {return ["top_level_statements",$1]}; 68 | 69 | statements_: statement statements_ {$$ = [$1].concat($2);} | statement {$$ = 70 | [$1];}; 71 | 72 | statements: statements_ {$$ = ["statements",$1]}; 73 | 74 | statement: 75 | "(" "defun" IDENTIFIER "(" parameters ")" statement ")" {$$ = ["function","public","Object",$3,$5,$7]} 76 | | "(" "defmacro" IDENTIFIER "(" exprs ")" statement ")" {$$ = ["macro",$3,$5,$7];} 77 | | statement_with_semicolon {$$=["semicolon",$1];} 78 | | "(" "cond" "(" e bracket_statements ")" elif ")" {$$ = ["if",$4,$5,$7];} 79 | | "(" "if" e bracket_statements ")" {$$ = ["if",$3,$4];} 80 | | "(" "if" e bracket_statements bracket_statements ")" {$$ = ["if",$3,$4];} 81 | | "(" "let" "(" declare_vars ")" bracket_statements ")" {$$ = ["lexically_scoped_vars",$4,["statements",$6]];} 82 | | "(" "loop" "while" e "do" statements ")" {$$ = ["while",$4,$6];} 83 | | "(" "loop" "do" statements "while" e ")" {$$ = ["do_while",$4,$6];} 84 | ; 85 | 86 | declare_var: "(" IDENTIFIER e ")" {$$ = ["lexically_scoped_var","Object",$2,$3]}; 87 | declare_vars: declare_var declare_vars {$$ = [$1].concat($2);} | declare_var {$$ = 88 | [$1];}; 89 | 90 | 91 | statement_with_semicolon: 92 | e {$$ = ["return",$1]} 93 | | "(" "setf" e e ")" {$$ = ["set_var",$3,$4];} 94 | | "(" "setq" e e ")" {$$ = ["set_var",$3,$4];}; 95 | 96 | 97 | bracket_statements: statement {$$= ["statements",[$1]];}; 98 | 99 | 100 | elif: 101 | "(" e bracket_statements ")" elif {$$ = ["elif",$2,$3,$5]} 102 | | "(" "t" bracket_statements ")" {$$ = ["else",$3];}; 103 | 104 | operator: 105 | | "not" {$$ = "!"} 106 | | "or" {$$ = "logic_or";} 107 | | "and" {$$ = "logic_and";} 108 | | "*" 109 | | "/" 110 | | "+" 111 | | "-" 112 | | comparison_operator; 113 | 114 | comparison_operator: 115 | ">=" 116 | | ">" 117 | | "<=" 118 | | "<"; 119 | 120 | equal_exprs: equal_exprs e {$$ = ["logic_equals",$1,$2]} | e; 121 | times_exprs: times_exprs e {$$ = ["*",$1,$2]} | e; 122 | divide_exprs: divide_exprs e {$$ = ["/",$1,$2]} | e; 123 | plus_exprs: plus_exprs e {$$ = ["+",$1,$2]} | e; 124 | minus_exprs: minus_exprs e {$$ = ["-",$1,$2]} | e; 125 | and_exprs: and_exprs e {$$ = ["logic_and",$1,$2]} | e; 126 | or_exprs: or_exprs e {$$ = ["logic_or",$1,$2]} | e; 127 | 128 | e: 129 | '(' '=' e equal_exprs ')' {$$ = ["==",$3,$4];} 130 | | "(" "lambda" IDENTIFIER "(" parameters ")" statement ")" {$$ = ["function","public","Object",$3,$5,$7]} 131 | | '(' '*' e times_exprs ')' {$$ = [$2,$3,$4];} 132 | | '(' '+' e plus_exprs ')' {$$ = [$2,$3,$4];} 133 | | '(' '-' e minus_exprs ')' {$$ = [$2,$3,$4];} 134 | | '(' '/' e divide_exprs ')' {$$ = [$2,$3,$4];} 135 | | '(' 'or' e or_exprs ')' {$$ = ["||",$3,$4];} 136 | | '(' 'and' e and_exprs ')' {$$ = ["&&",$3,$4];} 137 | | '(' comparison_operator e e ')' {$$ = [$2,$3,$4];} 138 | | function_call 139 | | "'(" exprs ")" {$$ = ["initializer_list","Object",$2]} 140 | | NUMBER 141 | {$$ = yytext;} 142 | | var_name 143 | {$$ = yytext;} 144 | | STRING_LITERAL 145 | {$$ = yytext;}; 146 | 147 | parameter: var_name {$$ = ["Object", $1];}; 148 | parameters: parameters parameter {$$ = $1.concat([$2]);} | parameter {$$ = 149 | [$1];}; 150 | 151 | function_call: 152 | "(" IDENTIFIER ")" {$$ = ["function_call",$2,[]];} | "(" IDENTIFIER exprs ")" {$$ = ["function_call",$2,$3];}; 153 | 154 | var_name: IDENTIFIER; 155 | 156 | exprs: exprs e {$$ = $1.concat([$2]);} | e {$$ = [$1];}; 157 | --------------------------------------------------------------------------------