bundles/org.simantics.scl.runtime/generation/org/simantics/scl/runtime/generation/GenerateFunctions.java

   1 package org.simantics.scl.runtime.generation;\r
   2 \r
   3 import java.io.File;\r
   4 import java.io.FileOutputStream;\r
   5 import java.io.PrintStream;\r
   6 import java.net.URL;\r
   7 \r
   8 public class GenerateFunctions {\r
   9     \r
  10     public static final String PACKAGE = "org.simantics.scl.runtime.function";\r
  11     public static final int MAX_ARITY = 8;\r
  12     \r
  13     public static final String HEADER =\r
  14             "/**\n"\r
  15           + " * This code is generated in " + GenerateFunctions.class.getName() + ".\n"\r
  16           + " * Do not edit manually!\n"\r
  17           + " */" \r
  18             ;\r
  19     \r
  20     public static void generateFunctionN(PrintStream p, int n) {\r
  21         p.println(HEADER);\r
  22         p.println("package " + PACKAGE + ";");\r
  23         p.println();        \r
  24         p.print("public interface Function"+n+"<");\r
  25         for(int i=0;i<n;++i)\r
  26             p.print("P" + i + ",");\r
  27         p.println("R> {");\r
  28         p.print("    R apply(");\r
  29         for(int i=0;i<n;++i) {\r
  30             if(i>0)\r
  31                 p.print(", ");\r
  32             p.print("P"+i+" p" + i);\r
  33         }\r
  34         p.println(");");\r
  35         p.println("}");\r
  36     }\r
  37     \r
  38     public static void generateFunctionN(PrintStream p) {\r
  39         p.println(HEADER);\r
  40         p.println("package " + PACKAGE + ";");\r
  41         p.println();\r
  42         p.println("public interface FunctionN {");\r
  43         p.println("    Object applyArray(Object ... ps);");\r
  44         p.println("}");\r
  45     }\r
  46     \r
  47     public static void generateFunction(PrintStream p) {\r
  48         p.println(HEADER);\r
  49         p.println("package " + PACKAGE + ";");\r
  50         p.println();\r
  51         //p.println("@SuppressWarnings(\"all\")");\r
  52         p.print("public interface Function<");\r
  53         for(int k=0;k<MAX_ARITY;++k) {\r
  54             p.print("P"+k+",");\r
  55         }\r
  56         for(int k=1;k<=MAX_ARITY;++k) {\r
  57             p.print("R"+k);\r
  58             if(k < MAX_ARITY)\r
  59                 p.print(",");\r
  60         }\r
  61         p.println("> extends");        \r
  62         for(int k=1;k<=MAX_ARITY;++k) {\r
  63             p.print("    Function" + k + "<");\r
  64             for(int i=0;i<k;++i) {\r
  65                 p.print("P"+i+",");\r
  66             }\r
  67             p.println("R"+k+">,");\r
  68         }\r
  69         p.println("    FunctionN {");\r
  70         p.println("}");\r
  71     }\r
  72     \r
  73     public static void generateFunctionImplN(PrintStream p, int n) {\r
  74         p.println(HEADER);\r
  75         p.println("package " + PACKAGE + ";");\r
  76         p.println();\r
  77         p.println("import java.util.Arrays;");\r
  78         p.println();\r
  79         p.println("@SuppressWarnings(\"all\")");\r
  80         p.print("public abstract class FunctionImpl" + n + "<");\r
  81         for(int i=0;i<n;++i)\r
  82             p.print("P" + i + ",");\r
  83         p.print("R> implements Function<");\r
  84         for(int i=0;i<n;++i)\r
  85             p.print("P" + i + ",");\r
  86         for(int i=n;i<MAX_ARITY;++i)\r
  87             p.print("Object,");\r
  88         for(int i=1;i<=MAX_ARITY;++i) {\r
  89             if(i == n)\r
  90                 p.print("R");\r
  91             else \r
  92                 p.print("Object");\r
  93             if(i < MAX_ARITY)\r
  94                 p.print(",");\r
  95         }\r
  96         p.println("> {");\r
  97         for(int k=1;k<Math.min(n, MAX_ARITY+1);++k) {\r
  98             p.println("    @Override");\r
  99             p.print("    public Object apply(");\r
 100             for(int i=0;i<k;++i) {\r
 101                 if(i>0)\r
 102                     p.print(", ");\r
 103                 p.print("Object p" + i);\r
 104             }\r
 105             p.println(") {");\r
 106             p.print("        return new UnsaturatedFunction" + k + "(this");\r
 107             for(int i=0;i<k;++i)\r
 108                 p.print(", p" + i);\r
 109             p.println(");");\r
 110             p.println("    }");\r
 111             p.println();\r
 112         }\r
 113         {\r
 114             if(n <= MAX_ARITY)\r
 115                 p.println("    @Override");\r
 116             p.print("    public abstract R apply(");\r
 117             for(int i=0;i<n;++i) {\r
 118                 if(i>0)\r
 119                     p.print(", ");\r
 120                 p.print("P"+i+" p" + i);\r
 121             }\r
 122             p.println(");");\r
 123             p.println();\r
 124         }\r
 125         for(int k=n+1;k<=MAX_ARITY;++k) {\r
 126             p.println("    @Override");\r
 127             p.print("    public Object apply(");\r
 128             for(int i=0;i<k;++i) {\r
 129                 if(i>0)\r
 130                     p.print(", ");\r
 131                 p.print("Object p" + i);\r
 132             }\r
 133             p.println(") {");\r
 134             p.println("        try {");\r
 135             p.print("            return ((Function)apply(");\r
 136             for(int i=0;i<n;++i) {\r
 137                 if(i>0)\r
 138                     p.print(", ");\r
 139                 p.print("(P"+i+")p" + i);\r
 140             }\r
 141             p.print(")).apply(");\r
 142             for(int i=n;i<k;++i) {\r
 143                 if(i>n)\r
 144                     p.print(", ");\r
 145                 p.print("p" + i);\r
 146             }\r
 147             p.println(");");\r
 148             p.println("        } catch(ClassCastException e) {");\r
 149             p.println("            throw new CalledWithTooManyParameters();");\r
 150             p.println("        }");\r
 151             p.println("    }");\r
 152             p.println();\r
 153         }\r
 154         p.println("    @Override");\r
 155         p.println("    public Object applyArray(Object ... ps) {");\r
 156         p.println("        switch(ps.length) {");\r
 157         for(int k=0;k<=MAX_ARITY+n;++k) {\r
 158             p.println("        case " + k + ":");\r
 159             if(k==0)\r
 160                 p.println("            return this;");\r
 161             else if(k < n) {\r
 162                 p.print("            return new UnsaturatedFunction" + k + "(this");\r
 163                 for(int i=0;i<k;++i)\r
 164                     p.print(", ps[" + i + "]");\r
 165                 p.println(");");\r
 166             }\r
 167             else if(k == n) {\r
 168                 p.print("            return apply(");\r
 169                 for(int i=0;i<k;++i) {\r
 170                     if(i > 0)\r
 171                         p.print(", ");\r
 172                     p.print("(P"+i+")ps[" + i + "]");\r
 173                 }\r
 174                 p.println(");");\r
 175             }\r
 176             else if(k <= n + MAX_ARITY) {\r
 177                 p.println("            try {");\r
 178                 p.print("                return ((Function)apply(");\r
 179                 for(int i=0;i<n;++i) {\r
 180                     if(i>0)\r
 181                         p.print(", ");\r
 182                     p.print("(P"+i+")ps[" + i + "]");\r
 183                 }\r
 184                 p.print(")).apply(");\r
 185                 for(int i=n;i<k;++i) {\r
 186                     if(i>n)\r
 187                         p.print(", ");\r
 188                     p.print("ps[" + i + "]");\r
 189                 }\r
 190                 p.println(");");\r
 191                 p.println("            } catch(ClassCastException e) {");\r
 192                 p.println("                throw new CalledWithTooManyParameters();");\r
 193                 p.println("            }");\r
 194             }\r
 195         }\r
 196         {\r
 197             p.println("        default:");\r
 198             p.println("            try {");\r
 199             p.print("                return ((Function)apply(");\r
 200             for(int i=0;i<n;++i) {\r
 201                 if(i>0)\r
 202                     p.print(", ");\r
 203                 p.print("(P"+i+")ps[" + i + "]");\r
 204             }\r
 205             p.println(")).apply(Arrays.copyOfRange(ps, "+n+", ps.length));");\r
 206             p.println("            } catch(ClassCastException e) {");\r
 207             p.println("                throw new CalledWithTooManyParameters();");\r
 208             p.println("            }");\r
 209         }\r
 210         p.println("        }");\r
 211         p.println("    }");\r
 212         p.println("}");\r
 213     }\r
 214     \r
 215     public static void generateFunctionImplN(PrintStream p) {\r
 216         p.println(HEADER);\r
 217         p.println("package " + PACKAGE + ";");\r
 218         p.println();\r
 219         p.println("import java.util.Arrays;");\r
 220         p.println();\r
 221         p.println("@SuppressWarnings(\"all\")");\r
 222         p.println("public abstract class FunctionImplN implements Function {");\r
 223         p.println("    int arity;");\r
 224         p.println();\r
 225         p.println("    public FunctionImplN(int arity) {");\r
 226         p.println("        if(arity < 1)");\r
 227         p.println("            throw new IllegalArgumentException();");\r
 228         p.println("        this.arity = arity;");\r
 229         p.println("    }");\r
 230         p.println();\r
 231         for(int k=1;k<=MAX_ARITY;++k) {\r
 232             p.println("    @Override");\r
 233             p.print("    public Object apply(");\r
 234             for(int i=0;i<k;++i) {\r
 235                 if(i>0)\r
 236                     p.print(", ");\r
 237                 p.print("Object p" + i);\r
 238             }\r
 239             p.println(") {");\r
 240             p.println("        try {");\r
 241             p.println("            switch(arity) {");\r
 242             for(int i=1;i<k;++i) {\r
 243                 p.print("            case " + i + ": return ((Function)doApply(");\r
 244                 for(int j=0;j<i;++j) {\r
 245                     if(j>0)\r
 246                         p.print(", ");\r
 247                     p.print("p" + j);\r
 248                 }\r
 249                 p.print(")).apply(");\r
 250                 for(int j=i;j<k;++j) {\r
 251                     if(j>i)\r
 252                         p.print(", ");\r
 253                     p.print("p" + j);\r
 254                 }\r
 255                 p.println(");");\r
 256             }\r
 257             p.print("            case " + k + ": return doApply(");\r
 258             for(int i=0;i<k;++i) {\r
 259                 if(i>0)\r
 260                     p.print(", ");\r
 261                 p.print("p" + i);\r
 262             }\r
 263             p.println(");");\r
 264             p.print("            default: return new UnsaturatedFunction" + k + "(this");\r
 265             for(int i=0;i<k;++i)\r
 266                 p.print(", p" + i);\r
 267             p.println(");");\r
 268             p.println("            }");\r
 269             p.println("        } catch(ClassCastException e) {");\r
 270             p.println("            throw new CalledWithTooManyParameters();");\r
 271             p.println("        }");\r
 272             p.println("    }");\r
 273             p.println();\r
 274         }\r
 275         p.println("    public abstract Object doApply(Object ... ps);");\r
 276         p.println();\r
 277         p.println("    @Override");\r
 278         p.println("    public Object applyArray(Object ... ps) {");\r
 279         p.println("        if(ps.length == arity)");\r
 280         p.println("            return doApply(ps);");\r
 281         p.println("        else if(ps.length < arity)");\r
 282         p.println("            return new UnsaturatedFunctionN(this, ps);");\r
 283         p.println("        else /* ps.length > arity */ {");\r
 284         p.println("            try {");\r
 285         p.println("                return ((Function)doApply(Arrays.copyOf(ps, arity))).applyArray(Arrays.copyOfRange(ps, arity, ps.length));");\r
 286         p.println("            } catch(ClassCastException e) {");\r
 287         p.println("                throw new CalledWithTooManyParameters();");\r
 288         p.println("            }");\r
 289         p.println("        }");\r
 290         p.println("    }");\r
 291         p.println("}");\r
 292     }\r
 293     \r
 294     public static void generateUnsaturatedFunctionN(PrintStream p, int n) {\r
 295         p.println(HEADER);\r
 296         p.println("package " + PACKAGE + ";");\r
 297         p.println();\r
 298         p.println("@SuppressWarnings(\"all\")");\r
 299         p.println("public class UnsaturatedFunction" + n + " implements Function {");\r
 300         p.println("    private final Function f;");\r
 301         for(int i=0;i<n;++i)\r
 302             p.println("    private final Object p" + i + ";");\r
 303         p.println();\r
 304         p.print("    public UnsaturatedFunction" + n + "(Function f");\r
 305         for(int i=0;i<n;++i)\r
 306             p.print(", Object p" + i);\r
 307         p.println(") {");\r
 308         p.println("        this.f = f;");\r
 309         for(int i=0;i<n;++i)\r
 310             p.println("        this.p" + i + " = p" + i + ";");\r
 311         p.println("    }");\r
 312         p.println();\r
 313         for(int k=1;k<=MAX_ARITY;++k) {\r
 314             p.println("    @Override");\r
 315             p.print("    public Object apply(");\r
 316             for(int i=0;i<k;++i) {\r
 317                 if(i>0)\r
 318                     p.print(", ");\r
 319                 p.print("Object p" + (i + n));\r
 320             }\r
 321             p.println(") {");\r
 322             if(n + k <= MAX_ARITY)\r
 323                 p.print("        return f.apply(");\r
 324             else\r
 325                 p.print("        return f.applyArray(");\r
 326             for(int i=0;i<k+n;++i) {\r
 327                 if(i>0)\r
 328                     p.print(", ");\r
 329                 p.print("p" + i);\r
 330             }\r
 331             p.println(");");\r
 332             p.println("    }");\r
 333             p.println();\r
 334         }\r
 335         {\r
 336             p.println("    @Override");\r
 337             p.println("    public Object applyArray(Object ... ps) {");         \r
 338             p.println("        Object[] nps = new Object[ps.length + " + n + "];");\r
 339             for(int i=0;i<n;++i)\r
 340                 p.println("        nps[" + i + "] = p" + i + ";");\r
 341             p.println("        for(int i=0;i<ps.length;++i)");\r
 342             p.println("            nps[i + " + n + "] = ps[i];");\r
 343             p.println("        return f.applyArray(nps);");\r
 344             p.println("    }");\r
 345         }\r
 346         {\r
 347             p.println("    @Override");\r
 348             p.println("    public String toString() {");\r
 349             p.println("        StringBuilder sb = new StringBuilder();");\r
 350             p.println("        sb.append(\"(\").append(f);");\r
 351             for(int i=0;i<n;++i)\r
 352                 p.println("        sb.append(\" \").append(p"+i+");");\r
 353             p.println("        sb.append(\")\");");\r
 354             p.println("        return sb.toString();");\r
 355             p.println("    }");\r
 356         }\r
 357         p.println("}");\r
 358     }\r
 359     \r
 360     public static void generateUnsaturatedFunctionN(PrintStream p) {\r
 361         p.println(HEADER);\r
 362         p.println("package " + PACKAGE + ";");\r
 363         p.println();\r
 364         p.println("@SuppressWarnings(\"all\")");\r
 365         p.println("public class UnsaturatedFunctionN implements Function {");\r
 366         p.println("    private final Function f;");\r
 367         p.println("    private final Object[] ps;");\r
 368         p.println();\r
 369         p.println("    public UnsaturatedFunctionN(Function f, Object ... ps) {");\r
 370         p.println("        this.f = f;");\r
 371         p.println("        this.ps = ps;");\r
 372         p.println("    }");\r
 373         p.println();\r
 374         for(int k=1;k<=MAX_ARITY;++k) {\r
 375             p.println("    @Override");\r
 376             p.print("    public Object apply(");\r
 377             for(int i=1;i<=k;++i) {\r
 378                 if(i>1)\r
 379                     p.print(", ");\r
 380                 p.print("Object p" + i);\r
 381             }\r
 382             p.println(") {");\r
 383             p.println("        Object[] nps = new Object[ps.length + " + k + "];");\r
 384             p.println("        System.arraycopy(ps, 0, nps, 0, ps.length);");\r
 385             for(int i=1;i<=k;++i)\r
 386                 p.println("        nps[ps.length+" + (i-1) + "] = p" + i+ ";");\r
 387             p.println("        return f.applyArray(nps);");\r
 388             p.println("    }");\r
 389             p.println();\r
 390         }\r
 391         {\r
 392             p.println("    @Override");\r
 393             p.println("    public Object applyArray(Object ... ops) {");\r
 394             p.println("        Object[] nps = new Object[ps.length + ops.length];");\r
 395             p.println("        System.arraycopy(ps, 0, nps, 0, ps.length);");\r
 396             p.println("        System.arraycopy(ops, 0, nps, ps.length, ops.length);");\r
 397             p.println("        return f.applyArray(nps);");\r
 398             p.println("    }");\r
 399         }\r
 400         {\r
 401             p.println("    @Override");\r
 402             p.println("    public String toString() {");\r
 403             p.println("        StringBuilder sb = new StringBuilder();");\r
 404             p.println("        sb.append(\"(\").append(f);");\r
 405             p.println("        for (Object p : ps)");\r
 406             p.println("            sb.append(\" \").append(p);");\r
 407             p.println("        sb.append(\")\");");\r
 408             p.println("        return sb.toString();");\r
 409             p.println("    }");\r
 410         }\r
 411         p.println("}");\r
 412     }\r
 413     \r
 414     public static void main(String[] args) throws Exception {\r
 415         URL url = GenerateFunctions.class.getResource(".");\r
 416         File dir = new File(url.getPath());\r
 417         while(!new File(dir, "src").exists())\r
 418             dir = dir.getParentFile();        \r
 419         dir = new File(dir, "src");\r
 420         dir = new File(dir, PACKAGE.replace('.', '/'));\r
 421         dir.mkdirs();\r
 422         \r
 423         for(int n=1;n<=MAX_ARITY;++n) {\r
 424             PrintStream ps = \r
 425                 new PrintStream(new FileOutputStream(new File(dir, "Function"+n+".java")));\r
 426             generateFunctionN(ps, n);\r
 427         }\r
 428         {\r
 429             PrintStream ps = \r
 430                 new PrintStream(new FileOutputStream(new File(dir, "FunctionN.java")));\r
 431             generateFunctionN(ps);\r
 432         }\r
 433         {\r
 434             PrintStream ps = \r
 435                 new PrintStream(new FileOutputStream(new File(dir, "Function.java")));\r
 436             generateFunction(ps);\r
 437         }\r
 438         \r
 439         for(int n=1;n<=MAX_ARITY;++n) {\r
 440             PrintStream ps = \r
 441                 new PrintStream(new FileOutputStream(new File(dir, "FunctionImpl"+n+".java")));\r
 442             generateFunctionImplN(ps, n);\r
 443         }\r
 444         {\r
 445             PrintStream ps = \r
 446                 new PrintStream(new FileOutputStream(new File(dir, "FunctionImplN.java")));\r
 447             generateFunctionImplN(ps);\r
 448         }\r
 449         for(int n=1;n<=MAX_ARITY;++n) {\r
 450             PrintStream ps = \r
 451                 new PrintStream(new FileOutputStream(new File(dir, "UnsaturatedFunction"+n+".java")));\r
 452             generateUnsaturatedFunctionN(ps, n);\r
 453         }\r
 454         {\r
 455             PrintStream ps = \r
 456                 new PrintStream(new FileOutputStream(new File(dir, "UnsaturatedFunctionN.java")));\r
 457             generateUnsaturatedFunctionN(ps);\r
 458         }\r
 459     }    \r
 460 }\r