├── .gitignore ├── .project ├── .travis.yml ├── LICENSE.md ├── README.md ├── pom.xml ├── recaf-desugar ├── .classpath ├── .project ├── META-INF │ ├── MANIFEST.MF │ └── RASCAL.MF ├── build.properties ├── input-paper │ ├── TestDebug.recaf │ ├── TestQL.recaf │ └── TestUsingWithError.recaf ├── input │ ├── BaseTestExprFieldSuper.recaf │ ├── BaseTestExprInvokeSuper.recaf │ ├── PStream.recaf │ ├── TestAsyncComplex.recaf │ ├── TestAsyncComplex2.recaf │ ├── TestAsyncNoAwait.recaf │ ├── TestAsyncWithAwait.recaf │ ├── TestBacktracking.recaf │ ├── TestComeFrom.recaf │ ├── TestCoroutine.recaf │ ├── TestDef.recaf │ ├── TestExprAnd.recaf │ ├── TestExprFieldSuper.recaf │ ├── TestExprInheritanceMethodLookup.recaf │ ├── TestExprInvokeSuper.recaf │ ├── TestExprNoConstructor.recaf │ ├── TestExprPlus.recaf │ ├── TestExprPrivateConstructor.recaf │ ├── TestExprSimpleMethodLookup.recaf │ ├── TestFibIter.recaf │ ├── TestFibIter2.recaf │ ├── TestFibMemo.recaf │ ├── TestFibRecAsync.recaf │ ├── TestFor_noBreak.recaf │ ├── TestFor_ordinary.recaf │ ├── TestFor_withBreak.recaf │ ├── TestGUI.recaf │ ├── TestGUI2.recaf │ ├── TestIter.recaf │ ├── TestIter_YieldEachRec.recaf │ ├── TestLocals.recaf │ ├── TestMaybe.recaf │ ├── TestOrElse.recaf │ ├── TestPEG.recaf │ ├── TestPropagate.recaf │ ├── TestPullStreams.recaf │ ├── TestSWUL.recaf │ ├── TestSecurity.recaf │ ├── TestSimple.recaf │ ├── TestSolve.recaf │ ├── TestSolve_alldifferent.recaf │ ├── TestStream_Complex.recaf │ ├── TestStream_with_await.recaf │ ├── TestStream_with_awaitFor.recaf │ ├── TestStream_with_yield.recaf │ ├── TestStream_with_yieldFrom.recaf │ ├── TestSwitch_break_default_beginning.recaf │ ├── TestSwitch_break_first.recaf │ ├── TestSwitch_break_second.recaf │ ├── TestSwitch_break_second_withdefault.recaf │ ├── TestSwitch_nested_default_beginning.recaf │ ├── TestSwitch_no_break.recaf │ ├── TestUsing.recaf │ ├── TestWeb.recaf │ ├── TestWhile_no_break.recaf │ └── TestWhile_withBreak.recaf ├── pom.xml └── src │ ├── Plugin.rsc │ └── lang │ ├── java │ └── Java8.rsc │ └── recaf │ ├── DesugarMain.rsc │ ├── Recaf.rsc │ ├── TypeCheck.rsc │ └── desugar │ ├── Expr.rsc │ ├── RecafFull.rsc │ ├── RecafStmts.rsc │ ├── Recaffeinate.rsc │ ├── Stmt.rsc │ └── Util.rsc ├── recaf-runtime ├── .classpath ├── .project ├── build.properties ├── libs │ └── rascal-shell-stable.jar ├── pom.xml └── src │ ├── main │ └── java │ │ └── recaf │ │ ├── core │ │ ├── ISupply.java │ │ ├── Ref.java │ │ ├── alg │ │ │ ├── JavaExprAlg.java │ │ │ ├── JavaMethodAlg.java │ │ │ ├── JavaStmtAlg.java │ │ │ └── JavaStmtOnlyAlg.java │ │ ├── cps │ │ │ ├── CD.java │ │ │ ├── EvalJavaStmt.java │ │ │ ├── K.java │ │ │ ├── K0.java │ │ │ ├── SD.java │ │ │ └── StmtJavaCPS.java │ │ ├── direct │ │ │ ├── EvalJavaStmt.java │ │ │ ├── ICase.java │ │ │ ├── IEval.java │ │ │ ├── IExec.java │ │ │ └── StmtJavaDirect.java │ │ ├── expr │ │ │ ├── EvalJavaExpr.java │ │ │ ├── EvalJavaHelper.java │ │ │ ├── IRef.java │ │ │ └── ReflectRef.java │ │ └── full │ │ │ ├── FullJavaCPS.java │ │ │ ├── FullJavaDirect.java │ │ │ └── JavaStmtAlgAdapter.java │ │ ├── demo │ │ ├── constraint │ │ │ └── Solve.java │ │ ├── cps │ │ │ ├── Async.java │ │ │ ├── AsyncFull.java │ │ │ ├── Backtrack.java │ │ │ ├── ComeFrom.java │ │ │ ├── Coroutine.java │ │ │ ├── Iter.java │ │ │ ├── IterFull.java │ │ │ ├── Maybe.java │ │ │ ├── ParFor.java │ │ │ ├── Propagate.java │ │ │ └── StreamExt.java │ │ ├── direct │ │ │ ├── App.java │ │ │ ├── GUI.java │ │ │ ├── LINQ.java │ │ │ ├── Logging.java │ │ │ ├── Maybe.java │ │ │ ├── Memo.java │ │ │ ├── MemoizableCall.java │ │ │ ├── OrElse.java │ │ │ ├── Policy.java │ │ │ ├── Security.java │ │ │ ├── Student.java │ │ │ ├── StudentPolicy.java │ │ │ └── Using.java │ │ ├── generic │ │ │ ├── Times.java │ │ │ ├── Unless.java │ │ │ └── Until.java │ │ ├── pegs │ │ │ ├── Fail.java │ │ │ ├── MemoPEG.java │ │ │ ├── PEG.java │ │ │ ├── PEGwithLayout.java │ │ │ ├── Parser.java │ │ │ └── Result.java │ │ ├── swul │ │ │ └── SWUL.java │ │ └── web │ │ │ └── Web.java │ │ └── paper │ │ ├── access │ │ ├── Policy.java │ │ ├── Security.java │ │ └── StudentPolicy.java │ │ ├── demo │ │ ├── Backtrack.java │ │ ├── BacktrackFull.java │ │ ├── Debug.java │ │ ├── GUI.java │ │ ├── GUIImpl.java │ │ ├── Goto.java │ │ ├── HTTPRequest.java │ │ ├── HTTPResponse.java │ │ ├── Maybe.java │ │ ├── Memo.java │ │ ├── OrElse.java │ │ ├── Times.java │ │ ├── ToAST.java │ │ ├── ToJS.java │ │ ├── Tracing.java │ │ ├── Unless.java │ │ └── ast │ │ │ ├── Decl.java │ │ │ ├── Empty.java │ │ │ ├── Exp.java │ │ │ ├── Expr.java │ │ │ ├── Field.java │ │ │ ├── For.java │ │ │ ├── If.java │ │ │ ├── Invoke.java │ │ │ ├── Lambda.java │ │ │ ├── Lit.java │ │ │ ├── New.java │ │ │ ├── Return.java │ │ │ ├── Seq.java │ │ │ ├── Stm.java │ │ │ ├── This.java │ │ │ └── Var.java │ │ ├── expr │ │ ├── IEval.java │ │ ├── MuExpJava.java │ │ ├── MuExpJavaBase.java │ │ ├── MuExpJavaZip.java │ │ ├── Pair.java │ │ ├── Print.java │ │ ├── PrintAndEval.java │ │ └── PrintAndEvalManual.java │ │ ├── full │ │ ├── FullMuJava.java │ │ ├── FullMuJavaCPS.java │ │ ├── FullMuJavaCPSManual.java │ │ ├── FullMuJavaDirect.java │ │ ├── FullMuJavaDirectManual.java │ │ ├── MuStmIEvalJavaAdapter.java │ │ ├── MuStmJava.java │ │ ├── MuStmJavaAdapter.java │ │ ├── MuStmJavaManualAdapter.java │ │ └── MuStmPrintEvalAdapter.java │ │ ├── methods │ │ ├── MuJavaMethod.java │ │ ├── TPCPS.java │ │ ├── TPDirect.java │ │ └── ToOptional.java │ │ └── stm │ │ ├── IExec.java │ │ ├── MuJava.java │ │ ├── MuJavaBase.java │ │ ├── MuJavaCPS.java │ │ ├── Return.java │ │ └── SD.java │ ├── test-generated │ └── generated │ │ ├── BaseTestExprFieldSuper.java │ │ ├── BaseTestExprInvokeSuper.java │ │ ├── PStream.java │ │ ├── TestAsyncComplex.java │ │ ├── TestAsyncComplex2.java │ │ ├── TestAsyncNoAwait.java │ │ ├── TestAsyncWithAwait.java │ │ ├── TestBacktracking.java │ │ ├── TestComeFrom.java │ │ ├── TestCoroutine.java │ │ ├── TestDebug.java │ │ ├── TestDef.java │ │ ├── TestExprAnd.java │ │ ├── TestExprFieldSuper.java │ │ ├── TestExprInheritanceMethodLookup.java │ │ ├── TestExprInvokeSuper.java │ │ ├── TestExprNoConstructor.java │ │ ├── TestExprPlus.java │ │ ├── TestExprPrivateConstructor.java │ │ ├── TestExprSimpleMethodLookup.java │ │ ├── TestFibIter.java │ │ ├── TestFibIter2.java │ │ ├── TestFibMemo.java │ │ ├── TestFibRecAsync.java │ │ ├── TestFor_noBreak.java │ │ ├── TestFor_ordinary.java │ │ ├── TestFor_withBreak.java │ │ ├── TestGUI.java │ │ ├── TestGUI2.java │ │ ├── TestIter.java │ │ ├── TestIter_YieldEachRec.java │ │ ├── TestLocals.java │ │ ├── TestMaybe.java │ │ ├── TestOrElse.java │ │ ├── TestPEG.java │ │ ├── TestPropagate.java │ │ ├── TestPullStreams.java │ │ ├── TestQL.java │ │ ├── TestSWUL.java │ │ ├── TestSecurity.java │ │ ├── TestSimple.java │ │ ├── TestSolve.java │ │ ├── TestSolve_alldifferent.java │ │ ├── TestStream_Complex.java │ │ ├── TestStream_with_await.java │ │ ├── TestStream_with_awaitFor.java │ │ ├── TestStream_with_yield.java │ │ ├── TestStream_with_yieldFrom.java │ │ ├── TestSwitch_break_default_beginning.java │ │ ├── TestSwitch_break_first.java │ │ ├── TestSwitch_break_second.java │ │ ├── TestSwitch_break_second_withdefault.java │ │ ├── TestSwitch_nested_default_beginning.java │ │ ├── TestSwitch_no_break.java │ │ ├── TestUsing.java │ │ ├── TestUsingWithError.java │ │ ├── TestWeb.java │ │ ├── TestWhile_no_break.java │ │ └── TestWhile_withBreak.java │ └── test │ ├── java │ └── recaf │ │ └── tests │ │ ├── BaseTest.java │ │ ├── CompiletimeException.java │ │ ├── Log4jTestWatcher.java │ │ ├── RascalModuleRunner.java │ │ ├── extensions │ │ ├── TestAsyncExtension.java │ │ ├── TestBacktrackingExtension.java │ │ ├── TestIterExtension.java │ │ ├── TestMaybeExtension.java │ │ ├── TestSolveExtension.java │ │ ├── TestStreamExtension.java │ │ └── TestUsingExtension.java │ │ └── virtualization │ │ ├── TestVirtualization.java │ │ └── TestVirtualizationExpressions.java │ └── resources │ ├── log4j2.xml │ └── test ├── resources ├── SWUL.png └── recaf.png ├── testgen └── testnogen /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Created by https://www.gitignore.io/api/eclipse 3 | 4 | ### Eclipse ### 5 | *.pydevproject 6 | .metadata 7 | bin/ 8 | tmp/ 9 | *.tmp 10 | *.bak 11 | *.swp 12 | *~.nib 13 | local.properties 14 | .settings/ 15 | .loadpath 16 | 17 | # Eclipse Core 18 | # .project 19 | 20 | # External tool builders 21 | .externalToolBuilders/ 22 | 23 | # Locally stored "Eclipse launch configurations" 24 | *.launch 25 | 26 | # CDT-specific 27 | .cproject 28 | 29 | # JDT-specific (Eclipse Java Development Tools) 30 | # .classpath 31 | 32 | # Java annotation processor (APT) 33 | .factorypath 34 | 35 | # PDT-specific 36 | .buildpath 37 | 38 | # sbteclipse plugin 39 | .target 40 | 41 | # TeXlipse plugin 42 | .texlipse 43 | 44 | # STS (Spring Tool Suite) 45 | .springBeans 46 | 47 | ### Emacs ### 48 | # -*- mode: gitignore; -*- 49 | *~ 50 | \#*\# 51 | /.emacs.desktop 52 | /.emacs.desktop.lock 53 | *.elc 54 | auto-save-list 55 | tramp 56 | .\#* 57 | 58 | # Org-mode 59 | .org-id-locations 60 | *_archive 61 | 62 | # flymake-mode 63 | *_flymake.* 64 | 65 | # eshell files 66 | /eshell/history 67 | /eshell/lastdir 68 | 69 | # elpa packages 70 | /elpa/ 71 | 72 | # reftex files 73 | *.rel 74 | 75 | # AUCTeX auto folder 76 | /auto/ 77 | 78 | # cask packages 79 | .cask/ 80 | 81 | ### Java ### 82 | *.class 83 | 84 | # Mobile Tools for Java (J2ME) 85 | .mtj.tmp/ 86 | 87 | # Package Files # 88 | *.jar 89 | *.war 90 | *.ear 91 | 92 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 93 | hs_err_pid* 94 | 95 | .DS_Store 96 | *.DS_Store 97 | */.DS_Store 98 | 99 | target/ 100 | 101 | */*.log 102 | 103 | */BenchmarkList 104 | */CompilerHints -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | recaf 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.m2e.core.maven2Builder 10 | 11 | 12 | 13 | 14 | 15 | org.eclipse.m2e.core.maven2Nature 16 | 17 | 18 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: java 2 | 3 | jdk: 4 | - oraclejdk8 5 | 6 | script: mvn -DGEN=false clean dependency:copy-dependencies test 7 | 8 | notifications: 9 | email: false 10 | webhooks: 11 | urls: 12 | - https://webhooks.gitter.im/e/2112ed37cf625ee2e486 13 | on_success: always # options: [always|never|change] default: always 14 | on_failure: always # options: [always|never|change] default: always 15 | on_start: false # default: false 16 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2016 CWI - Software Analysis and Transformation 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 all 13 | 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 THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | com.github.cwi-swat 8 | recaf 9 | 1.0-SNAPSHOT 10 | pom 11 | 12 | 13 | recaf-runtime 14 | recaf-desugar 15 | 16 | -------------------------------------------------------------------------------- /recaf-desugar/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /recaf-desugar/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | recaf-desugar 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | rascal_eclipse.rascal_builder 15 | 16 | 17 | 18 | 19 | rascal_eclipse.term_builder 20 | 21 | 22 | 23 | 24 | org.eclipse.pde.ManifestBuilder 25 | 26 | 27 | 28 | 29 | org.eclipse.pde.SchemaBuilder 30 | 31 | 32 | 33 | 34 | org.eclipse.m2e.core.maven2Builder 35 | 36 | 37 | 38 | 39 | 40 | org.eclipse.m2e.core.maven2Nature 41 | rascal_eclipse.rascal_nature 42 | org.eclipse.jdt.core.javanature 43 | org.eclipse.pde.PluginNature 44 | rascal_eclipse.term_nature 45 | 46 | 47 | -------------------------------------------------------------------------------- /recaf-desugar/META-INF/MANIFEST.MF: -------------------------------------------------------------------------------- 1 | Manifest-Version: 1.0 2 | Bundle-ManifestVersion: 2 3 | Bundle-Name: recaf 4 | Bundle-SymbolicName: recaf 5 | Bundle-Version: 1.0.0 6 | Require-Bundle: rascal 7 | Bundle-RequiredExecutionEnvironment: JavaSE-1.8 8 | -------------------------------------------------------------------------------- /recaf-desugar/META-INF/RASCAL.MF: -------------------------------------------------------------------------------- 1 | Manifest-Version: 0.0.1 2 | Main-Function: main 3 | Main-Module: Plugin 4 | Source: src 5 | 6 | -------------------------------------------------------------------------------- /recaf-desugar/build.properties: -------------------------------------------------------------------------------- 1 | bin.includes = META-INF/ 2 | -------------------------------------------------------------------------------- /recaf-desugar/input-paper/TestDebug.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.paper.demo.Debug; 4 | 5 | public class TestDebug { 6 | private static recaf Debug alg = new Debug() {}; 7 | 8 | public int x = 3; 9 | 10 | public int dup(int x){ 11 | return 2*x; 12 | } 13 | 14 | private recaff Integer simple(){ 15 | debug! this.dup(this.x); 16 | return this.dup(this.x); 17 | } 18 | 19 | 20 | public static void main(String args[]) { 21 | TestDebug s = new TestDebug(); 22 | int n = s.simple(); 23 | System.out.println(n); 24 | 25 | } 26 | } -------------------------------------------------------------------------------- /recaf-desugar/input-paper/TestQL.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | /* 3 | import recaf.demo.ql.QL; 4 | 5 | public class TestQL { 6 | 7 | private recaf QL alg; 8 | 9 | public TestQL(QL alg) { 10 | this.alg = alg; 11 | } 12 | 13 | public recaf void taxOffice() { 14 | // todo: fix boxing of formal params in binders. 15 | question "Did you sell a house in 2010?", Boolean hasSoldHouse; 16 | question "Did you buy a house in 2010?", Boolean hasBoughtHouse; 17 | question "Did you enter a loan?", Boolean hasMaintLoan; 18 | if (hasSoldHouse) { 19 | question "What was the selling price?", Integer sellingPrice; 20 | question "Private debts for the sold house:", Integer privateDebt; 21 | question "Value residue:", Integer valueResidue = sellingPrice - privateDebt; 22 | } 23 | } 24 | 25 | }*/ -------------------------------------------------------------------------------- /recaf-desugar/input-paper/TestUsingWithError.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.direct.IExec; 4 | import recaf.demo.direct.Using; 5 | import java.io.BufferedReader; 6 | import java.io.FileNotFoundException; 7 | import java.io.FileReader; 8 | import java.io.IOException; 9 | 10 | public class TestUsingWithError { 11 | 12 | private static recaf Using alg = new Using() {}; 13 | 14 | static recaf String usingExample(String path) { 15 | using (BufferedReader br : new BufferedReader(new FileReader(path))){ 16 | return br.readLine(); 17 | } 18 | } 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | public static void main(String args[]) { 37 | System.out.println(new TestUsing().usingExample("src/test-generated/README.md")); 38 | } 39 | } -------------------------------------------------------------------------------- /recaf-desugar/input/BaseTestExprFieldSuper.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | public class BaseTestExprFieldSuper{ 4 | 5 | protected int x = 3; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /recaf-desugar/input/BaseTestExprInvokeSuper.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | public class BaseTestExprInvokeSuper{ 4 | 5 | @Override 6 | public String toString(){ 7 | return "BaseTestExprInvokeSuper"; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestAsyncComplex.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncComplex { 7 | 8 | private static recaf Async alg = new Async() {}; 9 | 10 | public static void pause(long sleeptime) { 11 | try { 12 | Thread.sleep(sleeptime); 13 | } catch (InterruptedException ex) { } 14 | } 15 | 16 | public static Void print(String msg) { 17 | System.out.println(msg); 18 | return null; 19 | } 20 | 21 | recaf CompletableFuture op() { 22 | if (1 < 2) { 23 | pause(2500); 24 | print("delayed op"); 25 | return 42; 26 | } 27 | return 41; 28 | } 29 | 30 | recaf CompletableFuture op2() { 31 | if (1 < 2) { 32 | await Integer x = op(); 33 | await Integer y = op(); 34 | return x + y; 35 | } 36 | pause(5000); 37 | return 41; 38 | } 39 | 40 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 41 | CompletableFuture answer; 42 | 43 | answer = new TestAsyncComplex().op2(); 44 | 45 | print("main"); 46 | 47 | System.out.println(answer.get()); 48 | } 49 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestAsyncComplex2.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.AsyncFull; 5 | 6 | class MyPrinter{ 7 | public MyPrinter(){} 8 | 9 | public Void print(String msg) { 10 | System.out.println(msg); 11 | return null; 12 | } 13 | } 14 | 15 | public class TestAsyncComplex2 { 16 | 17 | private static recaf AsyncFull alg = new AsyncFull() {}; 18 | 19 | public Void pause(Integer sleeptime) { 20 | try { 21 | new Thread().sleep(sleeptime); 22 | return null; 23 | } catch (InterruptedException ex) { 24 | return null; 25 | } 26 | } 27 | 28 | 29 | recaff CompletableFuture op() { 30 | if (1 < 2) { 31 | pause(2500); 32 | new MyPrinter().print("delayed op"); 33 | return 42; 34 | } 35 | return 41; 36 | } 37 | 38 | recaff CompletableFuture op2() { 39 | if (1 < 2) { 40 | await Integer x = op(); 41 | await Integer y = op(); 42 | return x + y; 43 | } 44 | pause(5000); 45 | return 41; 46 | } 47 | 48 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 49 | CompletableFuture answer; 50 | 51 | answer = new TestAsyncComplex2().op2(); 52 | 53 | new MyPrinter().print("main"); 54 | 55 | System.out.println(answer.get()); 56 | } 57 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestAsyncNoAwait.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncNoAwait { 7 | private static recaf Async alg = new Async() {}; 8 | 9 | recaf CompletableFuture op() { 10 | if (1 > 5) { 11 | return 42; 12 | } 13 | return 41; 14 | } 15 | 16 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 17 | Integer answer = new TestAsyncNoAwait().op().get(); 18 | 19 | System.out.println(answer); 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestAsyncWithAwait.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncWithAwait { 7 | private static recaf Async alg = new Async() {}; 8 | 9 | recaf CompletableFuture op() { 10 | if (1 < 2) { 11 | await Integer x = secondOp(); 12 | return x; 13 | } 14 | return 41; 15 | } 16 | 17 | recaf CompletableFuture secondOp() { 18 | if (1 < 2) { 19 | return 42; 20 | } 21 | return 41; 22 | } 23 | 24 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 25 | Integer answer = new TestAsyncWithAwait().op().get(); 26 | 27 | System.out.println(answer); 28 | } 29 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestBacktracking.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.List; 4 | import recaf.demo.cps.Backtrack; 5 | import static java.util.Arrays.asList; 6 | import java.util.stream.IntStream; 7 | import java.util.Iterator; 8 | 9 | public class TestBacktracking { 10 | 11 | static class Pair { 12 | int x, y; 13 | Pair(int x, int y) { 14 | this.x = x; 15 | this.y = y; 16 | } 17 | public String toString() { 18 | return "(" + x + ", " + y + ")"; 19 | } 20 | } 21 | 22 | static List solve(recaf Backtrack alg) { 23 | choose Integer x = asList(1, 2, 3); 24 | System.err.println("Choice 1: " + x); 25 | choose Integer y = asList(4, 5, 6); 26 | System.err.println("Choice 2: " + y); 27 | if (x * y == 8) { 28 | return new Pair(x, y); 29 | } 30 | } 31 | 32 | static Iterable range(int n) { 33 | return new Iterable() { 34 | public Iterator iterator() { 35 | return IntStream.range(0, n).iterator(); 36 | } 37 | }; 38 | } 39 | 40 | public static void main(String args[]) { 41 | System.out.println(solve(new Backtrack())); 42 | } 43 | 44 | 45 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestComeFrom.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.ComeFrom; 4 | import java.util.Scanner; 5 | 6 | public class TestComeFrom { 7 | 8 | // from wikipedia 9 | static Void repl(recaf ComeFrom cf) { 10 | comeFrom! "l40"; 11 | System.out.println("What is your name?"); 12 | Scanner scanner = new Scanner(System.in); 13 | String name = scanner.next(); 14 | System.out.println("Hello, " + name); 15 | l40: ; 16 | } 17 | 18 | public static void main(String[] args) { 19 | repl(new ComeFrom()); 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestCoroutine.recaf: -------------------------------------------------------------------------------- 1 | 2 | package generated; 3 | 4 | import recaf.demo.cps.Coroutine; 5 | import java.util.Random; 6 | 7 | 8 | public class TestCoroutine { 9 | 10 | static void producer(Coroutine.Co other) throws InterruptedException { 11 | while (true) { 12 | Thread.sleep(1000); 13 | int data = (new Random()).nextInt(); 14 | System.out.println("Sending " + data); 15 | System.out.println("Producer received: " + other.resume(data)); 16 | } 17 | } 18 | 19 | static Coroutine.Co consumer(recaf Coroutine alg) { 20 | int i = 0; 21 | while (true) { 22 | Integer x = yield! i++; 23 | System.out.println("consumer received: " + x); 24 | yield! 2 * i++; 25 | } 26 | } 27 | 28 | public static void main(String args[]) throws InterruptedException { 29 | Coroutine.Co coro = consumer(new Coroutine()); 30 | coro.run(); 31 | producer(coro); 32 | } 33 | 34 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestDef.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | 6 | public class TestDef { 7 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 8 | 9 | static recaf void doSomething() { 10 | int sum = 0; 11 | for (int i = 0; i < 10; i++) { 12 | if (i % 2 == 0) { 13 | sum += i; 14 | } 15 | } 16 | System.out.println("sum = " + sum); 17 | } 18 | 19 | public static void main(String args[]) { 20 | doSomething(); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprAnd.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprAnd { 6 | 7 | private int i = 0; 8 | 9 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 10 | 11 | private boolean rhs(){ 12 | i++; 13 | return true; 14 | } 15 | 16 | private recaff boolean lazyAnd(){ 17 | return 1 < 0 && rhs(); 18 | } 19 | 20 | private recaff boolean and(){ 21 | return 1 < 0 & rhs(); 22 | } 23 | 24 | public static void main(String args[]) { 25 | TestExprAnd o = new TestExprAnd(); 26 | System.out.println(o.lazyAnd()); 27 | System.out.println(o.i); 28 | System.out.println(o.and()); 29 | System.out.println(o.i); 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprFieldSuper.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprFieldSuper extends BaseTestExprFieldSuper { 6 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 7 | 8 | private int x = 5; 9 | 10 | public recaff int getThisX(){ 11 | return this.x; 12 | } 13 | 14 | public recaff int getSuperX(){ 15 | return super.x; 16 | } 17 | 18 | public static void main(String args[]) { 19 | TestExprFieldSuper o = new TestExprFieldSuper(); 20 | System.out.println(o.getThisX()); 21 | System.out.println(o.getSuperX()); 22 | } 23 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprInheritanceMethodLookup.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AD{ 6 | private int a; 7 | 8 | public AD(){ 9 | 10 | } 11 | 12 | void setA(int a){ 13 | this.a = a; 14 | } 15 | 16 | int getA(){ 17 | return a; 18 | } 19 | } 20 | 21 | class AE extends AD{ 22 | @Override 23 | int getA(){ 24 | return -1; 25 | } 26 | } 27 | 28 | 29 | public class TestExprInheritanceMethodLookup { 30 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 31 | 32 | private recaff static int simple(){ 33 | AE a = new AE(); 34 | a.setA(4); 35 | return a.getA(); 36 | } 37 | 38 | public static void main(String args[]) { 39 | int n = simple(); 40 | System.out.println(n); 41 | 42 | } 43 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprInvokeSuper.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprInvokeSuper extends BaseTestExprInvokeSuper { 6 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 7 | 8 | @Override 9 | public recaff String toString(){ 10 | String s = super.toString(); 11 | return "son("+s+")"; 12 | } 13 | 14 | public static void main(String args[]) { 15 | TestExprInvokeSuper o = new TestExprInvokeSuper(); 16 | System.out.println(o.toString()); 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprNoConstructor.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | 6 | 7 | public class TestExprNoConstructor { 8 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 9 | 10 | static class AB { 11 | private int a; 12 | 13 | @Override 14 | public String toString(){ 15 | return "AB("+a+")"; 16 | } 17 | } 18 | 19 | private recaff static AB simple(){ 20 | AB a = new AB(); 21 | return a; 22 | } 23 | 24 | public static void main(String args[]) { 25 | AB a = simple(); 26 | System.out.println(a); 27 | 28 | } 29 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprPrivateConstructor.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AA{ 6 | private int a = 0; 7 | 8 | private AA(){ 9 | 10 | } 11 | 12 | @Override 13 | public String toString(){ 14 | return "AA("+a+")"; 15 | } 16 | } 17 | 18 | 19 | public class TestExprPrivateConstructor { 20 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 21 | 22 | private recaff static AA simple(){ 23 | AA a = new AA(); 24 | return a; 25 | } 26 | 27 | public static void main(String args[]) { 28 | AA aa = simple(); 29 | System.out.println(aa); 30 | 31 | } 32 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestExprSimpleMethodLookup.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AC{ 6 | private int a; 7 | 8 | public AC(){ 9 | 10 | } 11 | 12 | void setA(int a){ 13 | this.a = a; 14 | } 15 | 16 | int getA(){ 17 | return a; 18 | } 19 | } 20 | 21 | 22 | public class TestExprSimpleMethodLookup { 23 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 24 | 25 | private recaff static int simple(){ 26 | AC a = new AC(); 27 | a.setA(4); 28 | return a.getA(); 29 | } 30 | 31 | public static void main(String args[]) { 32 | int n = simple(); 33 | System.out.println(n); 34 | 35 | } 36 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestFibIter.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.Iter; 4 | 5 | public class TestFibIter { 6 | private static recaf Iter alg = new Iter(); 7 | 8 | private recaf static Iterable fib() { 9 | int a = 0; 10 | int b = 1; 11 | 12 | while(true) { 13 | yield! a; 14 | b = a + b; 15 | a = b - a; 16 | } 17 | } 18 | 19 | public static void main(String args[]) { 20 | int count = 10; 21 | for (Integer n: fib()) { 22 | if(count-- == 0) { 23 | System.out.println(n); 24 | break; 25 | } 26 | } 27 | } 28 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestFibIter2.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.IterFull; 4 | 5 | public class TestFibIter2 { 6 | private static recaf IterFull alg = new IterFull() {}; 7 | 8 | private static recaff Iterable fib() { 9 | int a = 0; 10 | int b = 1; 11 | 12 | while(true) { 13 | yield! a; 14 | b = a + b; 15 | a = b - a; 16 | } 17 | } 18 | 19 | public static void main(String args[]) { 20 | int count = 10; 21 | for (Integer n: fib()) { 22 | if(count-- == 0) { 23 | System.out.println(n); 24 | break; 25 | } 26 | } 27 | } 28 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestFibMemo.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.Memo; 4 | 5 | public class TestFibMemo { 6 | private static recaf Memo alg = new Memo(); 7 | 8 | private recaff Integer fib(Integer x) { 9 | if(x < 2) { 10 | return x; 11 | } else { 12 | Integer x1 = fib(x-1); 13 | Integer x2 = fib(x-2); 14 | return x1 + x2; 15 | } 16 | } 17 | 18 | public static void main(String args[]) { 19 | int count = 10; 20 | TestFibMemo t = new TestFibMemo(); 21 | System.out.println(t.fib(12)); 22 | System.out.println(t.fib(12)); 23 | } 24 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestFibRecAsync.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.ExecutionException; 5 | import recaf.demo.cps.Async; 6 | 7 | public class TestFibRecAsync { 8 | private static recaf Async alg = new Async() {}; 9 | 10 | recaf CompletableFuture fib(Integer x) { 11 | if(x < 2) { 12 | return x; 13 | } else { 14 | await Integer x1 = fib(x-1); 15 | await Integer x2 = fib(x-2); 16 | return x1 + x2; 17 | } 18 | } 19 | 20 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 21 | CompletableFuture answer; 22 | 23 | answer = new TestFibRecAsync().fib(10); 24 | 25 | System.out.println(answer.get()); 26 | } 27 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestFor_noBreak.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestFor_noBreak { 6 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | recaf Integer meth() { 9 | Integer sum = 0; 10 | 11 | List list = Arrays.asList(1,2,3,4,5); 12 | 13 | for(Integer i : list) { 14 | sum += (Integer)i; 15 | } 16 | 17 | return sum; 18 | } 19 | 20 | public static void main(String args[]) { 21 | System.out.println(new TestFor_noBreak().meth()); //15 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestFor_ordinary.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestFor_ordinary { 5 | 6 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | recaf Integer meth() { 9 | int sum = 0; 10 | for(int i = 0; i < 10; i++) { 11 | sum += i; 12 | } 13 | return sum; 14 | } 15 | 16 | public static void main(String args[]) { 17 | System.out.println(new TestFor_ordinary().meth()); //45 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestFor_withBreak.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestFor_withBreak { 6 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | recaf Integer meth() { 9 | Integer sum = 0; 10 | 11 | List list = Arrays.asList(1,2,3,4,5); 12 | 13 | bla: while(true) { 14 | for(Integer i : list) { 15 | sum += (Integer)i; 16 | if (i > 3) { 17 | break bla; 18 | } 19 | } 20 | } 21 | 22 | return sum; 23 | } 24 | 25 | public static void main(String args[]) { 26 | System.out.println(new TestFor_withBreak().meth()); //10 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestGUI.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.direct.GUI; 3 | import recaf.demo.direct.GUI.Render; 4 | import recaf.demo.direct.GUI.Handle; 5 | import java.util.stream.IntStream; 6 | import java.util.Iterator; 7 | import java.io.StringWriter; 8 | 9 | 10 | public class TestGUI { 11 | private recaf GUI alg; 12 | 13 | public TestGUI(GUI alg) { 14 | this.alg = alg; 15 | } 16 | 17 | 18 | recaf void h2(String title) { 19 | tag ("h2") { 20 | echo! title; 21 | } 22 | } 23 | 24 | static Iterable range(int n) { 25 | return new Iterable() { 26 | public Iterator iterator() { 27 | return IntStream.range(0, n).iterator(); 28 | } 29 | }; 30 | } 31 | 32 | static void println(String x) { 33 | System.out.println(x); 34 | } 35 | 36 | static 37 | void hello(recaf GUI alg, int n) { 38 | tag ("div") 39 | for (int i: range(n)) 40 | tag ("p") { 41 | echo! "Hello world " + i + "!\n"; 42 | button ("Click " + i) 43 | if (i % 2 == 0) println("even " + i); 44 | else println("odd " + i); 45 | } 46 | } 47 | 48 | static void sendToServer(String x) { 49 | System.out.println(x); 50 | } 51 | 52 | public static void main(String args[]) { 53 | StringWriter w = new StringWriter(); 54 | hello(new Render(w), 10); 55 | sendToServer(w.toString()); 56 | // ... receive the clicked id; assume it's "id2" 57 | hello(new Handle("id2"), 10); // prints out even 2 58 | } 59 | 60 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestGUI2.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.direct.GUI; 3 | import recaf.demo.direct.GUI.Render; 4 | import recaf.demo.direct.GUI.Handle; 5 | import java.util.stream.IntStream; 6 | import java.util.Iterator; 7 | import java.io.StringWriter; 8 | 9 | 10 | public class TestGUI2 { 11 | private recaf GUI alg; 12 | 13 | public TestGUI2(GUI alg) { 14 | this.alg = alg; 15 | } 16 | 17 | 18 | recaf void h2(String title) { 19 | tag ("h2") { 20 | echo! title; 21 | } 22 | } 23 | 24 | static Iterable range(int n) { 25 | return new Iterable() { 26 | public Iterator iterator() { 27 | return IntStream.range(0, n).iterator(); 28 | } 29 | }; 30 | } 31 | 32 | static void println(String x) { 33 | System.out.println(x); 34 | } 35 | 36 | static 37 | //BEGIN_HELLOES 38 | void hello(recaf GUI alg, int n) { 39 | tag ("div") 40 | for (int i: range(n)) 41 | button ("Click " + i) 42 | println("clicked " + i); 43 | } 44 | //END_HELLOES 45 | 46 | static void sendToServer(String x) { 47 | System.out.println(x); 48 | } 49 | 50 | public static void main(String args[]) { 51 | //BEGIN_CLIENT_GUI 52 | StringWriter w = new StringWriter(); 53 | hello(new Render(w), 10); 54 | sendToServer(w.toString()); 55 | // ... receive the clicked id; assume it's "id2" 56 | hello(new Handle("id2"), 10); // prints out "clicked 2" 57 | //END_CLIENT_GUI 58 | } 59 | 60 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestIter.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Iter; 3 | import java.util.stream.IntStream; 4 | import java.util.Iterator; 5 | import java.util.function.Predicate; 6 | 7 | public class TestIter { 8 | private static recaf Iter alg = new Iter(); 9 | 10 | Iterable range(int n) { 11 | return new Iterable() { 12 | public Iterator iterator() { 13 | return IntStream.range(0, n).iterator(); 14 | } 15 | }; 16 | } 17 | 18 | recaf Iterable filter(Iterable iter, Predicate pred) { 19 | for (Integer t: iter) { 20 | if (pred.test(t)) { 21 | yield! t; 22 | } 23 | } 24 | } 25 | 26 | recaf Iterable subIter() { 27 | for (Integer i: range(10)) { 28 | yield! i; 29 | } 30 | } 31 | 32 | recaf Iterable myIter() { 33 | while (true) { 34 | yieldFrom! filter(subIter(), x -> ((Integer)x) % 2 == 0); 35 | } 36 | } 37 | 38 | public static void main(String args[]) { 39 | for (Integer i: new TestIter().myIter()) { 40 | System.out.println("i = " + i); 41 | } 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestIter_YieldEachRec.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Iter; 3 | import java.util.stream.IntStream; 4 | import java.util.Iterator; 5 | import java.util.function.Predicate; 6 | 7 | public class TestIter_YieldEachRec { 8 | private static recaf Iter alg = new Iter(); 9 | 10 | recaf Iterable naturalsDownFrom(int n) { 11 | if (n >0) { 12 | yield! n; 13 | yieldFrom! naturalsDownFrom(n-1); 14 | } 15 | } 16 | 17 | public static void main(String args[]) { 18 | for (Integer i: new TestIter_YieldEachRec().naturalsDownFrom(10)) { 19 | System.out.println("i = " + i); 20 | } 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestLocals.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.cps.StmtJavaCPS; 4 | import static java.util.Arrays.asList; 5 | 6 | public class TestLocals { 7 | 8 | public Integer doit(recaf StmtJavaCPS alg, int x, final Integer $x) { 9 | return x; 10 | return $x; 11 | Object[] objs; 12 | for (Object $$x: asList(objs)) ; 13 | } 14 | 15 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestMaybe.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Maybe; 3 | import java.util.Optional; 4 | 5 | public class TestMaybe { 6 | private recaf Maybe alg = new Maybe(); 7 | 8 | recaf Optional maybe() { 9 | int x = 3; 10 | System.out.println("maybe"); 11 | if (7 > 5) { 12 | System.out.println("Yes"); 13 | return 42; 14 | } 15 | } 16 | 17 | recaf Optional readOptional() { 18 | maybe Integer x = maybe(); 19 | return x + 1; 20 | } 21 | 22 | public static void main(String args[]) { 23 | Optional x = new TestMaybe().readOptional(); 24 | System.out.println(x.get()); 25 | } 26 | 27 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestOrElse.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.OrElse; 4 | 5 | public class TestOrElse { 6 | 7 | private static recaf OrElse alg = new OrElse() {}; 8 | 9 | Integer someMethod(int i) { 10 | System.out.println("Called: " + i); 11 | if (i % 2 != 0) { 12 | return null; 13 | } 14 | return i; 15 | } 16 | 17 | recaff Object orElse() { 18 | return #orElse(null, someMethod(1), someMethod(2), someMethod(3)); 19 | } 20 | 21 | public static void main(String args[]) { 22 | new TestOrElse().orElse(); 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestPropagate.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Propagate; 3 | 4 | 5 | public class TestPropagate { 6 | private recaf Propagate alg = new Propagate(); 7 | 8 | recaf void update(String s) { 9 | local (s) { 10 | method(); 11 | } 12 | ask String x; 13 | System.out.println(x); 14 | } 15 | 16 | void method() { 17 | read(); 18 | } 19 | 20 | recaf void read() { 21 | ask String s; 22 | System.out.println("s = " + s); 23 | } 24 | 25 | public static void main(String args[]) { 26 | new TestPropagate().update("Hello world!"); 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestPullStreams.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | public class TestPullStreams { 3 | public static void main(String args[]) { 4 | Integer result = PStream 5 | .range(10) 6 | .map(i -> i ^ 2) 7 | .filter(i -> i % 2 == 0) 8 | .sum(); 9 | System.out.println(result); 10 | } 11 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSecurity.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | import recaf.demo.direct.Student; 7 | import recaf.demo.direct.StudentPolicy; 8 | import recaf.demo.direct.Security; 9 | 10 | class Printer2 { 11 | public Void print(Object o) { 12 | System.out.print(o); 13 | return null; 14 | } 15 | } 16 | 17 | public class TestSecurity{ 18 | 19 | private static recaf Security alg = new Security(new StudentPolicy()); 20 | 21 | public recaff static Void printGrades(List students){ 22 | Printer2 p = new Printer2(); 23 | for (Student s : students){ 24 | p.print(s.name); 25 | p.print(" -> "); 26 | p.print(s.grade); 27 | p.print("\n"); 28 | } 29 | } 30 | 31 | public recaff static Void failStudent(Student s){ 32 | s.grade = "F"; 33 | } 34 | 35 | public static void main(String[] args){ 36 | List students = 37 | Arrays.asList(new Student[]{ 38 | new Student("Alice", "A",1), 39 | new Student("Bob","B", 2), 40 | new Student("Cathy","F",1)}); 41 | failStudent(students.get(0)); 42 | failStudent(students.get(1)); 43 | printGrades(students); 44 | } 45 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSimple.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.Ref; 3 | import recaf.core.full.FullJavaDirect; 4 | import java.util.stream.IntStream; 5 | import java.util.Iterator; 6 | import java.util.function.Predicate; 7 | import java.util.function.*; 8 | 9 | class A{ 10 | int i = 1; 11 | 12 | int a(int x, int y){ 13 | return ++i; 14 | } 15 | 16 | public A(){ 17 | 18 | } 19 | } 20 | 21 | public class TestSimple { 22 | private static recaf FullJavaDirect alg = new FullJavaDirect() {}; 23 | 24 | private recaff static Integer simple(){ 25 | int a = 4; 26 | int b = a++; 27 | int d = 0; 28 | while (d < 5 ){ 29 | ++d; 30 | } 31 | return d; 32 | } 33 | 34 | private recaff static Integer access(){ 35 | int a = 4; 36 | return a; 37 | } 38 | 39 | private recaff static Integer methodCall(){ 40 | return new A().a(1,2); 41 | } 42 | 43 | private recaff static Integer fieldAccess(){ 44 | return new A().i; 45 | } 46 | 47 | private recaff static Integer many(){ 48 | A a = new A(); 49 | a.i = 3; 50 | return a.i; 51 | 52 | } 53 | 54 | 55 | public static void main(String args[]) { 56 | int n = many(); 57 | System.out.println(n); 58 | 59 | } 60 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSolve.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.constraint.Solve; 4 | import java.util.Map; 5 | import org.chocosolver.solver.variables.IntVar; 6 | 7 | public class TestSolve { 8 | private static recaf Solve alg = new Solve(); 9 | 10 | recaff Iterable> example() { 11 | var 0, 5, IntVar x; 12 | var 0, 5, IntVar y; 13 | solve! x + y < 5; 14 | solve! x - y > 1; 15 | } 16 | 17 | public static void main(String args[]) { 18 | for (Map sol: new TestSolve().example()) { 19 | System.out.println(sol); 20 | } 21 | } 22 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSolve_alldifferent.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.constraint.Solve; 4 | import java.util.Map; 5 | import org.chocosolver.solver.variables.IntVar; 6 | 7 | public class TestSolve_alldifferent { 8 | private static recaf Solve alg = new Solve(); 9 | 10 | recaff Iterable> example() { 11 | var 0, 1, IntVar w; 12 | var -1, 2, IntVar x; 13 | var 2, 4, IntVar y; 14 | var 5, 7, IntVar z; 15 | solve! alldifferent(w, x, y, z); 16 | } 17 | 18 | public static void main(String args[]) { 19 | for (Map sol: new TestSolve_alldifferent().example()) { 20 | System.out.println(sol); 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestStream_Complex.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | import java.util.function.Consumer; 4 | import java.util.List; 5 | import java.util.concurrent.CompletableFuture; 6 | import recaf.demo.cps.Async; 7 | import recaf.demo.cps.StreamExt; 8 | import rx.Observable; 9 | import rx.Subscription; 10 | import rx.observers.TestSubscriber; 11 | 12 | public class TestStream_Complex { 13 | 14 | CompletableFuture accumulateAsync(recaf Async alg, Integer state, Integer next) { 15 | return state + next; 16 | } 17 | 18 | Observable scan(recaf StreamExt alg, 19 | Observable src, 20 | Integer state) { 21 | yield! state; 22 | awaitFor(Integer next : src) { 23 | Integer x = await! accumulateAsync(new Async(){}, state, next); 24 | yield! x; 25 | state = x; 26 | } 27 | } 28 | 29 | Observable simpleStream(recaf StreamExt alg) { 30 | yield! 1; 31 | yield! 2; 32 | yield! 3; 33 | yield! 4; 34 | yield! 5; 35 | } 36 | 37 | public static void main(String args[]) throws InterruptedException, ExecutionException { 38 | TestSubscriber testSubscriber = new TestSubscriber(); 39 | 40 | Subscription sub = new TestStream_Complex() 41 | .scan(new StreamExt(), new TestStream_Complex().simpleStream(new StreamExt()), 0) 42 | .take(6) 43 | .subscribe(testSubscriber); 44 | 45 | testSubscriber.awaitTerminalEvent(); 46 | List ret = testSubscriber.getOnNextEvents(); 47 | ret.forEach(new Consumer() { 48 | @Override 49 | public void accept(Integer t) { 50 | System.out.println(t); 51 | } 52 | }); 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestStream_with_await.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.CountDownLatch; 5 | 6 | import recaf.demo.cps.Async; 7 | import recaf.demo.cps.StreamExt; 8 | import rx.Observable; 9 | import rx.Subscription; 10 | import rx.functions.Action0; 11 | import rx.functions.Action1; 12 | 13 | public class TestStream_with_await { 14 | 15 | CompletableFuture secondOp(recaf Async alg) { 16 | if (1 < 2) { 17 | return 42; 18 | } 19 | return 41; 20 | } 21 | 22 | Observable simpleStream2(recaf StreamExt alg) { 23 | yield! 1; 24 | yield! 2; 25 | Integer x = await! secondOp(new Async(){}); 26 | yield! x; 27 | yield! 4; 28 | yield! 5; 29 | } 30 | 31 | public static void main(String args[]) throws InterruptedException, ExecutionException { 32 | CountDownLatch latch = new CountDownLatch(1); 33 | 34 | Subscription sub = new TestStream_with_await() 35 | .simpleStream2(new StreamExt()) 36 | .subscribe(new Action1() { 37 | @Override 38 | public void call(Integer s) { 39 | System.out.println(s); 40 | } 41 | }, 42 | new Action1() { 43 | @Override 44 | public void call(Throwable e) { 45 | latch.countDown(); 46 | } 47 | } 48 | , 49 | new Action0() { 50 | @Override 51 | public void call() { 52 | latch.countDown(); 53 | } 54 | }); 55 | 56 | latch.await(); 57 | 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestStream_with_awaitFor.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.CountDownLatch; 5 | 6 | import recaf.demo.cps.StreamExt; 7 | import rx.Observable; 8 | import rx.Subscription; 9 | import rx.functions.Action0; 10 | import rx.functions.Action1; 11 | 12 | public class TestStream_with_awaitFor { 13 | 14 | private recaf StreamExt alg = new StreamExt(); 15 | 16 | recaf Observable simpleStream() { 17 | yield! 1; 18 | yield! 2; 19 | yield! 3; 20 | yield! 4; 21 | yield! 5; 22 | } 23 | 24 | recaf Observable simpleStream2(Observable stream) { 25 | yield! 1; 26 | awaitFor(Integer next : stream) { 27 | Integer x = await! CompletableFuture.supplyAsync(()->42); 28 | yield! x; 29 | } 30 | } 31 | 32 | public static void main(String args[]) throws InterruptedException, ExecutionException { 33 | CountDownLatch latch = new CountDownLatch(1); 34 | 35 | Subscription sub = new TestStream_with_awaitFor() 36 | .simpleStream2(new TestStream_with_awaitFor().simpleStream()) 37 | .subscribe(new Action1() { 38 | @Override 39 | public void call(Integer s) { 40 | System.out.println(s); 41 | } 42 | }, 43 | new Action1() { 44 | @Override 45 | public void call(Throwable e) { 46 | latch.countDown(); 47 | } 48 | } 49 | , 50 | new Action0() { 51 | @Override 52 | public void call() { 53 | latch.countDown(); 54 | } 55 | }); 56 | 57 | latch.await(); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestStream_with_yield.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | 4 | import recaf.demo.cps.StreamExt; 5 | import rx.Observable; 6 | import rx.Subscription; 7 | import rx.functions.Action1; 8 | 9 | public class TestStream_with_yield { 10 | 11 | private recaf StreamExt alg = new StreamExt(); 12 | 13 | recaf Observable simpleStream() { 14 | yield! 1; 15 | yield! 2; 16 | yield! 3; 17 | yield! 4; 18 | yield! 5; 19 | } 20 | 21 | public static void main(String args[]) throws InterruptedException, ExecutionException { 22 | Subscription sub = new TestStream_with_yield().simpleStream().subscribe(new Action1() { 23 | @Override 24 | public void call(Integer s) { 25 | System.out.println(s); 26 | } 27 | }); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestStream_with_yieldFrom.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | 4 | import recaf.demo.cps.StreamExt; 5 | import rx.Observable; 6 | import rx.Subscription; 7 | import rx.functions.Action1; 8 | 9 | public class TestStream_with_yieldFrom { 10 | 11 | private recaf StreamExt alg = new StreamExt(); 12 | 13 | recaf Observable simpleStream() { 14 | yield! 1; 15 | yield! 2; 16 | yield! 3; 17 | yieldFrom! simpleStream2(); 18 | yield! 4; 19 | yield! 5; 20 | } 21 | 22 | recaf Observable simpleStream2() { 23 | yield! 11; 24 | yield! 22; 25 | yield! 33; 26 | yield! 44; 27 | yield! 55; 28 | } 29 | 30 | public static void main(String args[]) throws InterruptedException, ExecutionException { 31 | Subscription sub = new TestStream_with_yieldFrom().simpleStream().subscribe(new Action1() { 32 | @Override 33 | public void call(Integer s) { 34 | System.out.println(s); 35 | } 36 | }); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_break_default_beginning.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_default_beginning { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS(){}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | recaf String meth() { 13 | int number = 2; 14 | 15 | String selection = "none"; 16 | 17 | switch (number) { 18 | default: 19 | print("with default"); 20 | case 1: 21 | print("one"); 22 | break; 23 | case 2: 24 | print("two"); 25 | } 26 | return selection; // returns two 27 | } 28 | 29 | public static void main(String args[]) { 30 | new TestSwitch_break_default_beginning().meth(); 31 | } 32 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_break_first.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_first { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | 13 | recaf String meth() { 14 | int number = 1; 15 | 16 | String selection = "none"; 17 | 18 | switch (number) { 19 | case 1: 20 | print("one"); 21 | break; 22 | case 2: 23 | print("two"); 24 | default: 25 | print("default"); 26 | } 27 | return selection; 28 | } 29 | 30 | public static void main(String args[]) { 31 | new TestSwitch_break_first().meth(); 32 | } 33 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_break_second.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_second { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | recaf String meth() { 13 | int number = 1; 14 | 15 | String selection = "none"; 16 | 17 | switch (number) { 18 | case 1: 19 | print("one"); 20 | case 2: 21 | print("two"); 22 | break; 23 | default: 24 | print("default"); 25 | } 26 | return selection; 27 | } 28 | 29 | public static void main(String args[]) { 30 | new TestSwitch_break_second().meth(); 31 | } 32 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_break_second_withdefault.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_second_withdefault { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | recaf String meth() { 13 | int number = 2; 14 | 15 | String selection = "none"; 16 | 17 | switch (number) { 18 | case 1: 19 | print("one"); 20 | case 2: 21 | print("two"); 22 | default: 23 | print("with default"); 24 | } 25 | return selection; 26 | } 27 | 28 | public static void main(String args[]) { 29 | new TestSwitch_break_second_withdefault().meth(); 30 | } 31 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_nested_default_beginning.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_nested_default_beginning { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | recaf String meth() { 13 | int number = 1; 14 | int number2 = 3; 15 | String selection = "none"; 16 | 17 | switch (number) { 18 | default: 19 | print("with default"); 20 | case 1: 21 | switch (number2) { 22 | case 1: 23 | print("one"); 24 | break; 25 | default: 26 | print("with default"); 27 | case 3: 28 | print("three"); 29 | break; 30 | case 4: 31 | print("four"); 32 | } 33 | case 2: 34 | print("two"); 35 | } 36 | return selection; 37 | } 38 | 39 | public static void main(String args[]) { 40 | 41 | new TestSwitch_nested_default_beginning().meth(); 42 | 43 | } 44 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestSwitch_no_break.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_no_break { 5 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | recaf String meth() { 13 | int number = 1; 14 | 15 | String selection = "none"; 16 | 17 | switch (number) { 18 | case 1: 19 | print("one"); 20 | case 2: 21 | print("two"); 22 | default: 23 | print("default"); 24 | } 25 | 26 | return selection; 27 | } 28 | 29 | public static void main(String args[]) { 30 | new TestSwitch_no_break().meth(); 31 | 32 | } 33 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestUsing.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.Using; 4 | import java.io.BufferedReader; 5 | import java.io.FileNotFoundException; 6 | import java.io.FileReader; 7 | import java.io.IOException; 8 | 9 | public class TestUsing { 10 | 11 | private static recaf Using alg = new Using() {}; 12 | 13 | static recaf String usingExample(String path) { 14 | using (BufferedReader br : new BufferedReader(new FileReader(path))){ 15 | return br.readLine(); 16 | } 17 | } 18 | 19 | public static void main(String args[]) { 20 | System.out.println(new TestUsing().usingExample("src/test/resources/test")); 21 | } 22 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestWeb.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.paper.demo.ToJS; 4 | import recaf.paper.demo.HTTPResponse; 5 | import recaf.paper.demo.HTTPRequest; 6 | 7 | public class TestWeb extends ToJS.Browser { 8 | 9 | recaf ToJS alg = new ToJS(); 10 | 11 | //BEGIN_HELLOWORLD_WEB 12 | recaff HTTPResponse helloWorld(HTTPRequest req) { 13 | document.write("

Hello world " 14 | + req.params.get("name") + "

"); 15 | } 16 | //END_HELLOWORLD_WEB 17 | 18 | public static void main(String args[]) { 19 | HTTPResponse r = new TestWeb().helloWorld(new HTTPRequest()); 20 | System.out.println(r.getJs()); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /recaf-desugar/input/TestWhile_no_break.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestWhile_no_break { 6 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | public recaf Integer meth() { 9 | Integer sum = 0; 10 | 11 | Iterator list = Arrays.asList(1,2,3,4,5).iterator(); 12 | 13 | while(list.hasNext()) { 14 | sum += list.next(); 15 | } 16 | 17 | return sum; 18 | } 19 | 20 | public static void main(String args[]) { 21 | System.out.println(new TestWhile_no_break().meth()); //15 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /recaf-desugar/input/TestWhile_withBreak.recaf: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestWhile_withBreak { 6 | private recaf StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | public recaf Integer meth() { 9 | Integer sum = 0; 10 | 11 | Iterator list = Arrays.asList(1,2,3,4,5).iterator(); 12 | 13 | while(list.hasNext()) { 14 | sum += list.next(); 15 | if (sum > 5) { 16 | break; 17 | } 18 | } 19 | 20 | return sum; 21 | } 22 | 23 | public static void main(String args[]) { 24 | System.out.println(new TestWhile_withBreak().meth()); //6 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /recaf-desugar/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | com.github.cwi-swat 8 | recaf-desugar 9 | 1.0-SNAPSHOT 10 | pom 11 | -------------------------------------------------------------------------------- /recaf-desugar/src/Plugin.rsc: -------------------------------------------------------------------------------- 1 | module Plugin 2 | 3 | import lang::recaf::Recaf; 4 | import lang::recaf::desugar::Recaffeinate; 5 | import lang::recaf::TypeCheck; 6 | import ParseTree; 7 | 8 | import IO; 9 | import Message; 10 | import util::IDE; 11 | 12 | private str LANG_NAME = "Java Recaffeinated"; 13 | 14 | // relative to HOME dir 15 | private str RECAF_RUNTIME_HOME = "/CWI/recaf/recaf-runtime"; 16 | 17 | void main() { 18 | registerLanguage(LANG_NAME, "recaf", start[CompilationUnit](str src, loc org) { 19 | return parse(#start[CompilationUnit], src, org); 20 | }); 21 | 22 | registerContributions(LANG_NAME, { 23 | builder(set[Message] (Tree tree) { 24 | if (start[CompilationUnit] cu := tree) { 25 | loc l = cu@\loc.top; 26 | l.extension = "java"; 27 | newLoc = |project://recaf-runtime/src/test-generated/generated/|; 28 | newCU = recaffeinate(cu); 29 | writeFile(newLoc, newCU); 30 | 31 | fileLoc = |home:///|; 32 | sourcePaths = [ 33 | |home:///src/main/java|, 34 | |home:///src/test-generated| 35 | ]; 36 | return typeCheck(fileLoc, sourcePaths, newCU, cu); 37 | } 38 | return {error("Not a program", tree@\loc)}; 39 | }) 40 | }); 41 | } -------------------------------------------------------------------------------- /recaf-desugar/src/lang/recaf/DesugarMain.rsc: -------------------------------------------------------------------------------- 1 | module lang::recaf::DesugarMain 2 | 3 | import lang::recaf::Recaf; 4 | import lang::recaf::desugar::Recaffeinate; 5 | import ParseTree; 6 | import IO; 7 | import String; 8 | 9 | void main(list[str] args) { 10 | str root = args[0]; 11 | str tgt = args[1]; 12 | 13 | loc rootDir = toLocation(root); 14 | for (loc src <- rootDir.ls){ 15 | str content = readFile(src); 16 | Tree tree = parse(#start[CompilationUnit], content); 17 | if (start[CompilationUnit] cu := tree) { 18 | println(src); 19 | newLoc = toLocation(tgt+"/"); 20 | writeFile(newLoc, recaffeinate(cu)); 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /recaf-desugar/src/lang/recaf/Recaf.rsc: -------------------------------------------------------------------------------- 1 | module lang::recaf::Recaf 2 | 3 | extend lang::java::Java8; 4 | 5 | syntax KId 6 | = @category="MetaKeyword" Id 7 | ; 8 | 9 | 10 | syntax Expr 11 | = "#" KId "(" { Expr ","}* ")" 12 | | "#" KId Block 13 | ; 14 | 15 | syntax Stm 16 | // return -like 17 | = KId "!" Expr ";" // ! is needed, otherwise amb with local var dec. 18 | | KId "!" ";" // ugly, but hey 19 | 20 | // for, while and try like, and combinations 21 | | KId "(" FormalParam ":" Expr ")" Stm 22 | | KId "(" {Expr ","}+ ")" Stm!empty 23 | | KId "(" {Expr ","}+ "," FormalParam ":" Expr ")" Stm 24 | | KId Stm!exprStm!empty 25 | 26 | // with continuation blocks (not implemented) 27 | | KId "(" FormalParam ":" Expr ")" Stm Rest+ 28 | | KId "(" Expr ")" Block Rest+ 29 | | KId Block Rest+ 30 | // TODO: augment with all the other forms 31 | 32 | // switch case like 33 | | KId "(" FormalParam ":" Expr ")" "{" Item+ "}" 34 | | KId "(" {Expr ","}+ ")" "{" Item+ "}" 35 | | KId "{" Item+ "}" 36 | 37 | // decl like 38 | | KId FormalParam ";" 39 | | KId FormalParam "=" "(" Expr ")" Stm!empty 40 | | KId {Expr ","}+ "," FormalParam ";" 41 | | KId FormalParam "=" Expr ";" 42 | | KId {Expr ","}+ "," FormalParam "=" Expr ";" 43 | | FormalParam "=" KId "!" Expr ";" 44 | 45 | // new style 46 | | KId "(" {FormalParam ","}+ ")" Stm 47 | // todo: KId "(" {Expr ","}+ "," {FormalParam ","}+ ")" Stm 48 | ; 49 | 50 | syntax Item 51 | = KId {Expr ","}+ ":" BlockStm+ 52 | | KId FormalParam ":" BlockStm+ 53 | ; 54 | 55 | 56 | syntax Anno 57 | = "[" Type "]" 58 | ; 59 | 60 | syntax VarMod 61 | = "recaf" !>> "f" 62 | | "recaff" 63 | ; 64 | 65 | syntax FieldMod 66 | = "recaf" 67 | ; 68 | 69 | 70 | syntax MethodMod 71 | = "recaf" !>> "f" 72 | | "recaff" 73 | ; 74 | 75 | syntax Modifier 76 | = "default" 77 | ; 78 | 79 | syntax Rest 80 | = KId ":" Block 81 | | KId ":" "(" Expr ")" Block 82 | | KId ":" "(" FormalParam ")" Block 83 | | KId ":" "(" FormalParam ":" Expr ")" Block 84 | ; 85 | 86 | 87 | 88 | -------------------------------------------------------------------------------- /recaf-desugar/src/lang/recaf/TypeCheck.rsc: -------------------------------------------------------------------------------- 1 | module lang::recaf::TypeCheck 2 | 3 | import lang::recaf::Recaf; 4 | 5 | import Message; 6 | import ParseTree; 7 | import lang::java::jdt::m3::Core; 8 | import IO; 9 | import String; 10 | 11 | set[Message] typeCheck(loc generatedFileLoc, list[loc] sourcePaths, start[CompilationUnit] desugaredCU, start[CompilationUnit] cu) { 12 | <_, ind> = posIndex(desugaredCU, desugaredCU@\loc); 13 | 14 | return { relocate(m, ind) | Message m <- createM3FromFile(generatedFileLoc, sourcePath = sourcePaths, javaVersion="1.8").messages}; 15 | } 16 | 17 | default 18 | Message relocate(Message m, rel[loc src, loc origin] ind) = m; 19 | 20 | Message relocate(error(str s, loc l), rel[loc src, loc origin] ind) = error(s, l2) 21 | when 22 | <- ind, 23 | l1.offset == l.offset, l1.length == l.length; 24 | 25 | 26 | tuple[loc current, rel[loc src, loc origin] index] posIndex(Tree tree, loc current) { 27 | //cur = |://|(0, 0, <1, 0>, <1,0>); 28 | ind = {}; 29 | 30 | switch (tree) { 31 | case char(n): { 32 | current.offset += 1; 33 | current.length = 1; 34 | return ; 35 | } 36 | 37 | case t:appl(_, args): { 38 | if (t@\loc?) { 39 | current.length = t@\loc.length; 40 | ind += {}; 41 | for (Tree a <- args) { 42 | = posIndex(a, current); 43 | ind += subs; 44 | } 45 | } 46 | else { 47 | current.offset += size(""); 48 | } 49 | } 50 | case amb(_): 51 | throw "todo"; 52 | } 53 | 54 | return ; 55 | 56 | 57 | } 58 | 59 | -------------------------------------------------------------------------------- /recaf-desugar/src/lang/recaf/desugar/RecafFull.rsc: -------------------------------------------------------------------------------- 1 | module lang::recaf::desugar::RecafFull 2 | 3 | extend lang::recaf::desugar::Expr; 4 | import lang::recaf::desugar::Util; 5 | import List; 6 | import Set; 7 | import String; 8 | import IO; 9 | import util::Maybe; 10 | 11 | MethodDec recafFull(MethodDec m, list[Id] algFields) 12 | = recafMethod(m, algFields); 13 | 14 | MethodDec recafMethod((MethodDec)` (recaff , <{FormalParam ","}* fs>) `, list[Id] algFields) 15 | = (MethodDec)` ( , <{FormalParam ","}* fs>) { 16 | ' 17 | ' 18 | '}` 19 | when := fps2decls(fs, declaredNames(b) + { x | /Id x := fs }), 20 | cps := method2alg(b, alg, names), 21 | ret := makeReturn(rt, cps); 22 | 23 | MethodDec recafMethod((MethodDec)` recaff (<{FormalParam ","}* fs>) `, list[Id] algFields) 24 | = (MethodDec)` (<{FormalParam ","}* fs>) { 25 | ' 26 | ' 27 | '}` 28 | when 29 | Id alg <- algFields, 30 | := fps2decls(fs, declaredNames(b) + { x | /Id x := fs }), 31 | cps := method2alg(b, alg, names), 32 | ret := makeReturn(rt, cps); 33 | 34 | default MethodDec recafMethod(MethodDec m, list[Id] algFields) = m; 35 | 36 | // NB: cannot use expr2alg because of void expressions. 37 | Expr stm2alg((Stm)`;`, Id alg, Names names) 38 | = (Expr)`.ExpStat()` 39 | when 40 | Expr e2 := expr2alg(unwrapRefs(e, names), alg, names); 41 | 42 | Expr injectExpr(Expr e, Id alg, Names names) 43 | = e2 //(Expr)`.Exp()` 44 | when 45 | Expr e2 := expr2alg(unwrapRefs(e, names), alg, names); 46 | 47 | 48 | -------------------------------------------------------------------------------- /recaf-desugar/src/lang/recaf/desugar/Recaffeinate.rsc: -------------------------------------------------------------------------------- 1 | module lang::recaf::desugar::Recaffeinate 2 | 3 | import lang::recaf::desugar::RecafStmts; 4 | import lang::recaf::desugar::RecafFull; 5 | import lang::recaf::Recaf; 6 | import List; 7 | import Set; 8 | import String; 9 | import IO; 10 | import util::Maybe; 11 | 12 | list[Id] collectAlgFields(start[CompilationUnit] cu) { 13 | list[Id] algFields = []; 14 | visit (cu) { 15 | case (FieldDec)` recaf = ;`: 16 | algFields += [x]; 17 | case (FieldDec)` recaf ;`: 18 | algFields += [x]; 19 | } 20 | return algFields; 21 | } 22 | 23 | start[CompilationUnit] recaffeinate(start[CompilationUnit] cu) { 24 | algFields = collectAlgFields(cu); 25 | 26 | return top-down visit (cu) { 27 | case (FieldDec)` recaf = ;` 28 | => (FieldDec)` = ;` 29 | 30 | case (FieldDec)` recaf ;` 31 | => (FieldDec)` ;` 32 | 33 | case m:(MethodDec)` (recaf , <{FormalParam ","}* _>) ` 34 | => recafStms(m, []) 35 | 36 | case m:(MethodDec)` recaf (<{FormalParam ","}* _>) ` 37 | => recafStms(m, algFields) 38 | 39 | case m:(MethodDec)` (recaff , <{FormalParam ","}* _>) ` 40 | => recafFull(m, []) 41 | 42 | case m:(MethodDec)` recaff (<{FormalParam ","}* _>) ` 43 | => recafFull(m, algFields) 44 | 45 | } 46 | } -------------------------------------------------------------------------------- /recaf-runtime/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /recaf-runtime/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | recaf-runtime 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | org.eclipse.m2e.core.maven2Builder 15 | 16 | 17 | 18 | 19 | 20 | org.eclipse.m2e.core.maven2Nature 21 | org.eclipse.jdt.core.javanature 22 | 23 | 24 | -------------------------------------------------------------------------------- /recaf-runtime/build.properties: -------------------------------------------------------------------------------- 1 | bin.includes = META-INF/ 2 | -------------------------------------------------------------------------------- /recaf-runtime/libs/rascal-shell-stable.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cwi-swat/recaf/70741af767191a126a7fac9e37ca80dcd373107b/recaf-runtime/libs/rascal-shell-stable.jar -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/ISupply.java: -------------------------------------------------------------------------------- 1 | package recaf.core; 2 | 3 | public interface ISupply { 4 | T get() throws Throwable; 5 | 6 | } 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/Ref.java: -------------------------------------------------------------------------------- 1 | package recaf.core; 2 | 3 | import recaf.core.expr.IRef; 4 | 5 | // todo: extract interface to make useable with fields in expression eval. 6 | public final class Ref implements IRef{ 7 | public X value ; 8 | public Ref(X value) { 9 | this.value = value; 10 | } 11 | 12 | public Ref() { 13 | this(null); 14 | } 15 | 16 | @Override 17 | public X value(){ 18 | return value; 19 | } 20 | 21 | @Override 22 | public IRef setValue(X val) { 23 | value = val; 24 | return this; 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/alg/JavaMethodAlg.java: -------------------------------------------------------------------------------- 1 | package recaf.core.alg; 2 | 3 | public interface JavaMethodAlg { 4 | R Method(S body); 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/alg/JavaStmtAlg.java: -------------------------------------------------------------------------------- 1 | package recaf.core.alg; 2 | 3 | import java.util.function.Function; 4 | 5 | import recaf.core.Ref; 6 | 7 | public interface JavaStmtAlg { 8 | S Decl(E exp, Function, S> body); 9 | 10 | S ForEach(E exp, Function, S> body); 11 | 12 | S ForDecl(E init, Function, S> body); 13 | 14 | S ForBody(E cond, S update, S body); 15 | 16 | S Throw(E e); 17 | 18 | S TryCatch(S body, Class type, Function handle); 19 | 20 | @SuppressWarnings("unchecked") 21 | S Switch(E expr, C... cases); 22 | 23 | C Case(T constant, S expStat); 24 | 25 | C Default(S expStat); 26 | 27 | S For(S init, E cond, S update, S body); 28 | 29 | S If(E cond, S s); 30 | 31 | S If(E cond, S s1, S s2); 32 | 33 | S While(E cond, S s); 34 | 35 | S DoWhile(S s, E cond); 36 | 37 | S Labeled(String label, S s); 38 | 39 | S Break(String label); 40 | 41 | S Continue(String label); 42 | 43 | S Break(); 44 | 45 | S Continue(); 46 | 47 | S Return(E supplier); 48 | 49 | S Return(); 50 | 51 | S Empty(); 52 | 53 | S Seq(S s1, S s2); 54 | 55 | S TryFinally(S body, S fin); 56 | 57 | S ExpStat(E e); 58 | } 59 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/alg/JavaStmtOnlyAlg.java: -------------------------------------------------------------------------------- 1 | package recaf.core.alg; 2 | 3 | import java.util.function.Function; 4 | 5 | import recaf.core.ISupply; 6 | import recaf.core.Ref; 7 | 8 | public interface JavaStmtOnlyAlg { 9 | S Decl(ISupply exp, Function, S> body); 10 | 11 | S ForEach(ISupply> exp, Function, S> body); 12 | 13 | S ForDecl(ISupply init, Function, S> body); 14 | 15 | S ForBody(ISupply cond, S update, S body); 16 | 17 | S Throw(ISupply e); 18 | 19 | S TryCatch(S body, Class type, Function handle); 20 | 21 | @SuppressWarnings("unchecked") 22 | S Switch(ISupply expr, C... cases); 23 | 24 | C Case(T constant, S expStat); 25 | 26 | C Default(S expStat); 27 | 28 | S For(S init, ISupply cond, S update, S body); 29 | 30 | S If(ISupply cond, S s); 31 | 32 | S If(ISupply cond, S s1, S s2); 33 | 34 | S While(ISupply cond, S s); 35 | 36 | S DoWhile(S s, ISupply cond); 37 | 38 | S Labeled(String label, S s); 39 | 40 | S Break(String label); 41 | 42 | S Continue(String label); 43 | 44 | S Break(); 45 | 46 | S Continue(); 47 | 48 | S Return(ISupply supplier); 49 | 50 | S Return(); 51 | 52 | S Empty(); 53 | 54 | S Seq(S s1, S s2); 55 | 56 | S TryFinally(S body, S fin); 57 | 58 | S ExpStat(ISupply e); 59 | } 60 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/cps/CD.java: -------------------------------------------------------------------------------- 1 | package recaf.core.cps; 2 | 3 | import java.util.List; 4 | 5 | /** 6 | * Case Denotation 7 | * 8 | * matched: if we have matched a case already. 9 | * value: the value that is switched upon 10 | * rho: continuation for return 11 | * sigma: continuation for success (fall through) 12 | * brk: continuation for break 13 | * contin: continuation for continue 14 | * err: continuation for exceptions 15 | * 16 | * @param 17 | */ 18 | 19 | public interface CD { 20 | void accept(boolean matched, Object v, List> rest, K rho, K0 sigma, K brk, K contin, K err); 21 | } 22 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/cps/K.java: -------------------------------------------------------------------------------- 1 | package recaf.core.cps; 2 | 3 | import java.util.function.Consumer; 4 | 5 | //R -> Unit 6 | public interface K extends Consumer { 7 | 8 | } 9 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/cps/K0.java: -------------------------------------------------------------------------------- 1 | package recaf.core.cps; 2 | 3 | public interface K0 { 4 | void call(); 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/cps/SD.java: -------------------------------------------------------------------------------- 1 | package recaf.core.cps; 2 | 3 | /** 4 | * Statement Denotation 5 | * 6 | * rho: continuation for return 7 | * sigma: continuation for success (fall through) 8 | * brk: continuation for break 9 | * contin: continuation for continue 10 | * ex: continuation for exceptions 11 | * 12 | * @param 13 | */ 14 | 15 | public interface SD { 16 | void accept(String label, K rho, K0 sigma, K brk, K contin, K err); 17 | } -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/cps/StmtJavaCPS.java: -------------------------------------------------------------------------------- 1 | package recaf.core.cps; 2 | 3 | import recaf.core.Ref; 4 | import recaf.core.alg.JavaMethodAlg; 5 | 6 | public interface StmtJavaCPS extends EvalJavaStmt, JavaMethodAlg> { 7 | @Override 8 | default R Method(SD body) { 9 | Ref result = new Ref<>(); 10 | body.accept(null, r -> { 11 | result.value = r; 12 | } , () -> { 13 | } , l -> { 14 | throw new AssertionError("Cannot call break without loop"); 15 | } , l -> { 16 | throw new AssertionError("Cannot call continue without loop"); 17 | } , exc -> { 18 | throw new RuntimeException(exc); 19 | }); 20 | return result.value; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/direct/ICase.java: -------------------------------------------------------------------------------- 1 | package recaf.core.direct; 2 | 3 | public interface ICase { 4 | boolean eval(Object value, boolean fallThrough) throws Throwable; 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/direct/IEval.java: -------------------------------------------------------------------------------- 1 | package recaf.core.direct; 2 | 3 | @FunctionalInterface 4 | public interface IEval { 5 | Object eval() throws Throwable; 6 | } 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/direct/IExec.java: -------------------------------------------------------------------------------- 1 | package recaf.core.direct; 2 | 3 | @FunctionalInterface 4 | public interface IExec { 5 | void exec(String label) throws Throwable; 6 | } 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/direct/StmtJavaDirect.java: -------------------------------------------------------------------------------- 1 | package recaf.core.direct; 2 | 3 | public interface StmtJavaDirect extends EvalJavaStmt { 4 | // @Override 5 | // default IExec ExpStat(ISupply thunk) { 6 | // return l -> { thunk.get(); }; 7 | // } 8 | } 9 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/expr/IRef.java: -------------------------------------------------------------------------------- 1 | package recaf.core.expr; 2 | 3 | public interface IRef { 4 | T value(); 5 | IRef setValue(T val); 6 | } 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/expr/ReflectRef.java: -------------------------------------------------------------------------------- 1 | package recaf.core.expr; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | // todo: extract interface to make useable with fields in expression eval. 6 | public final class ReflectRef implements IRef{ 7 | private Object object; 8 | private Field field; 9 | private String fieldName; 10 | 11 | public ReflectRef(Object obj, String fldName) throws NoSuchFieldException, SecurityException { 12 | this.object = obj; 13 | field = obj.getClass().getDeclaredField(fldName); 14 | fieldName = fldName; 15 | } 16 | 17 | 18 | @Override 19 | public X value(){ 20 | field.setAccessible(true); 21 | try { 22 | return (X) field.get(object); 23 | } catch (IllegalArgumentException | IllegalAccessException e) { 24 | throw new RuntimeException(e); 25 | } 26 | } 27 | 28 | @Override 29 | public IRef setValue(X val){ 30 | field.setAccessible(true); 31 | try { 32 | field.set(object, val); 33 | return this; 34 | } catch (IllegalArgumentException | IllegalAccessException e) { 35 | e.printStackTrace(); 36 | throw new RuntimeException(e); 37 | } 38 | } 39 | 40 | 41 | public String getFieldName() { 42 | return fieldName; 43 | } 44 | 45 | 46 | public Object getObject() { 47 | return object; 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/full/FullJavaCPS.java: -------------------------------------------------------------------------------- 1 | package recaf.core.full; 2 | 3 | import recaf.core.Ref; 4 | import recaf.core.alg.JavaMethodAlg; 5 | import recaf.core.alg.JavaStmtOnlyAlg; 6 | import recaf.core.cps.CD; 7 | import recaf.core.cps.EvalJavaStmt; 8 | import recaf.core.cps.SD; 9 | import recaf.core.expr.EvalJavaExpr; 10 | 11 | public interface FullJavaCPS extends JavaStmtAlgAdapter, CD>, EvalJavaExpr, JavaMethodAlg> { 12 | 13 | @Override 14 | default JavaStmtOnlyAlg, CD> base() { 15 | return new EvalJavaStmt() {}; 16 | } 17 | 18 | @Override 19 | default R Method(SD body) { 20 | Ref result = new Ref<>(); 21 | body.accept(null, r -> { 22 | result.value = r; 23 | } , () -> { 24 | } , l -> { 25 | throw new AssertionError("Cannot call break without loop"); 26 | } , l -> { 27 | throw new AssertionError("Cannot call continue without loop"); 28 | } , exc -> { 29 | throw new RuntimeException(exc); 30 | }); 31 | return result.value; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/core/full/FullJavaDirect.java: -------------------------------------------------------------------------------- 1 | package recaf.core.full; 2 | 3 | import static recaf.core.expr.EvalJavaHelper.toValue; 4 | 5 | import recaf.core.alg.JavaMethodAlg; 6 | import recaf.core.alg.JavaStmtOnlyAlg; 7 | import recaf.core.direct.EvalJavaStmt; 8 | import recaf.core.direct.ICase; 9 | import recaf.core.direct.IExec; 10 | import recaf.core.expr.EvalJavaExpr; 11 | 12 | 13 | public interface FullJavaDirect extends JavaStmtAlgAdapter, EvalJavaExpr, JavaMethodAlg { 14 | 15 | @Override 16 | default JavaStmtOnlyAlg base() { 17 | return new EvalJavaStmt() {}; 18 | } 19 | 20 | @SuppressWarnings("unchecked") 21 | @Override 22 | default R Method(IExec body) { 23 | try { 24 | body.exec(null); 25 | } 26 | catch (EvalJavaStmt.Return r) { 27 | return (R) toValue(r.getValue()); 28 | } 29 | catch (Throwable e) { 30 | throw new RuntimeException(e); 31 | } 32 | return null; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/Async.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.Future; 5 | import java.util.function.Function; 6 | 7 | import recaf.core.ISupply; 8 | import recaf.core.alg.JavaMethodAlg; 9 | import recaf.core.cps.EvalJavaStmt; 10 | import recaf.core.cps.SD; 11 | 12 | public interface Async extends EvalJavaStmt, JavaMethodAlg, SD> { 13 | 14 | @Override 15 | default Future Method(SD body) { 16 | CompletableFuture promise = new CompletableFuture(); 17 | 18 | CompletableFuture.supplyAsync(() -> { 19 | body.accept(null, 20 | r -> promise.complete(r), 21 | () -> promise.complete(null), 22 | l -> {throw new AssertionError("cannot break without loop");}, 23 | l -> {throw new AssertionError("cannot break without loop");}, 24 | ex -> promise.completeExceptionally(ex)); 25 | return null; 26 | }); 27 | 28 | return promise; 29 | } 30 | 31 | default SD Await(ISupply> e, Function> body) { 32 | return (label, rho, sigma, brk, contin, err) -> get(e).accept(f -> { 33 | f.whenComplete((a, ex) -> { 34 | if (a == null) { 35 | err.accept(ex); 36 | } else { 37 | body.apply(a).accept(null, rho, sigma, brk, contin, err); 38 | } 39 | }); 40 | } , err); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/AsyncFull.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | 5 | import java.util.concurrent.Future; 6 | import java.util.function.Function; 7 | 8 | import recaf.core.alg.JavaMethodAlg; 9 | import recaf.core.cps.CD; 10 | import recaf.core.cps.SD; 11 | import recaf.core.direct.IEval; 12 | import recaf.core.expr.EvalJavaExpr; 13 | import recaf.core.full.JavaStmtAlgAdapter; 14 | 15 | import static recaf.core.expr.EvalJavaHelper.toValue; 16 | 17 | public interface AsyncFull extends JavaStmtAlgAdapter, CD>, JavaMethodAlg, SD>, EvalJavaExpr { 18 | 19 | @Override 20 | default Async base() { 21 | return new Async() {}; 22 | } 23 | 24 | // Should be in Await interface (?) 25 | default SD Await(IEval e, Function> body) { 26 | return base().Await(() -> (CompletableFuture)toValue(e.eval()), body); 27 | } 28 | 29 | @Override 30 | default Future Method(SD body) { 31 | return base().Method(body); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/Backtrack.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.function.Function; 6 | 7 | import recaf.core.ISupply; 8 | import recaf.core.alg.JavaMethodAlg; 9 | import recaf.core.cps.EvalJavaStmt; 10 | import recaf.core.cps.SD; 11 | 12 | public class Backtrack implements EvalJavaStmt, JavaMethodAlg, SD> { 13 | 14 | @Override 15 | public List Method(SD body) { 16 | List result = new ArrayList<>(); 17 | body.accept(null, ret -> { 18 | result.add(ret); 19 | }, () -> {}, l -> {}, l -> {}, exc -> { throw new RuntimeException(exc); }); 20 | return result; 21 | } 22 | 23 | public SD Choose(ISupply> choices, Function> body) { 24 | return (label, rho, sigma, contin, brk, err) -> { 25 | get(choices).accept(iter -> { 26 | for (T t: iter) { 27 | body.apply(t).accept(null, rho, sigma, contin, brk, err); 28 | } 29 | }, err);; 30 | }; 31 | } 32 | 33 | @Override 34 | public SD Return() { 35 | throw new AssertionError("Cannot not return a value when backtracking"); 36 | } 37 | 38 | 39 | } 40 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/ComeFrom.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | import recaf.core.ISupply; 7 | import recaf.core.cps.K0; 8 | import recaf.core.cps.SD; 9 | import recaf.core.cps.StmtJavaCPS; 10 | 11 | public class ComeFrom implements StmtJavaCPS { 12 | 13 | private final static Map ks = new HashMap<>(); 14 | 15 | public SD ComeFrom(ISupply label) { 16 | return (label0, rho, sigma, brk, contin, err) -> { 17 | get(label).accept(l -> { 18 | ks.put(l, sigma); 19 | sigma.call(); 20 | }, err); 21 | }; 22 | } 23 | 24 | @Override 25 | public SD Labeled(String label, SD s) { 26 | return (label0, rho, sigma, brk, contin, err) -> { 27 | if (ks.containsKey(label)) { 28 | ks.get(label).call(); 29 | return; 30 | } 31 | s.accept(label, rho, sigma, brk, contin, err); 32 | }; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/IterFull.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import recaf.core.alg.JavaMethodAlg; 4 | import recaf.core.cps.CD; 5 | import recaf.core.cps.SD; 6 | import recaf.core.direct.IEval; 7 | import recaf.core.expr.EvalJavaExpr; 8 | import recaf.core.expr.EvalJavaHelper; 9 | import recaf.core.full.JavaStmtAlgAdapter; 10 | import static recaf.core.expr.EvalJavaHelper.toValue; 11 | 12 | public interface IterFull extends JavaStmtAlgAdapter, CD>, JavaMethodAlg, SD>, EvalJavaExpr { 13 | 14 | @Override 15 | default Iter base() { 16 | return new Iter(); 17 | } 18 | 19 | default SD Yield(IEval exp) { 20 | return base().Yield(() -> (U)toValue(exp.eval())); 21 | } 22 | 23 | default SD YieldFrom(IEval exp) { 24 | return base().YieldFrom(() -> (Iterable)toValue(exp.eval())); 25 | } 26 | 27 | @Override 28 | default Iterable Method(SD body) { 29 | Iterable x = base().Method(body); 30 | return (Iterable)toValue(x); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/Maybe.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.Optional; 4 | import java.util.function.Function; 5 | 6 | import recaf.core.ISupply; 7 | import recaf.core.Ref; 8 | import recaf.core.alg.JavaMethodAlg; 9 | import recaf.core.cps.EvalJavaStmt; 10 | import recaf.core.cps.SD; 11 | 12 | 13 | public class Maybe implements EvalJavaStmt, JavaMethodAlg, SD> { 14 | 15 | @Override 16 | public Optional Method(SD body) { 17 | Ref> ref = new Ref>(); 18 | body.accept(null, r -> { ref.value = Optional.of(r); }, 19 | () -> { ref.value = Optional.empty(); }, 20 | l -> { throw new AssertionError("cannot break without loop"); }, 21 | l -> { throw new AssertionError("cannot continue without loop"); }, 22 | exc -> { throw new RuntimeException(exc); }); 23 | return ref.value; 24 | } 25 | 26 | public SD Maybe(ISupply> opt, Function> body) { 27 | return (label, rho, sigma, brk, contin, err) -> get(opt).accept(v -> { 28 | if (v.isPresent()) { 29 | body.apply(v.get()).accept(null, rho, sigma, brk, contin,err); 30 | } 31 | else { 32 | sigma.call(); 33 | } 34 | }, err); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/ParFor.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.Collection; 4 | import java.util.function.Function; 5 | 6 | import recaf.core.ISupply; 7 | import recaf.core.cps.SD; 8 | import recaf.core.cps.StmtJavaCPS; 9 | 10 | public class ParFor implements StmtJavaCPS { 11 | public SD Parfor(ISupply> coll, Function> body) { 12 | return (label, rho, sigma, brk, contin, err) -> { 13 | get(coll).accept(v -> { 14 | v.parallelStream().forEach(u -> { 15 | body.apply(u).accept(null,rho, sigma, brk, contin, err); 16 | }); 17 | }, err); 18 | }; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/cps/Propagate.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.cps; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.function.Function; 5 | 6 | import recaf.core.ISupply; 7 | import recaf.core.cps.SD; 8 | import recaf.core.cps.StmtJavaCPS; 9 | 10 | public class Propagate implements StmtJavaCPS { 11 | // BAD!!! 12 | // non reentrant, only single type... 13 | // but works across ordinary methods... 14 | private static final ArrayDeque stack = new ArrayDeque<>(); 15 | 16 | public SD Local(ISupply exp, SD body) { 17 | return (label, rho, sigma, brk, contin, err) -> { 18 | get(exp).accept(t -> { 19 | stack.push(t); 20 | body.accept(null, r -> { stack.pop(); rho.accept(r);}, 21 | () -> { stack.pop(); sigma.call(); }, 22 | l -> { throw new AssertionError("cannot break without loop"); }, 23 | l -> { throw new AssertionError("cannot continue without loop"); }, 24 | e -> { stack.pop(); err.accept(e); }); 25 | }, err); 26 | }; 27 | } 28 | 29 | @SuppressWarnings("unchecked") 30 | public SD Ask(Function> body) { 31 | return (label, rho, sigma, brk, contin, err) -> { 32 | body.apply((T) stack.peek()).accept(null, rho, sigma, brk, contin, err); 33 | }; 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/App.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | public interface App { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/LINQ.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import java.util.function.BiFunction; 4 | import java.util.function.Function; 5 | import java.util.function.Supplier; 6 | 7 | import recaf.core.direct.EvalJavaStmt; 8 | import recaf.core.direct.IExec; 9 | 10 | public class LINQ implements EvalJavaStmt { 11 | 12 | // 13 | // IExec Where(Supplier c, IExec b) { 14 | // 15 | // } 16 | // 17 | // IExec From(Supplier> c, Function b) { 18 | // 19 | // } 20 | // 21 | // IExec Where(Supplier c, IExec b) { 22 | // 23 | // } 24 | // 25 | // IExec GroupBy(Function b) { 26 | // 27 | // } 28 | // 29 | // IExec Join( BiFunction b) { 30 | // 31 | // } 32 | // 33 | // IExec Select(Supplier t) { 34 | // 35 | // } 36 | } 37 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Logging.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import java.util.logging.Level; 4 | import java.util.logging.Logger; 5 | 6 | import recaf.core.direct.IEval; 7 | import recaf.core.full.FullJavaDirect; 8 | 9 | public interface Logging extends FullJavaDirect { 10 | static Logger logger = Logger.getLogger(FullJavaDirect.class.getCanonicalName()); 11 | 12 | @Override 13 | default IEval Var(String name, Object val){ 14 | return () -> { 15 | Object r = FullJavaDirect.super.Var(name, val).eval(); 16 | logger.log(Level.INFO, "Accessing variable "+name+" => "+r); 17 | return r; 18 | }; 19 | } 20 | 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Maybe.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import java.util.Optional; 4 | import java.util.function.Function; 5 | import java.util.function.Supplier; 6 | 7 | import recaf.core.alg.JavaMethodAlg; 8 | import recaf.core.direct.IExec; 9 | import recaf.core.direct.StmtJavaDirect; 10 | 11 | public class Maybe implements StmtJavaDirect, JavaMethodAlg, IExec> { 12 | 13 | @SuppressWarnings("unchecked") 14 | @Override 15 | public Optional Method(IExec body) { 16 | try { 17 | body.exec(null); 18 | } 19 | catch (Return r) { 20 | return Optional.of((R) r.getValue()); 21 | } 22 | catch (Throwable e) { 23 | throw new RuntimeException(e); 24 | } 25 | return Optional.empty(); 26 | } 27 | 28 | public IExec Maybe(Supplier> opt, Function body) { 29 | return l -> { 30 | Optional v = opt.get(); 31 | if (v.isPresent()) { 32 | body.apply(v.get()).exec(null); 33 | } 34 | }; 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Memo.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import static recaf.core.expr.EvalJavaHelper.toValue; 4 | 5 | import java.util.HashMap; 6 | import java.util.Map; 7 | 8 | import recaf.core.direct.IEval; 9 | import recaf.core.expr.EvalJavaHelper; 10 | import recaf.core.full.FullJavaDirect;; 11 | 12 | public class Memo implements FullJavaDirect { 13 | 14 | private Map map = new HashMap(); 15 | 16 | public Memo(){ 17 | } 18 | 19 | @Override 20 | public IEval Invoke(IEval obj, String method, IEval... args) { 21 | return () -> { 22 | Object evObj = toValue(obj.eval()); 23 | Object[] evArgs = EvalJavaHelper.evaluateArguments(args); 24 | MemoizableCall key = new MemoizableCall(evObj, method, evArgs); 25 | if (!map.containsKey(key)) 26 | map.put(key, (R) FullJavaDirect.super.Invoke(EvalJavaHelper.delayObject(evObj), method, EvalJavaHelper.delayObjects(evArgs)).eval()); 27 | return map.get(key); 28 | }; 29 | } 30 | 31 | } -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/MemoizableCall.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import java.util.Arrays; 4 | import java.util.stream.Stream; 5 | 6 | import org.apache.commons.lang.builder.EqualsBuilder; 7 | import org.apache.commons.lang.builder.HashCodeBuilder; 8 | 9 | public class MemoizableCall { 10 | private Object receiver; 11 | private String methodName; 12 | private Object[] evaluatedArguments; 13 | 14 | public MemoizableCall(Object receiver, String methodName, Object[] evaluatedArguments) { 15 | super(); 16 | this.receiver = receiver; 17 | this.methodName = methodName; 18 | this.evaluatedArguments = evaluatedArguments; 19 | } 20 | 21 | public Object getReceiver() { 22 | return receiver; 23 | } 24 | public String getMethodName() { 25 | return methodName; 26 | } 27 | public Object[] getEvaluatedArguments() { 28 | return evaluatedArguments; 29 | } 30 | 31 | @Override 32 | public String toString(){ 33 | Stream as = Arrays.asList(evaluatedArguments).stream().map(x -> x.toString()); 34 | String args = String.join(", ", (Iterable) as::iterator); 35 | return receiver+"."+methodName+"("+args+")"; 36 | } 37 | 38 | @Override 39 | public boolean equals(Object obj) { 40 | if (!(obj instanceof MemoizableCall)) 41 | return false; 42 | if (obj == this) 43 | return true; 44 | 45 | MemoizableCall rhs = (MemoizableCall) obj; 46 | return new EqualsBuilder(). 47 | // if deriving: appendSuper(super.equals(obj)). 48 | append(receiver, rhs.receiver). 49 | append(methodName, rhs.methodName). 50 | append(evaluatedArguments, rhs.evaluatedArguments). 51 | isEquals(); 52 | } 53 | 54 | @Override 55 | public int hashCode() { 56 | return new HashCodeBuilder(17, 31). // two randomly chosen prime numbers 57 | append(receiver). 58 | append(methodName). 59 | append(evaluatedArguments). 60 | toHashCode(); 61 | } 62 | 63 | } 64 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/OrElse.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import recaf.core.direct.IEval; 4 | import recaf.core.full.FullJavaDirect; 5 | 6 | public interface OrElse extends FullJavaDirect { 7 | 8 | default IEval OrElse(IEval ...es) { 9 | return () -> { 10 | for (int i = 0; i < es.length; i++) { 11 | Object x = es[i].eval(); 12 | if (x != null) { 13 | return x; 14 | } 15 | } 16 | return null; 17 | }; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Policy.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | public interface Policy { 4 | public final int READ = 0; 5 | public final int UPDATE = 1; 6 | boolean check(int op, Object obj, String name); 7 | } 8 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Security.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import static recaf.core.expr.EvalJavaHelper.toValue; 4 | 5 | import recaf.core.direct.IEval; 6 | import recaf.core.expr.ReflectRef; 7 | import recaf.core.full.FullJavaDirect; 8 | 9 | public class Security implements FullJavaDirect { 10 | 11 | private Policy policy; 12 | 13 | public Security(Policy policy) { 14 | this.policy = policy; 15 | } 16 | 17 | @Override 18 | public IEval Field(IEval recv, String name) { 19 | return () -> { 20 | Object obj = recv.eval(); 21 | if (policy.check(Policy.READ, toValue(obj), name)){ 22 | return FullJavaDirect.super.Field(() -> obj, name).eval(); 23 | } 24 | else 25 | return null; 26 | }; 27 | } 28 | 29 | @Override 30 | public IEval Assign(IEval lhs, IEval rhs) { 31 | return () -> { 32 | Object obj = lhs.eval(); 33 | if (obj instanceof ReflectRef){ 34 | String fldName = ((ReflectRef) obj).getFieldName(); 35 | Object recv = ((ReflectRef) obj).getObject(); 36 | if (policy.check(Policy.UPDATE, toValue(recv), fldName)){ 37 | return FullJavaDirect.super.Assign(() -> obj, rhs).eval(); 38 | } 39 | else 40 | return null; 41 | } 42 | else 43 | return FullJavaDirect.super.Assign(() -> obj, rhs).eval(); 44 | }; 45 | } 46 | 47 | 48 | 49 | } -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Student.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | public class Student { 4 | public String name; 5 | public String grade; 6 | public int section; 7 | 8 | public Student(String name, String grade, int section) { 9 | super(); 10 | this.name = name; 11 | this.grade = grade; 12 | this.section = section; 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/StudentPolicy.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | public class StudentPolicy implements Policy{ 4 | 5 | @Override 6 | public boolean check(int op, Object obj, String name) { 7 | if (op == Policy.READ){ 8 | if (obj instanceof Student){ 9 | return ((Student) obj).grade != "F"; 10 | } 11 | } 12 | else if (op == Policy.UPDATE){ 13 | if (obj instanceof Student){ 14 | return ((Student) obj).section == 1; 15 | } 16 | } 17 | return true; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/direct/Using.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.direct; 2 | 3 | import java.io.Closeable; 4 | import java.util.function.Function; 5 | 6 | import recaf.core.ISupply; 7 | import recaf.core.direct.IExec; 8 | import recaf.core.full.FullJavaDirect; 9 | 10 | public interface Using extends FullJavaDirect { 11 | 12 | default IExec Using(ISupply resource, Function body) { 13 | return l -> { 14 | U u = null; 15 | try { 16 | u = resource.get(); 17 | body.apply(u).exec(null); 18 | } 19 | finally { 20 | if (u != null) { 21 | u.close(); 22 | } 23 | } 24 | }; 25 | } 26 | 27 | // more generic 28 | // public interface Using extends FullJavaDirect { 29 | // 30 | // default S Using(ISupply resource, Function body) { 31 | // return (S) new IExec() { 32 | // @Override 33 | // public void exec(String label) throws Throwable { 34 | // 35 | // U u = null; 36 | // try { 37 | // u = resource.get(); 38 | // body.apply(u).exec(null); 39 | // } 40 | // finally { 41 | // if (u != null) { 42 | // u.close(); 43 | // } 44 | // } 45 | // 46 | // }}; 47 | // } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/generic/Times.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.generic; 2 | 3 | import java.util.Iterator; 4 | import java.util.function.Supplier; 5 | import java.util.stream.IntStream; 6 | 7 | import recaf.core.alg.JavaStmtOnlyAlg; 8 | 9 | public interface Times extends JavaStmtOnlyAlg { 10 | 11 | static Iterable range(Integer n) { 12 | return new Iterable() { 13 | @Override 14 | public Iterator iterator() { 15 | return IntStream.range(0, n).iterator(); 16 | } 17 | }; 18 | 19 | } 20 | 21 | default S Times(Supplier exp, S body) { 22 | return ForEach(() -> range(exp.get()), ignored -> body); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/generic/Unless.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.generic; 2 | import java.util.function.Supplier; 3 | 4 | import recaf.core.alg.JavaStmtOnlyAlg; 5 | 6 | public interface Unless extends JavaStmtOnlyAlg { 7 | default S Unless(Supplier cond, S body) { 8 | return If(() -> !cond.get(), body); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/generic/Until.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.generic; 2 | 3 | import java.util.function.Supplier; 4 | 5 | import recaf.core.alg.JavaStmtOnlyAlg; 6 | 7 | public interface Until extends JavaStmtOnlyAlg { 8 | 9 | default S Until(Supplier cond, S body) { 10 | return DoWhile(body, () -> !cond.get()); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/pegs/Fail.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.pegs; 2 | 3 | public class Fail extends RuntimeException { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/pegs/MemoPEG.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.pegs; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | public class MemoPEG implements PEG { 7 | private final Map> memo = new HashMap<>(); 8 | 9 | // TODO: make a generic memo aspect. 10 | 11 | @Override 12 | public Parser Method(Parser body) { 13 | Parser parser = PEG.super.Method(body); 14 | return (s, p) -> { 15 | if (!memo.containsKey(p)) { 16 | memo.put(p, parser.parse(s, p)); 17 | } 18 | return memo.get(p); 19 | }; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/pegs/PEGwithLayout.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.pegs; 2 | 3 | import java.util.function.Function; 4 | import java.util.function.Supplier; 5 | import java.util.regex.Matcher; 6 | import java.util.regex.Pattern; 7 | 8 | // here it shows that Java 8 interfaces are not true mixins (abstract super classes) 9 | // the calls to super are always bound to concrete super interfaces; as a result 10 | // this PEgwithLayout cannot be used with MemoPEG... 11 | public class PEGwithLayout implements PEG { 12 | 13 | /* 14 | * Puts layout before tokens (regexp/lit) and inbetween sequences. 15 | */ 16 | 17 | private Parser layout; 18 | 19 | public PEGwithLayout(String regexp) { 20 | Pattern pat = Pattern.compile(regexp); 21 | this.layout = (s, p) -> { 22 | Matcher m = pat.matcher(s.substring(p)); 23 | if (m.find() && m.start() == 0) { 24 | return new Result(null, p + m.group().length()); 25 | } 26 | throw new Fail(); 27 | }; 28 | } 29 | 30 | Function> withLayout(Function> parser) { 31 | return it -> (s, p) -> { 32 | Result r = layout.parse(s, p); 33 | Result r2 = parser.apply(it).parse(s, r.getPos()); 34 | return new Result(r2.getValue(), r2.getPos()); 35 | }; 36 | } 37 | 38 | @Override 39 | public Parser Regexp(Supplier x, Function> body) { 40 | return PEG.super.Regexp(x, withLayout(body)); 41 | } 42 | 43 | 44 | @Override 45 | public Parser Lit(Supplier x) { 46 | return Seq(layout, PEG.super.Lit(x)); 47 | } 48 | 49 | @Override 50 | public 51 | //BEGIN_SEQ_LAYOUT 52 | Parser Seq(Parser p1, Parser p2) { 53 | return PEG.super.Seq(p1, PEG.super.Seq(layout, p2)); 54 | } 55 | //END_SEQ_LAYOUT 56 | 57 | 58 | } 59 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/pegs/Parser.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.pegs; 2 | 3 | public interface Parser { 4 | Result parse(String src, int pos); 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/pegs/Result.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.pegs; 2 | 3 | public class Result { 4 | private T val; 5 | private int pos; 6 | 7 | Result(T val, int pos) { 8 | this.val = val; 9 | this.pos = pos; 10 | } 11 | 12 | public T getValue() { 13 | return val; 14 | } 15 | 16 | public int getPos() { 17 | return pos; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/demo/web/Web.java: -------------------------------------------------------------------------------- 1 | package recaf.demo.web; 2 | 3 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/access/Policy.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.access; 2 | 3 | //BEGIN_POLICY 4 | public interface Policy { 5 | boolean isAllowed(Object obj, String name); 6 | } 7 | //END_POLICY -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/access/Security.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.access; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.MuExpJavaBase; 5 | import recaf.paper.full.MuStmIEvalJavaAdapter; 6 | import recaf.paper.full.MuStmJavaManualAdapter; 7 | import recaf.paper.methods.TPDirect; 8 | import recaf.paper.stm.IExec; 9 | import recaf.paper.stm.MuJava; 10 | import recaf.paper.stm.MuJavaBase; 11 | 12 | public class Security implements TPDirect, MuStmIEvalJavaAdapter, MuExpJavaBase { 13 | 14 | @Override 15 | public MuJava base() { 16 | return new MuJavaBase() { 17 | }; 18 | } 19 | 20 | public Security(Policy policy) { 21 | this.policy = policy; 22 | } 23 | 24 | // BEGIN_SECURITY 25 | private Policy policy; 26 | 27 | @Override 28 | public IEval Field(IEval x, String f) { 29 | return () -> { 30 | Object obj = x.eval(); 31 | if (policy.isAllowed(obj, f)) { 32 | return MuExpJavaBase.super.Field(() -> obj, f).eval(); 33 | } 34 | return null; 35 | }; 36 | } 37 | // END_SECURITY 38 | } 39 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/access/StudentPolicy.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.access; 2 | 3 | import recaf.demo.direct.Student; 4 | 5 | //BEGIN_STUDENT_POLICY 6 | public class StudentPolicy implements Policy { 7 | @Override 8 | public boolean isAllowed(Object obj, String fldName) { 9 | if (obj instanceof Student) 10 | return ((Student) obj).grade != "F"; 11 | return true; 12 | } 13 | } 14 | //END_STUDENT_POLICY -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Backtrack.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.function.Function; 6 | import java.util.function.Supplier; 7 | 8 | import recaf.paper.methods.MuJavaMethod; 9 | import recaf.paper.stm.MuJavaCPS; 10 | import recaf.paper.stm.SD; 11 | 12 | //BEGIN_BACKTRACK 13 | interface Backtrack 14 | extends MuJavaCPS, MuJavaMethod, SD> { 15 | 16 | default List Method(SD body) { 17 | List result = new ArrayList<>(); 18 | body.accept(ret -> { result.add(ret); }, () -> {}); 19 | return result; 20 | } 21 | 22 | default SD Choose(Supplier> e, 23 | Function> s) { 24 | return (r, s0) -> { 25 | for (T t: e.get()) s.apply(t).accept(r, s0);}; 26 | } 27 | } 28 | //END_BACKTRACK 29 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/BacktrackFull.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.function.Function; 4 | 5 | import recaf.paper.expr.IEval; 6 | import recaf.paper.full.FullMuJavaCPS; 7 | import recaf.paper.stm.SD; 8 | 9 | public 10 | //BEGIN_BACKTRACK_FULL 11 | interface BacktrackFull extends FullMuJavaCPS { 12 | default Backtrack base() { 13 | return new Backtrack() {}; 14 | } 15 | default SD Choose(IEval e, Function> body){ 16 | return base().Choose(adapt(e), body); 17 | } 18 | } 19 | //END_BACKTRACK_FULL -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Debug.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.Pair; 5 | import recaf.paper.expr.PrintAndEval; 6 | import recaf.paper.full.MuStmPrintEvalAdapter; 7 | import recaf.paper.methods.TPDirect; 8 | import recaf.paper.stm.IExec; 9 | import recaf.paper.stm.MuJava; 10 | import recaf.paper.stm.MuJavaBase; 11 | 12 | public class Debug implements MuStmPrintEvalAdapter, PrintAndEval, TPDirect { 13 | 14 | @Override 15 | public MuJava base() { 16 | return new MuJavaBase() { 17 | }; 18 | } 19 | 20 | public 21 | //BEGIN_DEBUG 22 | IExec Debug(Pair e) { 23 | return () -> System.err.println("DEBUG: " + e.snd 24 | + " => " + e.fst.eval()); 25 | } 26 | //END_DEBUG 27 | } -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/GUI.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.function.Supplier; 4 | 5 | import recaf.paper.stm.IExec; 6 | import recaf.paper.stm.MuJavaBase; 7 | 8 | //BEGIN_GUI_ALG 9 | interface GUI extends MuJavaBase { 10 | IExec Tag(Supplier t, IExec b); 11 | IExec Button(Supplier l, IExec b); 12 | IExec Echo(Supplier x); 13 | } 14 | //END_GUI_ALG -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Goto.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.function.Supplier; 6 | 7 | import recaf.core.cps.K0; 8 | import recaf.paper.stm.MuJavaCPS; 9 | import recaf.paper.stm.SD; 10 | 11 | // Only support jumping backwards. 12 | 13 | //BEGIN_GOTO 14 | interface Goto extends MuJavaCPS { 15 | static Map labeled = new HashMap<>(); 16 | 17 | default SD Label(Supplier l, SD s) { 18 | return (r, s0) -> { 19 | labeled.put(l.get(), () -> s.accept(r, s0)); 20 | s.accept(r, s0); 21 | }; 22 | } 23 | 24 | default SD Go(Supplier l) { 25 | return (r, s) -> labeled.get(l).call(); 26 | } 27 | } 28 | //END_GOTO -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/HTTPRequest.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | public class HTTPRequest { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/HTTPResponse.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | public class HTTPResponse { 4 | private HTTPRequest req; 5 | private String js; 6 | 7 | public HTTPResponse(HTTPRequest req, String js) { 8 | this.req = req; 9 | this.js = js; 10 | } 11 | 12 | public String getJs() { 13 | return js; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Maybe.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.Optional; 4 | import java.util.function.Function; 5 | import java.util.function.Supplier; 6 | 7 | import recaf.paper.stm.IExec; 8 | import recaf.paper.stm.MuJavaBase; 9 | 10 | //BEGIN_MAYBE 11 | interface Maybe extends MuJavaBase { 12 | default IExec Maybe(Supplier> x, 13 | Function s) { 14 | return () -> { 15 | Optional opt = x.get(); 16 | if (opt.isPresent()) s.apply(opt.get()).exec(); }; 17 | } 18 | } 19 | //END_MAYBE 20 | 21 | class Test2 { 22 | public static void main(String[] args) { 23 | new Maybe() {}; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Memo.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | import java.util.stream.IntStream; 8 | 9 | import recaf.paper.expr.IEval; 10 | import recaf.paper.expr.MuExpJavaBase; 11 | 12 | interface Memo extends MuExpJavaBase { 13 | 14 | static List eval(IEval... es) { 15 | List lst = new ArrayList<>(es.length); 16 | for (int i = 0; i < es.length; i++) { 17 | lst.add(es[i].eval()); 18 | } 19 | return lst; 20 | } 21 | 22 | static IEval[] uneval(List vs) { 23 | IEval[] es = new IEval[vs.size()]; 24 | IntStream.range(0, vs.size()).forEach(i -> { 25 | es[i] = () -> vs.get(i + 2); 26 | }); 27 | return es; 28 | } 29 | 30 | // BEGIN_MEMO 31 | static Map, Object> memo = new HashMap<>(); 32 | 33 | default IEval Invoke(IEval x, String m, IEval... es) { 34 | return () -> { 35 | List key = new ArrayList<>(); 36 | key.add(x.eval()); 37 | key.add(m); 38 | List vs = eval(es); 39 | key.addAll(vs); 40 | if (!memo.containsKey(key)) { 41 | Object val = MuExpJavaBase.super.Invoke(() -> key.get(0), m, uneval(vs)).eval(); 42 | memo.put(key, val); 43 | } 44 | return memo.get(key); 45 | }; 46 | } 47 | // END_MEMO 48 | } 49 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/OrElse.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.MuExpJavaBase; 5 | import recaf.paper.full.MuStmIEvalJavaAdapter; 6 | import recaf.paper.full.MuStmJavaManualAdapter; 7 | import recaf.paper.stm.IExec; 8 | 9 | public interface OrElse extends MuStmIEvalJavaAdapter, MuExpJavaBase { 10 | //BEGIN_ORELSE 11 | default IEval OrElse(IEval ...es) { 12 | return () -> { 13 | for (IEval e: es) { 14 | Object x = e.eval(); 15 | if (x != null) return x; 16 | } 17 | return null; 18 | }; 19 | } 20 | //END_ORELSE 21 | } 22 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Times.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.Iterator; 4 | import java.util.function.Function; 5 | import java.util.function.Supplier; 6 | import java.util.stream.IntStream; 7 | 8 | import recaf.paper.stm.MuJava; 9 | 10 | public interface Times extends MuJava { 11 | static Iterable range(Integer n) { 12 | return new Iterable() { 13 | @Override 14 | public Iterator iterator() { 15 | return IntStream.range(0, n).iterator(); 16 | } 17 | }; 18 | } 19 | 20 | default S Times(Supplier n, S s) { 21 | return For(() -> range(n.get()), ignored -> s); 22 | } 23 | 24 | default 25 | //BEGIN_TIMES 26 | S Times(Supplier n, Function s) { 27 | return For(() -> range(n.get()), s); 28 | } 29 | //END_TIMES 30 | 31 | } 32 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Tracing.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.MuExpJavaBase; 5 | 6 | public 7 | interface Tracing extends MuExpJavaBase { 8 | //BEGIN_TRACING 9 | default IEval Var(String x, Object v){ 10 | return () -> { 11 | System.err.println(x + " = " + v); 12 | return MuExpJavaBase.super.Var(x, v).eval(); 13 | }; 14 | } 15 | //END_TRACING 16 | } 17 | 18 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/Unless.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo; 2 | 3 | import java.util.function.Supplier; 4 | 5 | import recaf.paper.stm.MuJava; 6 | 7 | public 8 | //BEGIN_UNLESS 9 | interface Unless extends MuJava { 10 | default S Unless(Supplier c, S s) { 11 | return If(() -> !c.get(), s, Empty()); 12 | } 13 | } 14 | //END_UNLESS 15 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Decl.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Decl extends Stm { 4 | private String x; 5 | private Expr init; 6 | private Stm body; 7 | 8 | public Decl(String x, Expr init, Stm body) { 9 | this.x = x; 10 | this.init = init; 11 | this.body = body; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Empty.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Empty extends Stm { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Exp.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Exp extends Stm { 4 | private Expr exp; 5 | 6 | public Exp(Expr exp) { 7 | this.exp = exp; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Expr.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public abstract class Expr { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Field.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Field extends Expr { 4 | private Expr exp; 5 | private String field; 6 | 7 | public Field(Expr exp, String field) { 8 | this.exp = exp; 9 | this.field = field; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/For.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class For extends Stm { 4 | private String x; 5 | private Expr init; 6 | private Stm body; 7 | 8 | public For(String x, Expr init, Stm body) { 9 | this.x = x; 10 | this.init = init; 11 | this.body = body; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/If.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class If extends Stm { 4 | private Expr cond; 5 | private Stm s1; 6 | private Stm s2; 7 | 8 | public If(Expr cond, Stm s1, Stm s2) { 9 | this.cond = cond; 10 | this.s1 = s1; 11 | this.s2 = s2; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Invoke.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Invoke extends Expr { 4 | private Expr recv; 5 | private String method; 6 | private Expr[] args; 7 | 8 | public Invoke(Expr recv, String method, Expr ...args) { 9 | this.recv = recv; 10 | this.method = method; 11 | this.args = args; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Lambda.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Lambda extends Expr { 4 | private Object lambda; 5 | private String[] params; 6 | private Stm body; 7 | 8 | public Lambda(String[] params, Stm body) { 9 | this.params = params; 10 | this.body = body; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Lit.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Lit extends Expr { 4 | private Object x; 5 | 6 | public Lit(Object x) { 7 | this.x = x; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/New.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class New extends Expr { 4 | private Class klass; 5 | private Expr[] args; 6 | 7 | public New(Class klass, Expr ...es) { 8 | this.klass = klass; 9 | this.args = es; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Return.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Return extends Stm { 4 | private Expr exp; 5 | 6 | public Return(Expr exp) { 7 | this.exp = exp; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Seq.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Seq extends Stm { 4 | private Stm s1; 5 | private Stm s2; 6 | 7 | public Seq(Stm s1, Stm s2) { 8 | this.s1 = s2; 9 | this.s2 = s2; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Stm.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public abstract class Stm { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/This.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class This extends Expr { 4 | private Object it; 5 | 6 | public This(Object it) { 7 | this.it = it; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/demo/ast/Var.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.demo.ast; 2 | 3 | public class Var extends Expr { 4 | private String name; 5 | private Object it; 6 | 7 | public Var(String name, Object it) { 8 | this.name = name; 9 | this.it = it; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/IEval.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | public 4 | //BEGIN_IEVAL 5 | interface IEval { Object eval(); } 6 | //END_IEVAL 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/MuExpJava.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | @SuppressWarnings("unchecked") 4 | public 5 | //BEGIN_MUEXPJAVA 6 | interface MuExpJava { 7 | E Lit(Object x); 8 | E This(Object x); 9 | E Field(E x, String f); 10 | E New(Class c, E...es); 11 | E Invoke(E x, String m, E...es); 12 | E Lambda(Object f); 13 | E Var(String x, Object it); 14 | } 15 | //END_MUEXPJAVA 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/MuExpJavaBase.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | import java.lang.reflect.Constructor; 4 | import java.lang.reflect.Method; 5 | 6 | //BEGIN_MUEXPJAVA_IMPL 7 | public interface MuExpJavaBase extends MuExpJava { 8 | @Override 9 | default IEval Lit(Object x) { 10 | return () -> x; 11 | } 12 | 13 | @Override 14 | default IEval This(Object x) { 15 | return () -> x; 16 | } 17 | 18 | @Override 19 | default IEval Field(IEval x, String f) { 20 | return () -> { 21 | Object o = x.eval(); 22 | Class clazz = o.getClass(); 23 | try { 24 | return clazz.getField(f).get(o); 25 | } catch (Exception e) { 26 | throw new RuntimeException(e); 27 | } 28 | }; 29 | } 30 | 31 | static Object[] evalArgs(IEval[] es) { 32 | Object[] args = new Object[es.length]; 33 | for (int i = 0; i < es.length; i++) 34 | args[i] = es[i].eval(); 35 | return args; 36 | } 37 | 38 | @Override 39 | default IEval New(Class c, IEval... es) { 40 | return () -> { 41 | Object[] args = evalArgs(es); 42 | for (Constructor cons : c.getDeclaredConstructors()) 43 | try { 44 | return cons.newInstance(args); 45 | } catch (Exception e) { 46 | continue; 47 | } 48 | throw new RuntimeException("no constructor"); 49 | }; 50 | } 51 | 52 | @Override 53 | default IEval Invoke(IEval x, String m, IEval... es) { 54 | return () -> { 55 | Object recv = x.eval(); 56 | Object[] args = evalArgs(es); 57 | for (Method method: recv.getClass().getMethods()) 58 | if (m.equals(method.getName())) 59 | try { 60 | return method.invoke(recv, args); 61 | } catch (Exception e) { 62 | continue; 63 | } 64 | throw new RuntimeException("no such method " + m); 65 | }; 66 | } 67 | 68 | @Override 69 | default IEval Lambda(Object f) { 70 | return () -> f; 71 | } 72 | 73 | @Override 74 | default IEval Var(String x, Object it) { 75 | return () -> it; 76 | } 77 | 78 | } 79 | //END_MUEXPJAVA_IMPL -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/Pair.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | public class Pair { 4 | public final T fst; 5 | public final U snd; 6 | public Pair(T t, U u) { 7 | this.fst = t; 8 | this.snd = u; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/Print.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | import java.lang.reflect.InvocationTargetException; 4 | import java.lang.reflect.Method; 5 | import java.lang.reflect.Parameter; 6 | import java.util.Arrays; 7 | 8 | public 9 | interface Print extends MuExpJava { 10 | @Override 11 | default String Lit(Object x) { 12 | return x.toString(); 13 | } 14 | 15 | @Override 16 | default String This(Object x) { 17 | return "this"; 18 | } 19 | 20 | @Override 21 | default String Field(String x, String f) { 22 | return x + "." + f; 23 | } 24 | 25 | @Override 26 | default String New(Class c, String... es) { 27 | return "new " + c.getName() + "(" + String.join(", ", es) + ")"; 28 | } 29 | 30 | @Override 31 | default String Invoke(String x, String m, String... es) { 32 | return x + "." + m + "(" + String.join(", ", es) + ")"; 33 | } 34 | 35 | @Override 36 | default String Lambda(Object f) { 37 | return "(" + getFormals(f) + ") -> " + callClosure(f); 38 | } 39 | 40 | static String callClosure(Object f) { 41 | for (Method m: f.getClass().getDeclaredMethods()) { 42 | Object[] args = new Object[m.getParameterCount()]; 43 | Arrays.fill(args, null); 44 | try { 45 | return (String)m.invoke(f, args); 46 | } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { 47 | throw new RuntimeException(e); 48 | } 49 | } 50 | return null; 51 | } 52 | 53 | static String getFormals(Object f) { 54 | String formals = ""; 55 | for (Method m: f.getClass().getDeclaredMethods()) { 56 | for (Parameter p: m.getParameters()) { 57 | formals += p.getType().getName() + " " + p.getName() + ", "; 58 | } 59 | if (!formals.isEmpty()) { 60 | return formals.substring(0, formals.length() - 2); 61 | } 62 | return formals; 63 | } 64 | return null; 65 | } 66 | 67 | @Override 68 | default String Var(String x, Object it) { 69 | return x; 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/PrintAndEval.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | public interface PrintAndEval extends MuExpJavaZip { 4 | @Override 5 | default MuExpJava alg1() { 6 | return new MuExpJavaBase() { }; 7 | } 8 | @Override 9 | default MuExpJava alg2() { 10 | return new Print() { }; 11 | } 12 | 13 | @Override 14 | default Class class1() { 15 | return IEval.class; 16 | } 17 | 18 | @Override 19 | default Class class2() { 20 | return String.class; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/expr/PrintAndEvalManual.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.expr; 2 | 3 | public interface PrintAndEvalManual extends MuExpJava> { 4 | static MuExpJavaBase e = new MuExpJavaBase() { }; 5 | static Print p = new Print() { }; 6 | 7 | @Override 8 | default Pair Lit(Object x) { 9 | return new Pair<>(e.Lit(x), p.Lit(x)); 10 | } 11 | 12 | @Override 13 | default Pair This(Object x) { 14 | return new Pair<>(e.This(x), p.This(x)); 15 | } 16 | 17 | @Override 18 | default Pair Field(Pair x, String f) { 19 | return new Pair<>(e.Field(x.fst, f), p.Field(x.snd, f)); 20 | } 21 | 22 | @Override 23 | default Pair New(Class c, Pair... es) { 24 | IEval[] es2 = new IEval[es.length]; 25 | String[] ss = new String[es.length]; 26 | for (int i = 0; i < es.length; i++) { 27 | es2[i] = es[i].fst; 28 | ss[i] = es[i].snd; 29 | } 30 | return new Pair<>(e.New(c, es2), p.New(c, ss)); 31 | } 32 | 33 | @Override 34 | default Pair Invoke(Pair x, String m, Pair... es) { 35 | IEval[] es2 = new IEval[es.length]; 36 | String[] ss = new String[es.length]; 37 | for (int i = 0; i < es.length; i++) { 38 | es2[i] = es[i].fst; 39 | ss[i] = es[i].snd; 40 | } 41 | return new Pair<>(e.Invoke(x.fst, m, es2), p.Invoke(x.snd, m, ss)); 42 | } 43 | 44 | @Override 45 | default Pair Lambda(Object f) { 46 | return new Pair<>(e.Lambda(f), p.Lambda(f)); 47 | } 48 | 49 | @Override 50 | default Pair Var(String x, Object it) { 51 | return new Pair<>(e.Var(x, it), p.Var(x, it)); 52 | } 53 | 54 | } 55 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/FullMuJava.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import recaf.paper.expr.MuExpJava; 4 | 5 | //BEGIN_FULLMUJAVA 6 | public interface FullMuJava 7 | extends MuStmJava, MuExpJava { } 8 | //END_FULLMUJAVA 9 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/FullMuJavaCPS.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.MuExpJavaBase; 5 | import recaf.paper.stm.MuJava; 6 | import recaf.paper.stm.MuJavaCPS; 7 | import recaf.paper.stm.SD; 8 | 9 | public interface FullMuJavaCPS extends FullMuJava, IEval>, MuStmIEvalJavaAdapter>, MuExpJavaBase { 10 | @Override 11 | default MuJava> base() { 12 | return new MuJavaCPS() {}; 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/FullMuJavaCPSManual.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.expr.MuExpJavaBase; 5 | import recaf.paper.stm.MuJavaCPS; 6 | import recaf.paper.stm.SD; 7 | 8 | public interface FullMuJavaCPSManual extends FullMuJava, IEval>, MuStmJavaManualAdapter>, MuExpJavaBase { 9 | @Override 10 | default MuJavaCPS base() { 11 | return new MuJavaCPS() { }; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/FullMuJavaDirect.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.stm.IExec; 5 | import recaf.paper.stm.MuJava; 6 | import recaf.paper.stm.MuJavaBase; 7 | 8 | public interface FullMuJavaDirect extends FullMuJava, MuStmIEvalJavaAdapter { 9 | @Override 10 | default MuJava base() { 11 | return new MuJavaBase() {}; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/FullMuJavaDirectManual.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import recaf.paper.expr.IEval; 4 | import recaf.paper.stm.IExec; 5 | import recaf.paper.stm.MuJava; 6 | import recaf.paper.stm.MuJavaBase; 7 | 8 | public interface FullMuJavaDirectManual extends FullMuJava, MuStmJavaManualAdapter { 9 | @Override 10 | default MuJava base() { 11 | return new MuJavaBase() {}; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/MuStmIEvalJavaAdapter.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import java.util.function.Supplier; 4 | 5 | import recaf.paper.expr.IEval; 6 | 7 | public 8 | //BEGIN_IEVAL_ADAPTER 9 | interface MuStmIEvalJavaAdapter 10 | extends MuStmJavaAdapter { 11 | 12 | default Supplier adapt(IEval e) { 13 | return () -> { return (T) e.eval(); }; 14 | } 15 | } 16 | //END_IEVAL_ADAPTER 17 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/MuStmJava.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import java.util.function.Function; 4 | 5 | public 6 | //BEGIN_MUSTMJAVA 7 | interface MuStmJava { 8 | S Exp(E x); 9 | S Decl(E x,Function s); 10 | S For(E x,Function s); 11 | S If(E c, S s1, S s2); 12 | S Return(E x); 13 | S Seq(S s1, S s2); 14 | S Empty(); 15 | } 16 | //END_MUSTMJAVA -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/MuStmJavaAdapter.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import java.util.function.Function; 4 | import java.util.function.Supplier; 5 | 6 | import recaf.paper.stm.MuJava; 7 | 8 | //BEGIN_MU_STM_GENERIC_ADAPTER 9 | public interface MuStmJavaAdapter extends MuStmJava { 10 | MuJava base(); 11 | 12 | Supplier adapt(E e); 13 | 14 | @Override 15 | default S Exp(E e) { 16 | return base().Exp(adapt(e)); 17 | } 18 | 19 | @Override 20 | default S Decl(E x, Function s) { 21 | return base().Decl(adapt(x), s); 22 | } 23 | 24 | @Override 25 | default S For(E e, Function s) { 26 | return base().For(adapt(e), s); 27 | } 28 | 29 | @Override 30 | default S If(E c, S s1, S s2) { 31 | return base().If(adapt(c), s1, s2); 32 | } 33 | 34 | @Override 35 | default S Return(E e) { 36 | return base().Return(adapt(e)); 37 | } 38 | 39 | @Override 40 | default S Seq(S s1, S s2) { 41 | return base().Seq(s1, s2); 42 | } 43 | 44 | @Override 45 | default S Empty() { 46 | return base().Empty(); 47 | } 48 | } 49 | //END_MU_STM_GENERIC_ADAPTER 50 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/MuStmJavaManualAdapter.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import java.util.function.Function; 4 | 5 | import recaf.paper.expr.IEval; 6 | import recaf.paper.stm.MuJava; 7 | 8 | //BEGIN_MU_STM_ADAPTER 9 | public interface MuStmJavaManualAdapter extends MuStmJava { 10 | MuJava base(); 11 | 12 | static T eval(IEval e) { 13 | try { return (T) e.eval(); } 14 | catch (Throwable t) {throw new RuntimeException(t);} 15 | } 16 | 17 | @Override 18 | default S Exp(IEval e) { 19 | return base().Exp(() -> { eval(e); return null;}); 20 | } 21 | 22 | @Override 23 | default S Decl(IEval x, Function s) { 24 | return base().Decl(() -> eval(x), s); 25 | } 26 | 27 | @Override 28 | default S For(IEval e, Function s) { 29 | return base().For(() -> (Iterable) eval(e), s); 30 | } 31 | 32 | @Override 33 | default S If(IEval c, S s1, S s2) { 34 | return base().If(() -> eval(c), s1, s2); 35 | } 36 | 37 | @Override 38 | default S Return(IEval e) { 39 | return base().Return(() -> eval(e)); 40 | } 41 | 42 | @Override 43 | default S Seq(S s1, S s2) { 44 | return base().Seq(s1, s2); 45 | } 46 | 47 | @Override 48 | default S Empty() { 49 | return base().Empty(); 50 | } 51 | } 52 | //END_MU_STM_ADAPTER 53 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/full/MuStmPrintEvalAdapter.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.full; 2 | 3 | import java.util.function.Function; 4 | 5 | import recaf.paper.expr.IEval; 6 | import recaf.paper.expr.Pair; 7 | import recaf.paper.stm.MuJava; 8 | 9 | public interface MuStmPrintEvalAdapter extends MuStmJava> { 10 | MuJava base(); 11 | 12 | static T adapt(Pair e) { 13 | try { return (T) e.fst.eval(); } 14 | catch (Throwable t) {throw new RuntimeException(t);} 15 | } 16 | 17 | @Override 18 | default S Exp(Pair e) { 19 | return base().Exp(() -> { adapt(e); return null;}); 20 | } 21 | 22 | @Override 23 | default S Decl(Pair x, Function s) { 24 | return base().Decl(() -> adapt(x), s); 25 | } 26 | 27 | @Override 28 | default S For(Pair e, Function s) { 29 | return base().For(() -> (Iterable) adapt(e), s); 30 | } 31 | 32 | @Override 33 | default S If(Pair c, S s1, S s2) { 34 | return base().If(() -> adapt(c), s1, s2); 35 | } 36 | 37 | @Override 38 | default S Return(Pair e) { 39 | return base().Return(() -> adapt(e)); 40 | } 41 | 42 | @Override 43 | default S Seq(S s1, S s2) { 44 | return base().Seq(s1, s2); 45 | } 46 | 47 | @Override 48 | default S Empty() { 49 | return base().Empty(); 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/methods/MuJavaMethod.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.methods; 2 | 3 | public 4 | //BEGIN_MU_METHOD_ALG 5 | interface MuJavaMethod { R Method(S s); } 6 | //END_MU_METHOD_ALG -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/methods/TPCPS.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.methods; 2 | 3 | import recaf.paper.stm.SD; 4 | 5 | public interface TPCPS { 6 | default R Method(SD s) { 7 | R r[] = (R[]) new Object[1]; 8 | s.accept(v -> r[0] = v, () -> {}); 9 | return r[0]; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/methods/TPDirect.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.methods; 2 | 3 | import recaf.paper.stm.IExec; 4 | import recaf.paper.stm.Return; 5 | 6 | public interface TPDirect { 7 | //BEGIN_TYPE_PRESERVING_METHOD 8 | default R Method(IExec s) { 9 | try { s.exec(); } 10 | catch (Return r) { return (R)r.value; } 11 | catch (Throwable e) { throw new RuntimeException(e); } 12 | return null; 13 | } 14 | //END_TYPE_PRESERVING_METHOD 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/methods/ToOptional.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.methods; 2 | 3 | import java.util.Optional; 4 | 5 | import recaf.paper.stm.IExec; 6 | import recaf.paper.stm.Return; 7 | 8 | public 9 | //BEGIN_TO_OPTIONAL 10 | interface ToOptional { 11 | default Optional Method(IExec s) { 12 | try { s.exec(); } 13 | catch (Return r) { return Optional.of((R)r.value); } 14 | catch (Throwable e) { throw new RuntimeException(e); } 15 | return Optional.empty(); 16 | } 17 | } 18 | //END_TO_OPTIONAL 19 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/IExec.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | public 4 | //BEGIN_IEXEC 5 | interface IExec { void exec(); } 6 | //END_IEXEC 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/MuJava.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | import java.util.function.Function; 4 | import java.util.function.Supplier; 5 | 6 | public 7 | //BEGIN_MUJAVA_ALG 8 | interface MuJava { 9 | S Exp(Supplier e); 10 | S If(Supplier c, S s1, S s2); 11 | S For(Supplier> e, Function s); 12 | S Decl(Supplier e, Function s); 13 | S Seq(S s1, S s2); 14 | S Return(Supplier e); 15 | S Empty(); 16 | } 17 | //END_MUJAVA_ALG 18 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/MuJavaBase.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | import java.util.function.Function; 4 | import java.util.function.Supplier; 5 | 6 | //BEGIN_MUJAVA_IMPL 7 | public interface MuJavaBase extends MuJava { 8 | default IExec Exp(Supplier e) { 9 | return () -> { e.get(); }; 10 | } 11 | 12 | default IExec Decl(Supplier e, Function s) { 13 | return () -> s.apply(e.get()).exec(); 14 | } 15 | 16 | default IExec For(Supplier> e, Function s) { 17 | return () -> { for (T t: e.get()) s.apply(t).exec(); }; 18 | } 19 | 20 | default IExec If(Supplier c, IExec s1, IExec s2) { 21 | return () -> { 22 | if (c.get()) s1.exec(); 23 | else s2.exec(); }; 24 | } 25 | 26 | default IExec Return(Supplier e) { 27 | return () -> { throw new Return(e.get()); }; 28 | } 29 | 30 | default IExec Seq(IExec s1, IExec s2) { 31 | return () -> { s1.exec(); s2.exec(); }; 32 | } 33 | 34 | default IExec Empty() { 35 | return () -> {}; 36 | } 37 | } 38 | //END_MUJAVA_IMPL 39 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/MuJavaCPS.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | import java.util.Iterator; 4 | import java.util.function.Function; 5 | import java.util.function.Supplier; 6 | 7 | import recaf.core.cps.K0; 8 | 9 | // TODO: need to distingui R as return type and R provided to SD 10 | // otherwise yield etc (and backtracking don't work). 11 | 12 | //BEGIN_MUJAVA_CPS 13 | public interface MuJavaCPS extends MuJava> { 14 | default SD Exp(Supplier e) { 15 | return (r, s) -> { e.get(); s.call(); }; 16 | } 17 | 18 | default SD Decl(Supplier e, Function> s) { 19 | return (r, s0) -> s.apply(e.get()).accept(r, s0); 20 | } 21 | 22 | default SD For(Supplier> e, Function> s) { 23 | return (r, s0) -> { 24 | Iterator iter = e.get().iterator(); 25 | new K0() { 26 | public void call() { 27 | if (iter.hasNext()) 28 | s.apply(iter.next()).accept(r, () -> call()); 29 | else 30 | s0.call(); 31 | } 32 | 33 | }.call(); 34 | }; 35 | } 36 | 37 | default SD If(Supplier c, SD s1, SD s2) { 38 | return (r, s) -> { 39 | if (c.get()) s1.accept(r, s); 40 | else s2.accept(r, s);}; 41 | } 42 | 43 | default SD Return(Supplier e) { 44 | return (r, s) -> r.accept(e.get()); 45 | } 46 | 47 | default SD Seq(SD s1, SD s2) { 48 | return (r, s) -> s1.accept(r, () -> s2.accept(r, s)); 49 | } 50 | 51 | default SD Empty() { 52 | return (r, s) -> s.call(); 53 | } 54 | } 55 | //END_MUJAVA_CPS 56 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/Return.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | public class Return extends RuntimeException { 4 | public final Object value; 5 | public Return(Object value) { this.value = value; } 6 | } 7 | 8 | -------------------------------------------------------------------------------- /recaf-runtime/src/main/java/recaf/paper/stm/SD.java: -------------------------------------------------------------------------------- 1 | package recaf.paper.stm; 2 | 3 | import recaf.core.cps.K; 4 | import recaf.core.cps.K0; 5 | 6 | public interface SD { void accept(K r, K0 s); } 7 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/BaseTestExprFieldSuper.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | public class BaseTestExprFieldSuper{ 4 | 5 | protected int x = 3; 6 | 7 | } 8 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/BaseTestExprInvokeSuper.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | public class BaseTestExprInvokeSuper{ 4 | 5 | @Override 6 | public String toString(){ 7 | return "BaseTestExprInvokeSuper"; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestAsyncComplex.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncComplex { 7 | 8 | private static Async alg = new Async() {}; 9 | 10 | public static void pause(long sleeptime) { 11 | try { 12 | Thread.sleep(sleeptime); 13 | } catch (InterruptedException ex) { } 14 | } 15 | 16 | public static Void print(String msg) { 17 | System.out.println(msg); 18 | return null; 19 | } 20 | 21 | CompletableFuture op() { 22 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 < 2, alg.Seq(alg.ExpStat(() -> { pause(2500); return null; }), alg.Seq(alg.ExpStat(() -> { print("delayed op"); return null; }), alg.Return(() -> 42)))), alg.Return(() -> 41))); 23 | } 24 | 25 | CompletableFuture op2() { 26 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 < 2, alg.Await(() -> op(), (x) -> { return alg.Await(() -> op(), (y) -> { return alg.Return(() -> x + y); }); })), alg.Seq(alg.ExpStat(() -> { pause(5000); return null; }), alg.Return(() -> 41)))); 27 | } 28 | 29 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 30 | CompletableFuture answer; 31 | 32 | answer = new TestAsyncComplex().op2(); 33 | 34 | print("main"); 35 | 36 | System.out.println(answer.get()); 37 | } 38 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestAsyncComplex2.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.AsyncFull; 5 | 6 | class MyPrinter{ 7 | public MyPrinter(){} 8 | 9 | public Void print(String msg) { 10 | System.out.println(msg); 11 | return null; 12 | } 13 | } 14 | 15 | public class TestAsyncComplex2 { 16 | 17 | private static AsyncFull alg = new AsyncFull() {}; 18 | 19 | public Void pause(Integer sleeptime) { 20 | try { 21 | new Thread().sleep(sleeptime); 22 | return null; 23 | } catch (InterruptedException ex) { 24 | return null; 25 | } 26 | } 27 | 28 | 29 | CompletableFuture op() { 30 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(alg.Lt(alg.Lit(1), alg.Lit(2)), alg.Seq(alg.ExpStat(alg.Invoke(alg.This(this), "pause", alg.Lit(2500))), alg.Seq(alg.ExpStat(alg.Invoke(alg.New(MyPrinter.class), "print", alg.Lit("delayed op"))), alg.Return(alg.Lit(42))))), alg.Return(alg.Lit(41)))); 31 | } 32 | 33 | CompletableFuture op2() { 34 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(alg.Lt(alg.Lit(1), alg.Lit(2)), alg.Await(alg.Invoke(alg.This(this), "op"), (x) -> { return alg.Await(alg.Invoke(alg.This(this), "op"), (y) -> { return alg.Return(alg.Plus(alg.Var("x", x), alg.Var("y", y))); }); })), alg.Seq(alg.ExpStat(alg.Invoke(alg.This(this), "pause", alg.Lit(5000))), alg.Return(alg.Lit(41))))); 35 | } 36 | 37 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 38 | CompletableFuture answer; 39 | 40 | answer = new TestAsyncComplex2().op2(); 41 | 42 | new MyPrinter().print("main"); 43 | 44 | System.out.println(answer.get()); 45 | } 46 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestAsyncNoAwait.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncNoAwait { 7 | private static Async alg = new Async() {}; 8 | 9 | CompletableFuture op() { 10 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 > 5, alg.Return(() -> 42)), alg.Return(() -> 41))); 11 | } 12 | 13 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 14 | Integer answer = new TestAsyncNoAwait().op().get(); 15 | 16 | System.out.println(answer); 17 | } 18 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestAsyncWithAwait.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.CompletableFuture; 3 | import java.util.concurrent.ExecutionException; 4 | import recaf.demo.cps.Async; 5 | 6 | public class TestAsyncWithAwait { 7 | private static Async alg = new Async() {}; 8 | 9 | CompletableFuture op() { 10 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 < 2, alg.Await(() -> secondOp(), (x) -> { return alg.Return(() -> x); })), alg.Return(() -> 41))); 11 | } 12 | 13 | CompletableFuture secondOp() { 14 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 < 2, alg.Return(() -> 42)), alg.Return(() -> 41))); 15 | } 16 | 17 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 18 | Integer answer = new TestAsyncWithAwait().op().get(); 19 | 20 | System.out.println(answer); 21 | } 22 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestBacktracking.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.List; 4 | import recaf.demo.cps.Backtrack; 5 | import static java.util.Arrays.asList; 6 | import java.util.stream.IntStream; 7 | import java.util.Iterator; 8 | 9 | public class TestBacktracking { 10 | 11 | static class Pair { 12 | int x, y; 13 | Pair(int x, int y) { 14 | this.x = x; 15 | this.y = y; 16 | } 17 | public String toString() { 18 | return "(" + x + ", " + y + ")"; 19 | } 20 | } 21 | 22 | static List solve(Backtrack alg) { 23 | return (List)alg.Method(alg.Choose(() -> asList(1, 2, 3), (x) -> { return alg.Seq(alg.ExpStat(() -> { System.err.println("Choice 1: " + x); return null; }), alg.Choose(() -> asList(4, 5, 6), (y) -> { return alg.Seq(alg.ExpStat(() -> { System.err.println("Choice 2: " + y); return null; }), alg.If(() -> x * y == 8, alg.Return(() -> new Pair(x, y)))); })); })); 24 | } 25 | 26 | static Iterable range(int n) { 27 | return new Iterable() { 28 | public Iterator iterator() { 29 | return IntStream.range(0, n).iterator(); 30 | } 31 | }; 32 | } 33 | 34 | public static void main(String args[]) { 35 | System.out.println(solve(new Backtrack())); 36 | } 37 | 38 | 39 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestComeFrom.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.ComeFrom; 4 | import java.util.Scanner; 5 | 6 | public class TestComeFrom { 7 | 8 | // from wikipedia 9 | static Void repl(ComeFrom cf) { 10 | return (Void )cf.Method(cf.Seq(cf.ComeFrom(() -> "l40"), cf.Seq(cf.ExpStat(() -> { System.out.println("What is your name?"); return null; }), cf.Decl(() -> new Scanner(System.in), (recaf.core.Ref scanner) -> {return cf.Decl(() -> scanner.value.next(), (recaf.core.Ref name) -> {return cf.Seq(cf.ExpStat(() -> { System.out.println("Hello, " + name.value); return null; }), cf.Labeled("l40", cf.Empty()));});})))); 11 | } 12 | 13 | public static void main(String[] args) { 14 | repl(new ComeFrom()); 15 | } 16 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestCoroutine.java: -------------------------------------------------------------------------------- 1 | 2 | package generated; 3 | 4 | import recaf.demo.cps.Coroutine; 5 | import java.util.Random; 6 | 7 | 8 | public class TestCoroutine { 9 | 10 | static void producer(Coroutine.Co other) throws InterruptedException { 11 | while (true) { 12 | Thread.sleep(1000); 13 | int data = (new Random()).nextInt(); 14 | System.out.println("Sending " + data); 15 | System.out.println("Producer received: " + other.resume(data)); 16 | } 17 | } 18 | 19 | static Coroutine.Co consumer(Coroutine alg) { 20 | return (Coroutine.Co)alg.Method(alg.Decl(() -> 0, (recaf.core.Ref i) -> {return alg.While(() -> true, alg.Yield(() -> i.value++, (Integer x) -> { return alg.Seq(alg.ExpStat(() -> { System.out.println("consumer received: " + x); return null; }), alg.Yield(() -> 2 * i.value++)); }));})); 21 | } 22 | 23 | public static void main(String args[]) throws InterruptedException { 24 | Coroutine.Co coro = consumer(new Coroutine()); 25 | coro.run(); 26 | producer(coro); 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestDebug.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.paper.demo.Debug; 4 | 5 | public class TestDebug { 6 | private static Debug alg = new Debug() { 7 | }; 8 | 9 | public int x = 3; 10 | 11 | public int dup(int x) { 12 | return 2 * x; 13 | } 14 | 15 | private Integer simple() { 16 | return (Integer) alg 17 | .Method(alg.Seq(alg.Debug(alg.Invoke(alg.This(this), "dup", alg.Field(alg.This(this), "x"))), 18 | alg.Return(alg.Invoke(alg.This(this), "dup", alg.Field(alg.This(this), "x"))))); 19 | } 20 | 21 | public static void main(String args[]) { 22 | TestDebug s = new TestDebug(); 23 | int n = s.simple(); 24 | System.out.println(n); 25 | 26 | } 27 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestDef.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | 6 | public class TestDef { 7 | private static FullJavaDirect alg = new FullJavaDirect() {}; 8 | 9 | static void doSomething() { 10 | alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Seq(alg.ForDecl(() -> 0, (recaf.core.Ref i) -> alg.ForBody(() -> i.value < 10, alg.Seq(alg.ExpStat(() -> { i.value++; return null; }), alg.Empty()), alg.If(() -> i.value % 2 == 0, alg.ExpStat(() -> { sum.value += i.value; return null; })))), alg.ExpStat(() -> { System.out.println("sum = " + sum.value); return null; }));})); 11 | } 12 | 13 | public static void main(String args[]) { 14 | doSomething(); 15 | } 16 | 17 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprAnd.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprAnd { 6 | 7 | private int i = 0; 8 | 9 | private static FullJavaDirect alg = new FullJavaDirect() {}; 10 | 11 | private boolean rhs(){ 12 | i++; 13 | return true; 14 | } 15 | 16 | private boolean lazyAnd() { 17 | return (Boolean)alg.Method(alg.Return(alg.LazyAnd(alg.Lt(alg.Lit(1), alg.Lit(0)), alg.Invoke(alg.This(this), "rhs")))); 18 | } 19 | 20 | private boolean and() { 21 | return (Boolean)alg.Method(alg.Return(alg.And(alg.Lt(alg.Lit(1), alg.Lit(0)), alg.Invoke(alg.This(this), "rhs")))); 22 | } 23 | 24 | public static void main(String args[]) { 25 | TestExprAnd o = new TestExprAnd(); 26 | System.out.println(o.lazyAnd()); 27 | System.out.println(o.i); 28 | System.out.println(o.and()); 29 | System.out.println(o.i); 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprFieldSuper.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprFieldSuper extends BaseTestExprFieldSuper { 6 | private static FullJavaDirect alg = new FullJavaDirect() {}; 7 | 8 | private int x = 5; 9 | 10 | public int getThisX() { 11 | return (Integer)alg.Method(alg.Return(alg.Field(alg.This(this), "x"))); 12 | } 13 | 14 | public int getSuperX() { 15 | return (Integer)alg.Method(alg.Return(alg.SuperField("x", this))); 16 | } 17 | 18 | public static void main(String args[]) { 19 | TestExprFieldSuper o = new TestExprFieldSuper(); 20 | System.out.println(o.getThisX()); 21 | System.out.println(o.getSuperX()); 22 | } 23 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprInheritanceMethodLookup.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AD{ 6 | private int a; 7 | 8 | public AD(){ 9 | 10 | } 11 | 12 | void setA(int a){ 13 | this.a = a; 14 | } 15 | 16 | int getA(){ 17 | return a; 18 | } 19 | } 20 | 21 | class AE extends AD{ 22 | @Override 23 | int getA(){ 24 | return -1; 25 | } 26 | } 27 | 28 | 29 | public class TestExprInheritanceMethodLookup { 30 | private static FullJavaDirect alg = new FullJavaDirect() {}; 31 | 32 | private static int simple() { 33 | return (Integer)alg.Method(alg.Decl(alg.New(AE.class), (recaf.core.Ref a) -> {return alg.Seq(alg.ExpStat(alg.Invoke(alg.Ref("a", a), "setA", alg.Lit(4))), alg.Return(alg.Invoke(alg.Ref("a", a), "getA")));})); 34 | } 35 | 36 | public static void main(String args[]) { 37 | int n = simple(); 38 | System.out.println(n); 39 | 40 | } 41 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprInvokeSuper.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | public class TestExprInvokeSuper extends BaseTestExprInvokeSuper { 6 | private static FullJavaDirect alg = new FullJavaDirect() {}; 7 | 8 | @Override 9 | public String toString() { 10 | return (String )alg.Method(alg.Decl(alg.InvokeSuper(alg.This(this), "toString"), (recaf.core.Ref s) -> {return alg.Return(alg.Plus(alg.Plus(alg.Lit("son("), alg.Ref("s", s)), alg.Lit(")")));})); 11 | } 12 | 13 | public static void main(String args[]) { 14 | TestExprInvokeSuper o = new TestExprInvokeSuper(); 15 | System.out.println(o.toString()); 16 | 17 | } 18 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprNoConstructor.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | 6 | 7 | public class TestExprNoConstructor { 8 | private static FullJavaDirect alg = new FullJavaDirect() {}; 9 | 10 | static class AB { 11 | private int a; 12 | 13 | @Override 14 | public String toString(){ 15 | return "AB("+a+")"; 16 | } 17 | } 18 | 19 | private static AB simple() { 20 | return (AB )alg.Method(alg.Decl(alg.New(AB.class), (recaf.core.Ref a) -> {return alg.Return(alg.Ref("a", a));})); 21 | } 22 | 23 | public static void main(String args[]) { 24 | AB a = simple(); 25 | System.out.println(a); 26 | 27 | } 28 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprPrivateConstructor.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AA{ 6 | private int a = 0; 7 | 8 | private AA(){ 9 | 10 | } 11 | 12 | @Override 13 | public String toString(){ 14 | return "AA("+a+")"; 15 | } 16 | } 17 | 18 | 19 | public class TestExprPrivateConstructor { 20 | private static FullJavaDirect alg = new FullJavaDirect() {}; 21 | 22 | private static AA simple() { 23 | return (AA )alg.Method(alg.Decl(alg.New(AA.class), (recaf.core.Ref a) -> {return alg.Return(alg.Ref("a", a));})); 24 | } 25 | 26 | public static void main(String args[]) { 27 | AA aa = simple(); 28 | System.out.println(aa); 29 | 30 | } 31 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestExprSimpleMethodLookup.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.full.FullJavaDirect; 4 | 5 | class AC{ 6 | private int a; 7 | 8 | public AC(){ 9 | 10 | } 11 | 12 | void setA(int a){ 13 | this.a = a; 14 | } 15 | 16 | int getA(){ 17 | return a; 18 | } 19 | } 20 | 21 | 22 | public class TestExprSimpleMethodLookup { 23 | private static FullJavaDirect alg = new FullJavaDirect() {}; 24 | 25 | private static int simple() { 26 | return (Integer)alg.Method(alg.Decl(alg.New(AC.class), (recaf.core.Ref a) -> {return alg.Seq(alg.ExpStat(alg.Invoke(alg.Ref("a", a), "setA", alg.Lit(4))), alg.Return(alg.Invoke(alg.Ref("a", a), "getA")));})); 27 | } 28 | 29 | public static void main(String args[]) { 30 | int n = simple(); 31 | System.out.println(n); 32 | 33 | } 34 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFibIter.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.Iter; 4 | 5 | public class TestFibIter { 6 | private static Iter alg = new Iter(); 7 | 8 | private static Iterable fib() { 9 | return (Iterable)alg.Method(alg.Decl(() -> 0, (recaf.core.Ref a) -> {return alg.Decl(() -> 1, (recaf.core.Ref b) -> {return alg.While(() -> true, alg.Seq(alg.Yield(() -> a.value), alg.Seq(alg.ExpStat(() -> { b.value = a.value + b.value; return null; }), alg.ExpStat(() -> { a.value = b.value - a.value; return null; }))));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | int count = 10; 14 | for (Integer n: fib()) { 15 | if(count-- == 0) { 16 | System.out.println(n); 17 | break; 18 | } 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFibIter2.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.cps.IterFull; 4 | 5 | public class TestFibIter2 { 6 | private static IterFull alg = new IterFull() {}; 7 | 8 | private static Iterable fib() { 9 | return (Iterable)alg.Method(alg.Decl(alg.Lit(0), (recaf.core.Ref a) -> {return alg.Decl(alg.Lit(1), (recaf.core.Ref b) -> {return alg.While(alg.Lit(true), alg.Seq(alg.Yield(alg.Ref("a", a)), alg.Seq(alg.ExpStat(alg.Assign(alg.Ref("b", b), alg.Plus(alg.Ref("a", a), alg.Ref("b", b)))), alg.ExpStat(alg.Assign(alg.Ref("a", a), alg.Minus(alg.Ref("b", b), alg.Ref("a", a)))))));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | int count = 10; 14 | for (Integer n: fib()) { 15 | if(count-- == 0) { 16 | System.out.println(n); 17 | break; 18 | } 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFibMemo.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.Memo; 4 | 5 | public class TestFibMemo { 6 | private static Memo alg = new Memo(); 7 | 8 | private Integer fib(Integer x) { 9 | recaf.core.Ref $x = new recaf.core.Ref(x); 10 | return (Integer )alg.Method(alg.If(alg.Lt(alg.Ref("$x", $x), alg.Lit(2)), alg.Return(alg.Ref("$x", $x)), alg.Decl(alg.Invoke(alg.This(this), "fib", alg.Minus(alg.Ref("$x", $x), alg.Lit(1))), (recaf.core.Ref x1) -> {return alg.Decl(alg.Invoke(alg.This(this), "fib", alg.Minus(alg.Ref("$x", $x), alg.Lit(2))), (recaf.core.Ref x2) -> {return alg.Return(alg.Plus(alg.Ref("x1", x1), alg.Ref("x2", x2)));});}))); 11 | } 12 | 13 | public static void main(String args[]) { 14 | int count = 10; 15 | TestFibMemo t = new TestFibMemo(); 16 | System.out.println(t.fib(12)); 17 | System.out.println(t.fib(12)); 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFibRecAsync.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.ExecutionException; 5 | import recaf.demo.cps.Async; 6 | 7 | public class TestFibRecAsync { 8 | private static Async alg = new Async() {}; 9 | 10 | CompletableFuture fib(Integer x) { 11 | recaf.core.Ref $x = new recaf.core.Ref(x); 12 | return (CompletableFuture)alg.Method(alg.If(() -> $x.value < 2, alg.Return(() -> $x.value), alg.Await(() -> fib($x.value-1), (x1) -> { return alg.Await(() -> fib($x.value-2), (x2) -> { return alg.Return(() -> x1 + x2); }); }))); 13 | } 14 | 15 | public static void main(String[] args) throws InterruptedException, ExecutionException{ 16 | CompletableFuture answer; 17 | 18 | answer = new TestFibRecAsync().fib(10); 19 | 20 | System.out.println(answer.get()); 21 | } 22 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFor_noBreak.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestFor_noBreak { 6 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | Integer meth() { 9 | return (Integer )alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Decl(() -> Arrays.asList(1,2,3,4,5), (recaf.core.Ref> list) -> {return alg.Seq(alg.ForEach(() -> list.value, (recaf.core.Ref i) -> alg.ExpStat(() -> { sum.value += (Integer)i.value; return null; })), alg.Return(() -> sum.value));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | System.out.println(new TestFor_noBreak().meth()); //15 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFor_ordinary.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestFor_ordinary { 5 | 6 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | Integer meth() { 9 | return (Integer )alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Seq(alg.ForDecl(() -> 0, (recaf.core.Ref i) -> alg.ForBody(() -> i.value < 10, alg.Seq(alg.ExpStat(() -> { i.value++; return null; }), alg.Empty()), alg.ExpStat(() -> { sum.value += i.value; return null; }))), alg.Return(() -> sum.value));})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | System.out.println(new TestFor_ordinary().meth()); //45 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestFor_withBreak.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestFor_withBreak { 6 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | Integer meth() { 9 | return (Integer )alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Decl(() -> Arrays.asList(1,2,3,4,5), (recaf.core.Ref> list) -> {return alg.Seq(alg.Labeled("bla", alg.While(() -> true, alg.ForEach(() -> list.value, (recaf.core.Ref i) -> alg.Seq(alg.ExpStat(() -> { sum.value += (Integer)i.value; return null; }), alg.If(() -> i.value > 3, alg.Break("bla")))))), alg.Return(() -> sum.value));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | System.out.println(new TestFor_withBreak().meth()); //10 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestGUI.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.direct.GUI; 3 | import recaf.demo.direct.GUI.Render; 4 | import recaf.demo.direct.GUI.Handle; 5 | import java.util.stream.IntStream; 6 | import java.util.Iterator; 7 | import java.io.StringWriter; 8 | 9 | 10 | public class TestGUI { 11 | private GUI alg; 12 | 13 | public TestGUI(GUI alg) { 14 | this.alg = alg; 15 | } 16 | 17 | 18 | void h2(String title) { 19 | recaf.core.Ref $title = new recaf.core.Ref(title); 20 | alg.Method(alg.Tag(() -> "h2", alg.Echo(() -> $title.value))); 21 | } 22 | 23 | static Iterable range(int n) { 24 | return new Iterable() { 25 | public Iterator iterator() { 26 | return IntStream.range(0, n).iterator(); 27 | } 28 | }; 29 | } 30 | 31 | static void println(String x) { 32 | System.out.println(x); 33 | } 34 | 35 | static void hello(GUI alg, int n) { 36 | recaf.core.Ref $n = new recaf.core.Ref(n); 37 | alg.Method(alg.Tag(() -> "div", alg.ForEach(() -> range($n.value), (recaf.core.Ref i) -> alg.Tag(() -> "p", alg.Seq(alg.Echo(() -> "Hello world " + i.value + "!\n"), alg.Button(() -> "Click " + i.value, alg.If(() -> i.value % 2 == 0, alg.ExpStat(() -> { println("even " + i.value); return null; }), alg.ExpStat(() -> { println("odd " + i.value); return null; })))))))); 38 | } 39 | 40 | static void sendToServer(String x) { 41 | System.out.println(x); 42 | } 43 | 44 | public static void main(String args[]) { 45 | StringWriter w = new StringWriter(); 46 | hello(new Render(w), 10); 47 | sendToServer(w.toString()); 48 | // ... receive the clicked id; assume it's "id2" 49 | hello(new Handle("id2"), 10); // prints out even 2 50 | } 51 | 52 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestGUI2.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.direct.GUI; 3 | import recaf.demo.direct.GUI.Render; 4 | import recaf.demo.direct.GUI.Handle; 5 | import java.util.stream.IntStream; 6 | import java.util.Iterator; 7 | import java.io.StringWriter; 8 | 9 | 10 | public class TestGUI2 { 11 | private GUI alg; 12 | 13 | public TestGUI2(GUI alg) { 14 | this.alg = alg; 15 | } 16 | 17 | 18 | void h2(String title) { 19 | recaf.core.Ref $title = new recaf.core.Ref(title); 20 | alg.Method(alg.Tag(() -> "h2", alg.Echo(() -> $title.value))); 21 | } 22 | 23 | static Iterable range(int n) { 24 | return new Iterable() { 25 | public Iterator iterator() { 26 | return IntStream.range(0, n).iterator(); 27 | } 28 | }; 29 | } 30 | 31 | static void println(String x) { 32 | System.out.println(x); 33 | } 34 | 35 | static void hello(GUI alg, int n) { 36 | recaf.core.Ref $n = new recaf.core.Ref(n); 37 | alg.Method(alg.Tag(() -> "div", alg.ForEach(() -> range($n.value), (recaf.core.Ref i) -> alg.Button(() -> "Click " + i.value, alg.ExpStat(() -> { println("clicked " + i.value); return null; }))))); 38 | } 39 | //END_HELLOES 40 | 41 | static void sendToServer(String x) { 42 | System.out.println(x); 43 | } 44 | 45 | public static void main(String args[]) { 46 | //BEGIN_CLIENT_GUI 47 | StringWriter w = new StringWriter(); 48 | hello(new Render(w), 10); 49 | sendToServer(w.toString()); 50 | // ... receive the clicked id; assume it's "id2" 51 | hello(new Handle("id2"), 10); // prints out "clicked 2" 52 | //END_CLIENT_GUI 53 | } 54 | 55 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestIter.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Iter; 3 | import java.util.stream.IntStream; 4 | import java.util.Iterator; 5 | import java.util.function.Predicate; 6 | 7 | public class TestIter { 8 | private static Iter alg = new Iter(); 9 | 10 | Iterable range(int n) { 11 | return new Iterable() { 12 | public Iterator iterator() { 13 | return IntStream.range(0, n).iterator(); 14 | } 15 | }; 16 | } 17 | 18 | Iterable filter(Iterable iter, Predicate pred) { 19 | recaf.core.Ref> $iter = new recaf.core.Ref>(iter); recaf.core.Ref> $pred = new recaf.core.Ref>(pred); 20 | return (Iterable)alg.Method(alg.ForEach(() -> $iter.value, (recaf.core.Ref t) -> alg.If(() -> $pred.value.test(t.value), alg.Yield(() -> t.value)))); 21 | } 22 | 23 | Iterable subIter() { 24 | return (Iterable)alg.Method(alg.ForEach(() -> range(10), (recaf.core.Ref i) -> alg.Yield(() -> i.value))); 25 | } 26 | 27 | Iterable myIter() { 28 | return (Iterable)alg.Method(alg.While(() -> true, alg.YieldFrom(() -> filter(subIter(), x -> ((Integer)x) % 2 == 0)))); 29 | } 30 | 31 | public static void main(String args[]) { 32 | for (Integer i: new TestIter().myIter()) { 33 | System.out.println("i = " + i); 34 | } 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestIter_YieldEachRec.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Iter; 3 | import java.util.stream.IntStream; 4 | import java.util.Iterator; 5 | import java.util.function.Predicate; 6 | 7 | public class TestIter_YieldEachRec { 8 | private static Iter alg = new Iter(); 9 | 10 | Iterable naturalsDownFrom(int n) { 11 | recaf.core.Ref $n = new recaf.core.Ref(n); 12 | return (Iterable)alg.Method(alg.If(() -> $n.value >0, alg.Seq(alg.Yield(() -> $n.value), alg.YieldFrom(() -> naturalsDownFrom($n.value-1))))); 13 | } 14 | 15 | public static void main(String args[]) { 16 | for (Integer i: new TestIter_YieldEachRec().naturalsDownFrom(10)) { 17 | System.out.println("i = " + i); 18 | } 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestLocals.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.cps.StmtJavaCPS; 4 | import static java.util.Arrays.asList; 5 | 6 | public class TestLocals { 7 | 8 | public Integer doit(StmtJavaCPS alg, int x, final Integer $x) { 9 | recaf.core.Ref $$$x = new recaf.core.Ref(x); final Integer $$$$x = $x; 10 | return (Integer )alg.Method(alg.Seq(alg.Return(() -> $$$x.value), alg.Seq(alg.Return(() -> $$$$x), alg.Decl(null, (recaf.core.Ref objs) -> {return alg.ForEach(() -> asList(objs.value), (recaf.core.Ref $$x) -> alg.Empty());})))); 11 | } 12 | 13 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestMaybe.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Maybe; 3 | import java.util.Optional; 4 | 5 | public class TestMaybe { 6 | private Maybe alg = new Maybe(); 7 | 8 | Optional maybe() { 9 | return (Optional)alg.Method(alg.Decl(() -> 3, (recaf.core.Ref x) -> {return alg.Seq(alg.ExpStat(() -> { System.out.println("maybe"); return null; }), alg.If(() -> 7 > 5, alg.Seq(alg.ExpStat(() -> { System.out.println("Yes"); return null; }), alg.Return(() -> 42))));})); 10 | } 11 | 12 | Optional readOptional() { 13 | return (Optional)alg.Method(alg.Maybe(() -> maybe(), (x) -> { return alg.Return(() -> x + 1); })); 14 | } 15 | 16 | public static void main(String args[]) { 17 | Optional x = new TestMaybe().readOptional(); 18 | System.out.println(x.get()); 19 | } 20 | 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestOrElse.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.OrElse; 4 | 5 | public class TestOrElse { 6 | 7 | private static OrElse alg = new OrElse() {}; 8 | 9 | Integer someMethod(int i) { 10 | System.out.println("Called: " + i); 11 | if (i % 2 != 0) { 12 | return null; 13 | } 14 | return i; 15 | } 16 | 17 | Object orElse() { 18 | return (Object )alg.Method(alg.Return(alg.OrElse(alg.Lit(null), alg.Invoke(alg.This(this), "someMethod", alg.Lit(1)), alg.Invoke(alg.This(this), "someMethod", alg.Lit(2)), alg.Invoke(alg.This(this), "someMethod", alg.Lit(3))))); 19 | } 20 | 21 | public static void main(String args[]) { 22 | new TestOrElse().orElse(); 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestPropagate.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.demo.cps.Propagate; 3 | 4 | 5 | public class TestPropagate { 6 | private Propagate alg = new Propagate(); 7 | 8 | void update(String s) { 9 | recaf.core.Ref $s = new recaf.core.Ref(s); 10 | alg.Method(alg.Seq(alg.Local(() -> $s.value, alg.ExpStat(() -> { method(); return null; })), alg.Ask((String x) -> { return alg.ExpStat(() -> { System.out.println(x); return null; }); }))); 11 | } 12 | 13 | void method() { 14 | read(); 15 | } 16 | 17 | void read() { 18 | alg.Method(alg.Ask((String s) -> { return alg.ExpStat(() -> { System.out.println("s = " + s); return null; }); })); 19 | } 20 | 21 | public static void main(String args[]) { 22 | new TestPropagate().update("Hello world!"); 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestPullStreams.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | public class TestPullStreams { 3 | public static void main(String args[]) { 4 | Integer result = PStream 5 | .range(10) 6 | .map(i -> i ^ 2) 7 | .filter(i -> i % 2 == 0) 8 | .sum(); 9 | System.out.println(result); 10 | } 11 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestQL.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | /* 3 | * import recaf.demo.ql.QL; 4 | * 5 | * public class TestQL { 6 | * 7 | * private recaf QL alg; 8 | * 9 | * public TestQL(QL alg) { this.alg = alg; } 10 | * 11 | * public recaf void taxOffice() { // todo: fix boxing of formal params in 12 | * binders. question "Did you sell a house in 2010?", Boolean hasSoldHouse; 13 | * question "Did you buy a house in 2010?", Boolean hasBoughtHouse; question 14 | * "Did you enter a loan?", Boolean hasMaintLoan; if (hasSoldHouse) { question 15 | * "What was the selling price?", Integer sellingPrice; question 16 | * "Private debts for the sold house:", Integer privateDebt; question 17 | * "Value residue:", Integer valueResidue = sellingPrice - privateDebt; } } 18 | * 19 | * } 20 | */ -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSecurity.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | import recaf.demo.direct.Student; 7 | import recaf.demo.direct.StudentPolicy; 8 | import recaf.demo.direct.Security; 9 | 10 | class Printer2 { 11 | public Void print(Object o) { 12 | System.out.print(o); 13 | return null; 14 | } 15 | } 16 | 17 | public class TestSecurity{ 18 | 19 | private static Security alg = new Security(new StudentPolicy()); 20 | 21 | public static Void printGrades(List students) { 22 | recaf.core.Ref> $students = new recaf.core.Ref>(students); 23 | return (Void )alg.Method(alg.Decl(alg.New(Printer2.class), (recaf.core.Ref p) -> {return alg.ForEach(alg.Ref("$students", $students), (recaf.core.Ref s) -> alg.Seq(alg.ExpStat(alg.Invoke(alg.Ref("p", p), "print", alg.Field(alg.Ref("s", s), "name"))), alg.Seq(alg.ExpStat(alg.Invoke(alg.Ref("p", p), "print", alg.Lit(" -> "))), alg.Seq(alg.ExpStat(alg.Invoke(alg.Ref("p", p), "print", alg.Field(alg.Ref("s", s), "grade"))), alg.ExpStat(alg.Invoke(alg.Ref("p", p), "print", alg.Lit("\n")))))));})); 24 | } 25 | 26 | public static Void failStudent(Student s) { 27 | recaf.core.Ref $s = new recaf.core.Ref(s); 28 | return (Void )alg.Method(alg.ExpStat(alg.Assign(alg.Field(alg.Ref("$s", $s), "grade"), alg.Lit("F")))); 29 | } 30 | 31 | public static void main(String[] args){ 32 | List students = 33 | Arrays.asList(new Student[]{ 34 | new Student("Alice", "A",1), 35 | new Student("Bob","B", 2), 36 | new Student("Cathy","F",1)}); 37 | failStudent(students.get(0)); 38 | failStudent(students.get(1)); 39 | printGrades(students); 40 | } 41 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSimple.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.Ref; 3 | import recaf.core.full.FullJavaDirect; 4 | import java.util.stream.IntStream; 5 | import java.util.Iterator; 6 | import java.util.function.Predicate; 7 | import java.util.function.*; 8 | 9 | class A{ 10 | int i = 1; 11 | 12 | int a(int x, int y){ 13 | return ++i; 14 | } 15 | 16 | public A(){ 17 | 18 | } 19 | } 20 | 21 | public class TestSimple { 22 | private static FullJavaDirect alg = new FullJavaDirect() {}; 23 | 24 | private static Integer simple() { 25 | return (Integer )alg.Method(alg.Decl(alg.Lit(4), (recaf.core.Ref a) -> {return alg.Decl(alg.PostIncr(alg.Ref("a", a)), (recaf.core.Ref b) -> {return alg.Decl(alg.Lit(0), (recaf.core.Ref d) -> {return alg.Seq(alg.While(alg.Lt(alg.Ref("d", d), alg.Lit(5)), alg.ExpStat(alg.PreIncr(alg.Ref("d", d)))), alg.Return(alg.Ref("d", d)));});});})); 26 | } 27 | 28 | private static Integer access() { 29 | return (Integer )alg.Method(alg.Decl(alg.Lit(4), (recaf.core.Ref a) -> {return alg.Return(alg.Ref("a", a));})); 30 | } 31 | 32 | private static Integer methodCall() { 33 | return (Integer )alg.Method(alg.Return(alg.Invoke(alg.New(A.class), "a", alg.Lit(1),alg.Lit(2)))); 34 | } 35 | 36 | private static Integer fieldAccess() { 37 | return (Integer )alg.Method(alg.Return(alg.Field(alg.New(A.class), "i"))); 38 | } 39 | 40 | private static Integer many() { 41 | return (Integer )alg.Method(alg.Decl(alg.New(A.class), (recaf.core.Ref a) -> {return alg.Seq(alg.ExpStat(alg.Assign(alg.Field(alg.Ref("a", a), "i"), alg.Lit(3))), alg.Return(alg.Field(alg.Ref("a", a), "i")));})); 42 | } 43 | 44 | 45 | public static void main(String args[]) { 46 | int n = many(); 47 | System.out.println(n); 48 | 49 | } 50 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSolve.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.constraint.Solve; 4 | import java.util.Map; 5 | import org.chocosolver.solver.variables.IntVar; 6 | 7 | public class TestSolve { 8 | private static Solve alg = new Solve(); 9 | 10 | Iterable> example() { 11 | return (Iterable>)alg.Method(alg.Var(alg.Lit(0), alg.Lit(5), (IntVar x) -> { return alg.Var(alg.Lit(0), alg.Lit(5), (IntVar y) -> { return alg.Seq(alg.Solve(alg.Lt(alg.Plus(alg.Var("x", x), alg.Var("y", y)), alg.Lit(5))), alg.Solve(alg.Gt(alg.Minus(alg.Var("x", x), alg.Var("y", y)), alg.Lit(1)))); }); })); 12 | } 13 | 14 | public static void main(String args[]) { 15 | for (Map sol: new TestSolve().example()) { 16 | System.out.println(sol); 17 | } 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSolve_alldifferent.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.constraint.Solve; 4 | import java.util.Map; 5 | import org.chocosolver.solver.variables.IntVar; 6 | 7 | public class TestSolve_alldifferent { 8 | private static Solve alg = new Solve(); 9 | 10 | Iterable> example() { 11 | return (Iterable>)alg.Method(alg.Var(alg.Lit(0), alg.Lit(1), (IntVar w) -> { return alg.Var(alg.Minus(alg.Lit(1)), alg.Lit(2), (IntVar x) -> { return alg.Var(alg.Lit(2), alg.Lit(4), (IntVar y) -> { return alg.Var(alg.Lit(5), alg.Lit(7), (IntVar z) -> { return alg.Solve(alg.Invoke(alg.This(this), "alldifferent", alg.Var("w", w), alg.Var("x", x), alg.Var("y", y), alg.Var("z", z))); }); }); }); })); 12 | } 13 | 14 | public static void main(String args[]) { 15 | for (Map sol: new TestSolve_alldifferent().example()) { 16 | System.out.println(sol); 17 | } 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestStream_with_await.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | import java.util.concurrent.CompletableFuture; 4 | import java.util.concurrent.CountDownLatch; 5 | 6 | import recaf.demo.cps.Async; 7 | import recaf.demo.cps.StreamExt; 8 | import rx.Observable; 9 | import rx.Subscription; 10 | import rx.functions.Action0; 11 | import rx.functions.Action1; 12 | 13 | public class TestStream_with_await { 14 | 15 | CompletableFuture secondOp(Async alg) { 16 | return (CompletableFuture)alg.Method(alg.Seq(alg.If(() -> 1 < 2, alg.Return(() -> 42)), alg.Return(() -> 41))); 17 | } 18 | 19 | Observable simpleStream2(StreamExt alg) { 20 | return (Observable)alg.Method(alg.Seq(alg.Yield(() -> 1), alg.Seq(alg.Yield(() -> 2), alg.Await(() -> secondOp(new Async(){}), (Integer x) -> { return alg.Seq(alg.Yield(() -> x), alg.Seq(alg.Yield(() -> 4), alg.Yield(() -> 5))); })))); 21 | } 22 | 23 | public static void main(String args[]) throws InterruptedException, ExecutionException { 24 | CountDownLatch latch = new CountDownLatch(1); 25 | 26 | Subscription sub = new TestStream_with_await() 27 | .simpleStream2(new StreamExt()) 28 | .subscribe(new Action1() { 29 | @Override 30 | public void call(Integer s) { 31 | System.out.println(s); 32 | } 33 | }, 34 | new Action1() { 35 | @Override 36 | public void call(Throwable e) { 37 | latch.countDown(); 38 | } 39 | } 40 | , 41 | new Action0() { 42 | @Override 43 | public void call() { 44 | latch.countDown(); 45 | } 46 | }); 47 | 48 | latch.await(); 49 | 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestStream_with_yield.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | 4 | import recaf.demo.cps.StreamExt; 5 | import rx.Observable; 6 | import rx.Subscription; 7 | import rx.functions.Action1; 8 | 9 | public class TestStream_with_yield { 10 | 11 | private StreamExt alg = new StreamExt(); 12 | 13 | Observable simpleStream() { 14 | return (Observable)alg.Method(alg.Seq(alg.Yield(() -> 1), alg.Seq(alg.Yield(() -> 2), alg.Seq(alg.Yield(() -> 3), alg.Seq(alg.Yield(() -> 4), alg.Yield(() -> 5)))))); 15 | } 16 | 17 | public static void main(String args[]) throws InterruptedException, ExecutionException { 18 | Subscription sub = new TestStream_with_yield().simpleStream().subscribe(new Action1() { 19 | @Override 20 | public void call(Integer s) { 21 | System.out.println(s); 22 | } 23 | }); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestStream_with_yieldFrom.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.concurrent.ExecutionException; 3 | 4 | import recaf.demo.cps.StreamExt; 5 | import rx.Observable; 6 | import rx.Subscription; 7 | import rx.functions.Action1; 8 | 9 | public class TestStream_with_yieldFrom { 10 | 11 | private StreamExt alg = new StreamExt(); 12 | 13 | Observable simpleStream() { 14 | return (Observable)alg.Method(alg.Seq(alg.Yield(() -> 1), alg.Seq(alg.Yield(() -> 2), alg.Seq(alg.Yield(() -> 3), alg.Seq(alg.YieldFrom(() -> simpleStream2()), alg.Seq(alg.Yield(() -> 4), alg.Yield(() -> 5))))))); 15 | } 16 | 17 | Observable simpleStream2() { 18 | return (Observable)alg.Method(alg.Seq(alg.Yield(() -> 11), alg.Seq(alg.Yield(() -> 22), alg.Seq(alg.Yield(() -> 33), alg.Seq(alg.Yield(() -> 44), alg.Yield(() -> 55)))))); 19 | } 20 | 21 | public static void main(String args[]) throws InterruptedException, ExecutionException { 22 | Subscription sub = new TestStream_with_yieldFrom().simpleStream().subscribe(new Action1() { 23 | @Override 24 | public void call(Integer s) { 25 | System.out.println(s); 26 | } 27 | }); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_break_default_beginning.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_default_beginning { 5 | private StmtJavaCPS alg = new StmtJavaCPS(){}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | String meth() { 13 | return (String )alg.Method(alg.Decl(() -> 2, (recaf.core.Ref number) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Default(alg.ExpStat(() -> { print("with default"); return null; })), alg.Case(1, alg.Seq(alg.ExpStat(() -> { print("one"); return null; }), alg.Break())), alg.Case(2, alg.ExpStat(() -> { print("two"); return null; }))), alg.Return(() -> selection.value));});})); 14 | } 15 | 16 | public static void main(String args[]) { 17 | new TestSwitch_break_default_beginning().meth(); 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_break_first.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_first { 5 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | 13 | String meth() { 14 | return (String )alg.Method(alg.Decl(() -> 1, (recaf.core.Ref number) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Case(1, alg.Seq(alg.ExpStat(() -> { print("one"); return null; }), alg.Break())), alg.Case(2, alg.ExpStat(() -> { print("two"); return null; })), alg.Default(alg.ExpStat(() -> { print("default"); return null; }))), alg.Return(() -> selection.value));});})); 15 | } 16 | 17 | public static void main(String args[]) { 18 | new TestSwitch_break_first().meth(); 19 | } 20 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_break_second.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_second { 5 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | String meth() { 13 | return (String )alg.Method(alg.Decl(() -> 1, (recaf.core.Ref number) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Case(1, alg.ExpStat(() -> { print("one"); return null; })), alg.Case(2, alg.Seq(alg.ExpStat(() -> { print("two"); return null; }), alg.Break())), alg.Default(alg.ExpStat(() -> { print("default"); return null; }))), alg.Return(() -> selection.value));});})); 14 | } 15 | 16 | public static void main(String args[]) { 17 | new TestSwitch_break_second().meth(); 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_break_second_withdefault.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_break_second_withdefault { 5 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | String meth() { 13 | return (String )alg.Method(alg.Decl(() -> 2, (recaf.core.Ref number) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Case(1, alg.ExpStat(() -> { print("one"); return null; })), alg.Case(2, alg.ExpStat(() -> { print("two"); return null; })), alg.Default(alg.ExpStat(() -> { print("with default"); return null; }))), alg.Return(() -> selection.value));});})); 14 | } 15 | 16 | public static void main(String args[]) { 17 | new TestSwitch_break_second_withdefault().meth(); 18 | } 19 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_nested_default_beginning.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_nested_default_beginning { 5 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | String meth() { 13 | return (String )alg.Method(alg.Decl(() -> 1, (recaf.core.Ref number) -> {return alg.Decl(() -> 3, (recaf.core.Ref number2) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Default(alg.ExpStat(() -> { print("with default"); return null; })), alg.Case(1, alg.Switch(() -> number2.value, alg.Case(1, alg.Seq(alg.ExpStat(() -> { print("one"); return null; }), alg.Break())), alg.Default(alg.ExpStat(() -> { print("with default"); return null; })), alg.Case(3, alg.Seq(alg.ExpStat(() -> { print("three"); return null; }), alg.Break())), alg.Case(4, alg.ExpStat(() -> { print("four"); return null; })))), alg.Case(2, alg.ExpStat(() -> { print("two"); return null; }))), alg.Return(() -> selection.value));});});})); 14 | } 15 | 16 | public static void main(String args[]) { 17 | 18 | new TestSwitch_nested_default_beginning().meth(); 19 | 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestSwitch_no_break.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import recaf.core.cps.StmtJavaCPS; 3 | 4 | public class TestSwitch_no_break { 5 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 6 | 7 | public static Void print(String msg) { 8 | System.out.println(msg); 9 | return null; 10 | } 11 | 12 | String meth() { 13 | return (String )alg.Method(alg.Decl(() -> 1, (recaf.core.Ref number) -> {return alg.Decl(() -> "none", (recaf.core.Ref selection) -> {return alg.Seq(alg.Switch(() -> number.value, alg.Case(1, alg.ExpStat(() -> { print("one"); return null; })), alg.Case(2, alg.ExpStat(() -> { print("two"); return null; })), alg.Default(alg.ExpStat(() -> { print("default"); return null; }))), alg.Return(() -> selection.value));});})); 14 | } 15 | 16 | public static void main(String args[]) { 17 | new TestSwitch_no_break().meth(); 18 | 19 | } 20 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestUsing.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.demo.direct.Using; 4 | import java.io.BufferedReader; 5 | import java.io.FileNotFoundException; 6 | import java.io.FileReader; 7 | import java.io.IOException; 8 | 9 | public class TestUsing { 10 | 11 | private static Using alg = new Using() {}; 12 | 13 | static String usingExample(String path) { 14 | recaf.core.Ref $path = new recaf.core.Ref(path); 15 | return (String )alg.Method(alg.Using(() -> new BufferedReader(new FileReader($path.value)), (BufferedReader br) -> {return alg.Return(() -> br.readLine());})); 16 | } 17 | 18 | public static void main(String args[]) { 19 | System.out.println(new TestUsing().usingExample("src/test/resources/test")); 20 | } 21 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestUsingWithError.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.core.direct.IExec; 4 | import recaf.demo.direct.Using; 5 | import java.io.BufferedReader; 6 | import java.io.FileNotFoundException; 7 | import java.io.FileReader; 8 | import java.io.IOException; 9 | 10 | public class TestUsingWithError { 11 | 12 | private static Using alg = new Using() {}; 13 | 14 | static String usingExample(String path) { 15 | recaf.core.Ref $path = new recaf.core.Ref(path); 16 | return (String )alg.Method(alg.Using(() -> new BufferedReader(new FileReader($path.value)), (BufferedReader br) -> {return alg.Return(() -> br.readLine());})); 17 | } 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | public static void main(String args[]) { 36 | System.out.println(new TestUsing().usingExample("src/test-generated/README.md")); 37 | } 38 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestWeb.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | 3 | import recaf.paper.demo.ToJS; 4 | import recaf.paper.demo.HTTPResponse; 5 | import recaf.paper.demo.HTTPRequest; 6 | 7 | public class TestWeb extends ToJS.Browser { 8 | 9 | ToJS alg = new ToJS(); 10 | 11 | //BEGIN_HELLOWORLD_WEB 12 | HTTPResponse helloWorld(HTTPRequest req) { 13 | recaf.core.Ref $req = new recaf.core.Ref(req); 14 | return (HTTPResponse )alg.Method(alg.ExpStat(alg.Invoke(alg.Var("document", document), "write", alg.Plus(alg.Plus(alg.Lit("

Hello world "), alg.Invoke(alg.Field(alg.Ref("$req", $req), "params"), "get", alg.Lit("name"))), alg.Lit("

"))))); 15 | } 16 | //END_HELLOWORLD_WEB 17 | 18 | public static void main(String args[]) { 19 | HTTPResponse r = new TestWeb().helloWorld(new HTTPRequest()); 20 | System.out.println(r.getJs()); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestWhile_no_break.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestWhile_no_break { 6 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | public Integer meth() { 9 | return (Integer )alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Decl(() -> Arrays.asList(1,2,3,4,5).iterator(), (recaf.core.Ref> list) -> {return alg.Seq(alg.While(() -> list.value.hasNext(), alg.ExpStat(() -> { sum.value += list.value.next(); return null; })), alg.Return(() -> sum.value));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | System.out.println(new TestWhile_no_break().meth()); //15 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /recaf-runtime/src/test-generated/generated/TestWhile_withBreak.java: -------------------------------------------------------------------------------- 1 | package generated; 2 | import java.util.*; 3 | import recaf.core.cps.StmtJavaCPS; 4 | 5 | public class TestWhile_withBreak { 6 | private StmtJavaCPS alg = new StmtJavaCPS() {}; 7 | 8 | public Integer meth() { 9 | return (Integer )alg.Method(alg.Decl(() -> 0, (recaf.core.Ref sum) -> {return alg.Decl(() -> Arrays.asList(1,2,3,4,5).iterator(), (recaf.core.Ref> list) -> {return alg.Seq(alg.While(() -> list.value.hasNext(), alg.Seq(alg.ExpStat(() -> { sum.value += list.value.next(); return null; }), alg.If(() -> sum.value > 5, alg.Break()))), alg.Return(() -> sum.value));});})); 10 | } 11 | 12 | public static void main(String args[]) { 13 | System.out.println(new TestWhile_withBreak().meth()); //6 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/CompiletimeException.java: -------------------------------------------------------------------------------- 1 | package recaf.tests; 2 | 3 | import java.io.IOException; 4 | import java.util.List; 5 | 6 | import javax.tools.Diagnostic; 7 | import javax.tools.JavaFileObject; 8 | 9 | public class CompiletimeException extends Exception { 10 | 11 | /** 12 | * 13 | */ 14 | private static final long serialVersionUID = 1L; 15 | List> diagnostics; 16 | Exception inner; 17 | String message; 18 | 19 | public CompiletimeException(List> diagnostics) { 20 | this.diagnostics = diagnostics; 21 | } 22 | 23 | public CompiletimeException(IOException e) { 24 | this.inner = e; 25 | } 26 | 27 | public CompiletimeException(String status) { 28 | super(status); 29 | } 30 | 31 | @Override 32 | public String toString() { 33 | StringBuilder errorMessage = new StringBuilder(); 34 | errorMessage.append(super.getMessage()); 35 | if (diagnostics != null && !diagnostics.isEmpty()) { 36 | for (Diagnostic diagnostic : diagnostics) { 37 | errorMessage.append("Code: ") 38 | .append(diagnostic.getCode()) 39 | .append("\nKind: ") 40 | .append(diagnostic.getKind()) 41 | .append("\nPosition: ") 42 | .append(diagnostic.getPosition()) 43 | .append("\nSource: ") 44 | .append(diagnostic.getSource()) 45 | .append("\nInternal Message: ") 46 | .append(diagnostic.getMessage(null)) 47 | .append("\n\t"); 48 | } 49 | } 50 | return errorMessage.toString(); 51 | } 52 | 53 | 54 | 55 | } 56 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/Log4jTestWatcher.java: -------------------------------------------------------------------------------- 1 | package recaf.tests; 2 | 3 | import org.apache.logging.log4j.LogManager; 4 | import org.apache.logging.log4j.Logger; 5 | import org.junit.rules.TestWatcher; 6 | import org.junit.runner.Description; 7 | 8 | public class Log4jTestWatcher extends TestWatcher { 9 | 10 | private final Logger logger; 11 | 12 | public Log4jTestWatcher() { 13 | logger = LogManager.getLogger(); 14 | } 15 | 16 | public Log4jTestWatcher(String loggerName) { 17 | logger = LogManager.getLogger(loggerName); 18 | } 19 | 20 | @Override 21 | protected void failed(Throwable e, Description description) { 22 | logger.error(e.toString()); 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/RascalModuleRunner.java: -------------------------------------------------------------------------------- 1 | package recaf.tests; 2 | 3 | 4 | import java.io.IOException; 5 | import java.io.PrintWriter; 6 | 7 | import org.eclipse.imp.pdb.facts.ISourceLocation; 8 | import org.eclipse.imp.pdb.facts.IValue; 9 | import org.eclipse.imp.pdb.facts.io.StandardTextWriter; 10 | import org.rascalmpl.interpreter.Evaluator; 11 | import org.rascalmpl.shell.ShellEvaluatorFactory; 12 | 13 | public class RascalModuleRunner{ 14 | 15 | private final Evaluator eval; 16 | 17 | public RascalModuleRunner(PrintWriter stdout, PrintWriter stderr) { 18 | eval = ShellEvaluatorFactory.getDefaultEvaluator(stdout, stderr); 19 | } 20 | 21 | public void addRascalSearchPathContributor(ISourceLocation loc){ 22 | eval.addRascalSearchPath(loc); 23 | } 24 | 25 | public void run(String module, String[] args) throws IOException { 26 | if (module.endsWith(".rsc")) { 27 | module = module.substring(0, module.length() - 4); 28 | } 29 | module = module.replaceAll("/", "::"); 30 | 31 | eval.doImport(null, module); 32 | //eval.eval("") 33 | IValue v = eval.main(null, module, "main", args); 34 | 35 | if (v != null) { 36 | new StandardTextWriter(true).write(v, eval.getStdOut()); 37 | eval.getStdOut().flush(); 38 | } 39 | 40 | return; 41 | } 42 | 43 | } -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestAsyncExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestAsyncExtension extends BaseTest { 10 | 11 | @Test 12 | public void TestAsyncNoAwait() throws CompiletimeException, RuntimeException { 13 | String output = compileAndRun("TestAsyncNoAwait"); 14 | Assert.assertEquals("41", output); 15 | } 16 | 17 | @Test 18 | public void TestAsyncWithAwait() throws CompiletimeException, RuntimeException { 19 | String output = compileAndRun("TestAsyncWithAwait"); 20 | Assert.assertEquals("42", output); 21 | } 22 | 23 | @Test 24 | public void TestAsyncComplex() throws CompiletimeException, RuntimeException { 25 | String output = compileAndRun("TestAsyncComplex"); 26 | Assert.assertEquals("main\n" 27 | + "delayed op\n" 28 | + "delayed op\n" 29 | + "84", output); 30 | } 31 | 32 | @Test 33 | public void TestFibRecAsync() throws CompiletimeException, RuntimeException { 34 | String output = compileAndRun("TestFibRecAsync"); 35 | Assert.assertEquals("55", output); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestBacktrackingExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestBacktrackingExtension extends BaseTest { 10 | @Test 11 | public void TestBacktracking() throws CompiletimeException, RuntimeException { 12 | String output = compileAndRun("TestBacktracking"); 13 | Assert.assertEquals("[(2, 4)]", output); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestIterExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestIterExtension extends BaseTest { 10 | 11 | @Test 12 | public void TestIterStreamLibrary() throws CompiletimeException, RuntimeException { 13 | compile("PStream"); 14 | 15 | String output = compileAndRun("TestPullStreams"); 16 | Assert.assertEquals("22", output); 17 | } 18 | 19 | @Test 20 | public void TestFibIter() throws CompiletimeException, RuntimeException { 21 | String output = compileAndRun("TestFibIter"); 22 | Assert.assertEquals("55", output); 23 | } 24 | 25 | @Test 26 | public void TestIter_YieldEachRec() throws CompiletimeException, RuntimeException { 27 | String output = compileAndRun("TestIter_YieldEachRec"); 28 | Assert.assertEquals("i = 10\n" + 29 | "i = 9\n" + 30 | "i = 8\n" + 31 | "i = 7\n" + 32 | "i = 6\n" + 33 | "i = 5\n" + 34 | "i = 4\n" + 35 | "i = 3\n" + 36 | "i = 2\n" + 37 | "i = 1", output); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestMaybeExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestMaybeExtension extends BaseTest { 10 | 11 | @Test 12 | public void TestMaybe() throws CompiletimeException { 13 | String output = compileAndRun("TestMaybe"); 14 | Assert.assertEquals("maybe\n" + 15 | "Yes\n" + 16 | "43", output); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestStreamExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestStreamExtension extends BaseTest { 10 | 11 | @Test 12 | public void TestStream_with_yield() throws CompiletimeException, RuntimeException { 13 | String output = compileAndRun("TestStream_with_yield"); 14 | Assert.assertEquals("1\n" + 15 | "2\n" + 16 | "3\n" + 17 | "4\n" + 18 | "5", output); 19 | } 20 | 21 | @Test 22 | public void TestStream_with_yieldFrom() throws CompiletimeException, RuntimeException { 23 | String output = compileAndRun("TestStream_with_yieldFrom"); 24 | Assert.assertEquals("1\n" + 25 | "2\n" + 26 | "3\n" + 27 | "11\n" + 28 | "22\n" + 29 | "33\n" + 30 | "44\n" + 31 | "55\n" + 32 | "4\n" + 33 | "5", output); 34 | } 35 | 36 | @Test 37 | public void TestStream_with_await() throws CompiletimeException, RuntimeException { 38 | String output = compileAndRun("TestStream_with_await"); 39 | Assert.assertEquals("1\n" + 40 | "2\n" + 41 | "42\n" + 42 | "4\n" + 43 | "5", output); 44 | } 45 | 46 | @Test 47 | public void TestStream_with_awaitFor() throws CompiletimeException, RuntimeException { 48 | String output = compileAndRun("TestStream_with_awaitFor"); 49 | Assert.assertEquals("1\n" + 50 | "42\n" + 51 | "42\n" + 52 | "42\n" + 53 | "42\n" + 54 | "42", output); 55 | } 56 | 57 | @Test 58 | public void TestStream_complex() throws CompiletimeException, RuntimeException { 59 | String output = compileAndRun("TestStream_Complex"); 60 | Assert.assertEquals("0\n" + 61 | "1\n" + 62 | "3\n" + 63 | "6\n" + 64 | "10\n" + 65 | "15", output); 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/extensions/TestUsingExtension.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.extensions; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestUsingExtension extends BaseTest { 10 | 11 | @Test 12 | public void TestUsing() throws CompiletimeException { 13 | String output = compileAndRun("TestUsing"); 14 | Assert.assertEquals("test", output); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/java/recaf/tests/virtualization/TestVirtualizationExpressions.java: -------------------------------------------------------------------------------- 1 | package recaf.tests.virtualization; 2 | 3 | import org.junit.Assert; 4 | import org.junit.Test; 5 | 6 | import recaf.tests.BaseTest; 7 | import recaf.tests.CompiletimeException; 8 | 9 | public class TestVirtualizationExpressions extends BaseTest { 10 | 11 | @Test 12 | public void TestPrivateConstructor() throws CompiletimeException, RuntimeException { 13 | String output = compileAndRun("TestExprPrivateConstructor"); 14 | 15 | Assert.assertEquals("AA(0)", output); 16 | } 17 | 18 | @Test 19 | public void TestNoConstructor() throws CompiletimeException, RuntimeException { 20 | String output = compileAndRun("TestExprNoConstructor"); 21 | 22 | Assert.assertEquals("AB(0)", output); 23 | } 24 | 25 | @Test 26 | public void TestSimpleMethodLookup() throws CompiletimeException, RuntimeException { 27 | String output = compileAndRun("TestExprSimpleMethodLookup"); 28 | Assert.assertEquals("4", output); 29 | } 30 | 31 | @Test 32 | public void TestInheritanceMethodLookup() throws CompiletimeException, RuntimeException { 33 | String output = compileAndRun("TestExprInheritanceMethodLookup"); 34 | Assert.assertEquals("-1", output); 35 | } 36 | 37 | 38 | @Test 39 | public void TestPlus() throws CompiletimeException, RuntimeException { 40 | String output = compileAndRun("TestExprPlus"); 41 | Assert.assertEquals("2\n2.0\n2.0\n2.0\n11\n11\n11.0\n1.01\n1.01\n11.0\n2.0\n2.0\n2.0\n2.0\n2.0\n11", output); 42 | } 43 | 44 | @Test 45 | public void TestInvokeSuper() throws CompiletimeException, RuntimeException { 46 | String output = compileAndRun("TestExprInvokeSuper"); 47 | Assert.assertEquals("son(BaseTestExprInvokeSuper)", output); 48 | } 49 | 50 | @Test 51 | public void TestFieldSuper() throws CompiletimeException, RuntimeException { 52 | String output = compileAndRun("TestExprFieldSuper"); 53 | Assert.assertEquals("5\n3", output); 54 | } 55 | 56 | @Test 57 | public void TestAnd() throws CompiletimeException, RuntimeException { 58 | String output = compileAndRun("TestExprAnd"); 59 | Assert.assertEquals("false\n0\nfalse\n1", output); 60 | } 61 | 62 | } 63 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/resources/log4j2.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | -------------------------------------------------------------------------------- /recaf-runtime/src/test/resources/test: -------------------------------------------------------------------------------- 1 | test -------------------------------------------------------------------------------- /resources/SWUL.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cwi-swat/recaf/70741af767191a126a7fac9e37ca80dcd373107b/resources/SWUL.png -------------------------------------------------------------------------------- /resources/recaf.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cwi-swat/recaf/70741af767191a126a7fac9e37ca80dcd373107b/resources/recaf.png -------------------------------------------------------------------------------- /testgen: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | mvn -DGEN=true clean dependency:copy-dependencies test -------------------------------------------------------------------------------- /testnogen: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | mvn -DGEN=false clean dependency:copy-dependencies test 4 | --------------------------------------------------------------------------------