Home | History | Annotate | Download | only in src 
      1 /*
      2  * Copyright (C) 2006 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 import java.io.PrintStream;
     18 import java.util.ArrayList;
     19 import java.util.HashSet;
     20 import java.util.Iterator;
     21 import java.util.List;
     22 
     23 public class JniCodeEmitter {
     24 
     25     static final boolean mUseCPlusPlus = true;
     26     protected boolean mUseContextPointer = true;
     27     protected boolean mUseStaticMethods = false;
     28     protected String mClassPathName;
     29     protected ParameterChecker mChecker;
     30     protected List<String> nativeRegistrations = new ArrayList<String>();
     31     boolean needsExit;
     32     protected static String indent = "    ";
     33     HashSet<String> mFunctionsEmitted = new HashSet<String>();
     34 
     35     public static String getJniName(JType jType) {
     36         String jniName = "";
     37         if (jType.isClass()) {
     38             return "L" + jType.getBaseType() + ";";
     39         } else if (jType.isArray()) {
     40             jniName = "[";
     41         }
     42 
     43         String baseType = jType.getBaseType();
     44         if (baseType.equals("int")) {
     45             jniName += "I";
     46         } else if (baseType.equals("float")) {
     47             jniName += "F";
     48         } else if (baseType.equals("boolean")) {
     49             jniName += "Z";
     50         } else if (baseType.equals("short")) {
     51             jniName += "S";
     52         } else if (baseType.equals("long")) {
     53             jniName += "L";
     54         } else if (baseType.equals("byte")) {
     55             jniName += "B";
     56         } else if (baseType.equals("String")) {
     57             jniName += "Ljava/lang/String;";
     58         } else if (baseType.equals("void")) {
     59             // nothing.
     60         } else {
     61             throw new RuntimeException("Uknown primitive basetype " + baseType);
     62         }
     63         return jniName;
     64     }
     65 
     66 
     67     public void emitCode(CFunc cfunc, String original,
     68             PrintStream javaInterfaceStream,
     69             PrintStream javaImplStream,
     70             PrintStream cStream) {
     71         JFunc jfunc;
     72         String signature;
     73         boolean duplicate;
     74 
     75         if (cfunc.hasTypedPointerArg()) {
     76             jfunc = JFunc.convert(cfunc, true);
     77 
     78             // Don't emit duplicate functions
     79             // These may appear because they are defined in multiple
     80             // Java interfaces (e.g., GL11/GL11ExtensionPack)
     81             signature = jfunc.toString();
     82             duplicate = false;
     83             if (mFunctionsEmitted.contains(signature)) {
     84                 duplicate = true;
     85             } else {
     86                 mFunctionsEmitted.add(signature);
     87             }
     88 
     89             if (!duplicate) {
     90                 emitNativeDeclaration(jfunc, javaImplStream);
     91                 emitJavaCode(jfunc, javaImplStream);
     92             }
     93             if (javaInterfaceStream != null) {
     94                 emitJavaInterfaceCode(jfunc, javaInterfaceStream);
     95             }
     96             if (!duplicate) {
     97                 emitJniCode(jfunc, cStream);
     98             }
     99         }
    100 
    101         jfunc = JFunc.convert(cfunc, false);
    102 
    103         signature = jfunc.toString();
    104         duplicate = false;
    105         if (mFunctionsEmitted.contains(signature)) {
    106             duplicate = true;
    107         } else {
    108             mFunctionsEmitted.add(signature);
    109         }
    110 
    111         if (!duplicate) {
    112             emitNativeDeclaration(jfunc, javaImplStream);
    113         }
    114         if (javaInterfaceStream != null) {
    115             emitJavaInterfaceCode(jfunc, javaInterfaceStream);
    116         }
    117         if (!duplicate) {
    118             emitJavaCode(jfunc, javaImplStream);
    119             emitJniCode(jfunc, cStream);
    120         }
    121     }
    122 
    123     public void emitNativeDeclaration(JFunc jfunc, PrintStream out) {
    124         out.println("    // C function " + jfunc.getCFunc().getOriginal());
    125         out.println();
    126 
    127         emitFunction(jfunc, out, true, false);
    128     }
    129 
    130     public void emitJavaInterfaceCode(JFunc jfunc, PrintStream out) {
    131         emitFunction(jfunc, out, false, true);
    132     }
    133 
    134     public void emitJavaCode(JFunc jfunc, PrintStream out) {
    135         emitFunction(jfunc, out, false, false);
    136     }
    137 
    138     boolean isPointerFunc(JFunc jfunc) {
    139         String name = jfunc.getName();
    140         return (name.endsWith("Pointer") || name.endsWith("PointerOES"))
    141             && jfunc.getCFunc().hasPointerArg();
    142     }
    143 
    144     void emitFunctionCall(JFunc jfunc, PrintStream out, String iii, boolean grabArray) {
    145         boolean isVoid = jfunc.getType().isVoid();
    146         boolean isPointerFunc = isPointerFunc(jfunc);
    147 
    148         if (!isVoid) {
    149             out.println(iii +
    150                         jfunc.getType() + " _returnValue;");
    151         }
    152         out.println(iii +
    153                     (isVoid ? "" : "_returnValue = ") +
    154                     jfunc.getName() +
    155                     (isPointerFunc ? "Bounds" : "" ) +
    156                     "(");
    157 
    158         int numArgs = jfunc.getNumArgs();
    159         for (int i = 0; i < numArgs; i++) {
    160             String argName = jfunc.getArgName(i);
    161             JType argType = jfunc.getArgType(i);
    162 
    163             if (grabArray && argType.isTypedBuffer()) {
    164                 String typeName = argType.getBaseType();
    165                 typeName = typeName.substring(9, typeName.length() - 6);
    166                 out.println(iii + indent + "get" + typeName + "Array(" + argName + "),");
    167                 out.print(iii + indent + "getOffset(" + argName + ")");
    168             } else {
    169                 out.print(iii + indent + argName);
    170             }
    171             if (i == numArgs - 1) {
    172                 if (isPointerFunc) {
    173                     out.println(",");
    174                     out.println(iii + indent + argName + ".remaining()");
    175                 } else {
    176                     out.println();
    177                 }
    178             } else {
    179                 out.println(",");
    180             }
    181         }
    182 
    183         out.println(iii + ");");
    184     }
    185 
    186     void printIfcheckPostamble(PrintStream out, boolean isBuffer, boolean emitExceptionCheck,
    187             String iii) {
    188                 printIfcheckPostamble(out, isBuffer, emitExceptionCheck,
    189                                       "offset", "_remaining", iii);
    190             }
    191 
    192     void printIfcheckPostamble(PrintStream out, boolean isBuffer, boolean emitExceptionCheck,
    193             String offset, String remaining, String iii) {
    194                 out.println(iii + "    default:");
    195                 out.println(iii + "        _needed = 0;");
    196                 out.println(iii + "        break;");
    197                 out.println(iii + "}");
    198 
    199                 out.println(iii + "if (" + remaining + " < _needed) {");
    200                 if (emitExceptionCheck) {
    201                     out.println(iii + indent + "_exception = 1;");
    202                 }
    203                 out.println(iii + indent +
    204                             (mUseCPlusPlus ? "_env" : "(*_env)") +
    205                             "->ThrowNew(" +
    206                             (mUseCPlusPlus ? "" : "_env, ") +
    207                             "IAEClass, " +
    208                             "\"" +
    209                             (isBuffer ?
    210                              "remaining()" : "length - " + offset) +
    211                             " < needed\");");
    212                 out.println(iii + indent + "goto exit;");
    213                 needsExit = true;
    214                 out.println(iii + "}");
    215             }
    216 
    217     boolean isNullAllowed(CFunc cfunc) {
    218         String[] checks = mChecker.getChecks(cfunc.getName());
    219         int index = 1;
    220         if (checks != null) {
    221             while (index < checks.length) {
    222                 if (checks[index].equals("return")) {
    223                     index += 2;
    224                 } else if (checks[index].startsWith("check")) {
    225                     index += 3;
    226                 } else if (checks[index].equals("ifcheck")) {
    227                     index += 5;
    228                 } else if (checks[index].equals("unsupported")) {
    229                     index += 1;
    230                 } else if (checks[index].equals("requires")) {
    231                     index += 2;
    232                 } else if (checks[index].equals("nullAllowed")) {
    233                     return true;
    234                 } else {
    235                     System.out.println("Error: unknown keyword \"" +
    236                                        checks[index] + "\"");
    237                     System.exit(0);
    238                 }
    239             }
    240         }
    241         return false;
    242     }
    243 
    244     String getErrorReturnValue(CFunc cfunc) {
    245         CType returnType = cfunc.getType();
    246         boolean isVoid = returnType.isVoid();
    247         if (isVoid) {
    248             return null;
    249         }
    250 
    251         String[] checks = mChecker.getChecks(cfunc.getName());
    252 
    253         int index = 1;
    254         if (checks != null) {
    255             while (index < checks.length) {
    256                 if (checks[index].equals("return")) {
    257                     return checks[index + 1];
    258                 } else if (checks[index].startsWith("check")) {
    259                     index += 3;
    260                 } else if (checks[index].equals("ifcheck")) {
    261                     index += 5;
    262                 } else if (checks[index].equals("unsupported")) {
    263                     index += 1;
    264                 } else if (checks[index].equals("requires")) {
    265                     index += 2;
    266                 } else if (checks[index].equals("nullAllowed")) {
    267                     index += 1;
    268                 } else {
    269                     System.out.println("Error: unknown keyword \"" +
    270                                        checks[index] + "\"");
    271                     System.exit(0);
    272                 }
    273             }
    274         }
    275 
    276         return null;
    277     }
    278 
    279     boolean isUnsupportedFunc(CFunc cfunc) {
    280         String[] checks = mChecker.getChecks(cfunc.getName());
    281         int index = 1;
    282         if (checks != null) {
    283             while (index < checks.length) {
    284                 if (checks[index].equals("unsupported")) {
    285                     return true;
    286                 } else if (checks[index].equals("requires")) {
    287                     index += 2;
    288                 } else if (checks[index].equals("return")) {
    289                     index += 2;
    290                 } else if (checks[index].startsWith("check")) {
    291                     index += 3;
    292                 } else if (checks[index].equals("ifcheck")) {
    293                     index += 5;
    294                 } else if (checks[index].equals("nullAllowed")) {
    295                     index += 1;
    296                 } else {
    297                     System.out.println("Error: unknown keyword \"" +
    298                                        checks[index] + "\"");
    299                     System.exit(0);
    300                 }
    301             }
    302         }
    303         return false;
    304     }
    305 
    306     String isRequiresFunc(CFunc cfunc) {
    307         String[] checks = mChecker.getChecks(cfunc.getName());
    308         int index = 1;
    309         if (checks != null) {
    310             while (index < checks.length) {
    311                 if (checks[index].equals("unsupported")) {
    312                     index += 1;
    313                 } else if (checks[index].equals("requires")) {
    314                     return checks[index+1];
    315                 } else if (checks[index].equals("return")) {
    316                     index += 2;
    317                 } else if (checks[index].startsWith("check")) {
    318                     index += 3;
    319                 } else if (checks[index].equals("ifcheck")) {
    320                     index += 5;
    321                 } else if (checks[index].equals("nullAllowed")) {
    322                     index += 1;
    323                 } else {
    324                     System.out.println("Error: unknown keyword \"" +
    325                                        checks[index] + "\"");
    326                     System.exit(0);
    327                 }
    328             }
    329         }
    330         return null;
    331     }
    332 
    333     void emitNativeBoundsChecks(CFunc cfunc, String cname, PrintStream out,
    334             boolean isBuffer, boolean emitExceptionCheck, String offset, String remaining, String iii) {
    335 
    336                 String[] checks = mChecker.getChecks(cfunc.getName());
    337 
    338                 boolean lastWasIfcheck = false;
    339 
    340                 int index = 1;
    341                 if (checks != null) {
    342                     while (index < checks.length) {
    343                         if (checks[index].startsWith("check")) {
    344                             if (lastWasIfcheck) {
    345                                 printIfcheckPostamble(out, isBuffer, emitExceptionCheck,
    346                                                       offset, remaining, iii);
    347                             }
    348                             lastWasIfcheck = false;
    349                             if (cname != null && !cname.equals(checks[index + 1])) {
    350                                 index += 3;
    351                                 continue;
    352                             }
    353                             out.println(iii + "if (" + remaining + " < " +
    354                                         checks[index + 2] +
    355                                         ") {");
    356                             if (emitExceptionCheck) {
    357                                 out.println(iii + indent + "_exception = 1;");
    358                             }
    359                     String exceptionClassName = "IAEClass";
    360                     // If the "check" keyword was of the form
    361                     // "check_<class name>", use the class name in the
    362                     // exception to be thrown
    363                     int underscore = checks[index].indexOf('_');
    364                     if (underscore >= 0) {
    365                     exceptionClassName = checks[index].substring(underscore + 1) + "Class";
    366                     }
    367                             out.println(iii + indent +
    368                                         (mUseCPlusPlus ? "_env" : "(*_env)") +
    369                                         "->ThrowNew(" +
    370                                         (mUseCPlusPlus ? "" : "_env, ") +
    371                         exceptionClassName + ", " +
    372                                         "\"" +
    373                                         (isBuffer ?
    374                                          "remaining()" : "length - " + offset) +
    375                                         " < " + checks[index + 2] +
    376                                         "\");");
    377 
    378                             out.println(iii + indent + "goto exit;");
    379                             needsExit = true;
    380                             out.println(iii + "}");
    381 
    382                             index += 3;
    383                         } else if (checks[index].equals("ifcheck")) {
    384                             String[] matches = checks[index + 4].split(",");
    385 
    386                             if (!lastWasIfcheck) {
    387                                 out.println(iii + "int _needed;");
    388                                 out.println(iii +
    389                                             "switch (" +
    390                                             checks[index + 3] +
    391                                             ") {");
    392                             }
    393 
    394                             for (int i = 0; i < matches.length; i++) {
    395                                 out.println("#if defined(" + matches[i] + ")");
    396                                 out.println(iii +
    397                                             "    case " +
    398                                             matches[i] +
    399                                             ":");
    400                                 out.println("#endif // defined(" + matches[i] + ")");
    401                             }
    402                             out.println(iii +
    403                                         "        _needed = " +
    404                                         checks[index + 2] +
    405                                         ";");
    406                             out.println(iii +
    407                                         "        break;");
    408 
    409                             lastWasIfcheck = true;
    410                             index += 5;
    411                         } else if (checks[index].equals("return")) {
    412                             // ignore
    413                             index += 2;
    414                         } else if (checks[index].equals("unsupported")) {
    415                             // ignore
    416                             index += 1;
    417                         } else if (checks[index].equals("requires")) {
    418                             // ignore
    419                             index += 2;
    420                         } else if (checks[index].equals("nullAllowed")) {
    421                             // ignore
    422                             index += 1;
    423                         } else {
    424                             System.out.println("Error: unknown keyword \"" +
    425                                                checks[index] + "\"");
    426                             System.exit(0);
    427                         }
    428                     }
    429                 }
    430 
    431                 if (lastWasIfcheck) {
    432                     printIfcheckPostamble(out, isBuffer, emitExceptionCheck, iii);
    433                 }
    434             }
    435 
    436     boolean hasNonConstArg(JFunc jfunc, CFunc cfunc, List<Integer> nonPrimitiveArgs) {
    437         if (nonPrimitiveArgs.size() > 0) {
    438             for (int i = nonPrimitiveArgs.size() - 1; i >= 0; i--) {
    439                 int idx = nonPrimitiveArgs.get(i).intValue();
    440                 int cIndex = jfunc.getArgCIndex(idx);
    441                 if (jfunc.getArgType(idx).isArray()) {
    442                     if (!cfunc.getArgType(cIndex).isConst()) {
    443                         return true;
    444                     }
    445                 } else if (jfunc.getArgType(idx).isBuffer()) {
    446                     if (!cfunc.getArgType(cIndex).isConst()) {
    447                         return true;
    448                     }
    449                 }
    450             }
    451         }
    452 
    453         return false;
    454     }
    455 
    456     /**
    457      * Emit a function in several variants:
    458      *
    459      * if nativeDecl: public native <returntype> func(args);
    460      *
    461      * if !nativeDecl:
    462      *   if interfaceDecl:  public <returntype> func(args);
    463      *   if !interfaceDecl: public <returntype> func(args) { body }
    464      */
    465     void emitFunction(JFunc jfunc, PrintStream out, boolean nativeDecl, boolean interfaceDecl) {
    466         boolean isPointerFunc = isPointerFunc(jfunc);
    467 
    468         if (!nativeDecl && !interfaceDecl && !isPointerFunc) {
    469             // If it's not a pointer function, we've already emitted it
    470             // with nativeDecl == true
    471             return;
    472         }
    473 
    474         String maybeStatic = mUseStaticMethods ? "static " : "";
    475 
    476         if (isPointerFunc) {
    477             out.println(indent +
    478                         (nativeDecl ? "private " + maybeStatic +"native " :
    479                          (interfaceDecl ? "" : "public ") + maybeStatic) +
    480                         jfunc.getType() + " " +
    481                         jfunc.getName() +
    482                         (nativeDecl ? "Bounds" : "") +
    483                         "(");
    484         } else {
    485             out.println(indent +
    486                         (nativeDecl ? "public " + maybeStatic +"native " :
    487                          (interfaceDecl ? "" : "public ") + maybeStatic) +
    488                         jfunc.getType() + " " +
    489                         jfunc.getName() +
    490                         "(");
    491         }
    492 
    493         int numArgs = jfunc.getNumArgs();
    494         for (int i = 0; i < numArgs; i++) {
    495             String argName = jfunc.getArgName(i);
    496             JType argType = jfunc.getArgType(i);
    497 
    498             out.print(indent + indent + argType + " " + argName);
    499             if (i == numArgs - 1) {
    500                 if (isPointerFunc && nativeDecl) {
    501                     out.println(",");
    502                     out.println(indent + indent + "int remaining");
    503                 } else {
    504                     out.println();
    505                 }
    506             } else {
    507                 out.println(",");
    508             }
    509         }
    510 
    511         if (nativeDecl || interfaceDecl) {
    512             out.println(indent + ");");
    513         } else {
    514             out.println(indent + ") {");
    515 
    516             String iii = indent + indent;
    517 
    518             // emitBoundsChecks(jfunc, out, iii);
    519             emitFunctionCall(jfunc, out, iii, false);
    520 
    521             // Set the pointer after we call the native code, so that if
    522             // the native code throws an exception we don't modify the
    523             // pointer. We assume that the native code is written so that
    524             // if an exception is thrown, then the underlying glXXXPointer
    525             // function will not have been called.
    526 
    527             String fname = jfunc.getName();
    528             if (isPointerFunc) {
    529                 // TODO - deal with VBO variants
    530                 if (fname.equals("glColorPointer")) {
    531                     out.println(iii + "if ((size == 4) &&");
    532                     out.println(iii + "    ((type == GL_FLOAT) ||");
    533                     out.println(iii + "     (type == GL_UNSIGNED_BYTE) ||");
    534                     out.println(iii + "     (type == GL_FIXED)) &&");
    535                     out.println(iii + "    (stride >= 0)) {");
    536                     out.println(iii + indent + "_colorPointer = pointer;");
    537                     out.println(iii + "}");
    538                 } else if (fname.equals("glNormalPointer")) {
    539                     out.println(iii + "if (((type == GL_FLOAT) ||");
    540                     out.println(iii + "     (type == GL_BYTE) ||");
    541                     out.println(iii + "     (type == GL_SHORT) ||");
    542                     out.println(iii + "     (type == GL_FIXED)) &&");
    543                     out.println(iii + "    (stride >= 0)) {");
    544                     out.println(iii + indent + "_normalPointer = pointer;");
    545                     out.println(iii + "}");
    546                 } else if (fname.equals("glTexCoordPointer")) {
    547                     out.println(iii + "if (((size == 2) ||");
    548                     out.println(iii + "     (size == 3) ||");
    549                     out.println(iii + "     (size == 4)) &&");
    550                     out.println(iii + "    ((type == GL_FLOAT) ||");
    551                     out.println(iii + "     (type == GL_BYTE) ||");
    552                     out.println(iii + "     (type == GL_SHORT) ||");
    553                     out.println(iii + "     (type == GL_FIXED)) &&");
    554                     out.println(iii + "    (stride >= 0)) {");
    555                     out.println(iii + indent + "_texCoordPointer = pointer;");
    556                     out.println(iii + "}");
    557                 } else if (fname.equals("glVertexPointer")) {
    558                     out.println(iii + "if (((size == 2) ||");
    559                     out.println(iii + "     (size == 3) ||");
    560                     out.println(iii + "     (size == 4)) &&");
    561                     out.println(iii + "    ((type == GL_FLOAT) ||");
    562                     out.println(iii + "     (type == GL_BYTE) ||");
    563                     out.println(iii + "     (type == GL_SHORT) ||");
    564                     out.println(iii + "     (type == GL_FIXED)) &&");
    565                     out.println(iii + "    (stride >= 0)) {");
    566                     out.println(iii + indent + "_vertexPointer = pointer;");
    567                     out.println(iii + "}");
    568                 } else if (fname.equals("glPointSizePointerOES")) {
    569                     out.println(iii + "if (((type == GL_FLOAT) ||");
    570                     out.println(iii + "     (type == GL_FIXED)) &&");
    571                     out.println(iii + "    (stride >= 0)) {");
    572                     out.println(iii + indent + "_pointSizePointerOES = pointer;");
    573                     out.println(iii + "}");
    574                 } else if (fname.equals("glMatrixIndexPointerOES")) {
    575                     out.println(iii + "if (((size == 2) ||");
    576                     out.println(iii + "     (size == 3) ||");
    577                     out.println(iii + "     (size == 4)) &&");
    578                     out.println(iii + "    ((type == GL_FLOAT) ||");
    579                     out.println(iii + "     (type == GL_BYTE) ||");
    580                     out.println(iii + "     (type == GL_SHORT) ||");
    581                     out.println(iii + "     (type == GL_FIXED)) &&");
    582                     out.println(iii + "    (stride >= 0)) {");
    583                     out.println(iii + indent + "_matrixIndexPointerOES = pointer;");
    584                     out.println(iii + "}");
    585                 } else if (fname.equals("glWeightPointer")) {
    586                     out.println(iii + "if (((size == 2) ||");
    587                     out.println(iii + "     (size == 3) ||");
    588                     out.println(iii + "     (size == 4)) &&");
    589                     out.println(iii + "    ((type == GL_FLOAT) ||");
    590                     out.println(iii + "     (type == GL_BYTE) ||");
    591                     out.println(iii + "     (type == GL_SHORT) ||");
    592                     out.println(iii + "     (type == GL_FIXED)) &&");
    593                     out.println(iii + "    (stride >= 0)) {");
    594                     out.println(iii + indent + "_weightPointerOES = pointer;");
    595                     out.println(iii + "}");
    596                 }
    597             }
    598 
    599             boolean isVoid = jfunc.getType().isVoid();
    600 
    601             if (!isVoid) {
    602                 out.println(indent + indent + "return _returnValue;");
    603             }
    604             out.println(indent + "}");
    605         }
    606         out.println();
    607     }
    608 
    609     public void addNativeRegistration(String s) {
    610         nativeRegistrations.add(s);
    611     }
    612 
    613     public void emitNativeRegistration(String registrationFunctionName,
    614             PrintStream cStream) {
    615         cStream.println("static const char *classPathName = \"" +
    616                         mClassPathName +
    617                         "\";");
    618         cStream.println();
    619 
    620         cStream.println("static JNINativeMethod methods[] = {");
    621 
    622         cStream.println("{\"_nativeClassInit\", \"()V\", (void*)nativeClassInit },");
    623 
    624         Iterator<String> i = nativeRegistrations.iterator();
    625         while (i.hasNext()) {
    626             cStream.println(i.next());
    627         }
    628 
    629         cStream.println("};");
    630         cStream.println();
    631 
    632 
    633         cStream.println("int " + registrationFunctionName + "(JNIEnv *_env)");
    634         cStream.println("{");
    635         cStream.println(indent +
    636                         "int err;");
    637 
    638         cStream.println(indent +
    639                         "err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));");
    640 
    641         cStream.println(indent + "return err;");
    642         cStream.println("}");
    643     }
    644 
    645     public JniCodeEmitter() {
    646         super();
    647     }
    648 
    649     String getJniType(JType jType) {
    650         if (jType.isVoid()) {
    651             return "void";
    652         }
    653 
    654         String baseType = jType.getBaseType();
    655         if (jType.isPrimitive()) {
    656             if (baseType.equals("String")) {
    657                 return "jstring";
    658             } else {
    659                 return "j" + baseType;
    660             }
    661         } else if (jType.isArray()) {
    662             return "j" + baseType + "Array";
    663         } else {
    664             return "jobject";
    665         }
    666     }
    667 
    668     String getJniMangledName(String name) {
    669         name = name.replaceAll("_", "_1");
    670         name = name.replaceAll(";", "_2");
    671         name = name.replaceAll("\\[", "_3");
    672         return name;
    673     }
    674 
    675     public void emitJniCode(JFunc jfunc, PrintStream out) {
    676         CFunc cfunc = jfunc.getCFunc();
    677 
    678         // Emit comment identifying original C function
    679         //
    680         // Example:
    681         //
    682         // /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */
    683         //
    684         out.println("/* " + cfunc.getOriginal() + " */");
    685 
    686         // Emit JNI signature (name)
    687         //
    688         // Example:
    689         //
    690         // void
    691         // android_glClipPlanef__I_3FI
    692         //
    693 
    694         String outName = "android_" + jfunc.getName();
    695         boolean isPointerFunc = isPointerFunc(jfunc);
    696         boolean isVBOPointerFunc = (outName.endsWith("Pointer") ||
    697                 outName.endsWith("PointerOES") ||
    698             outName.endsWith("DrawElements")) &&
    699             !jfunc.getCFunc().hasPointerArg();
    700         if (isPointerFunc) {
    701             outName += "Bounds";
    702         }
    703 
    704         out.print("static ");
    705         out.println(getJniType(jfunc.getType()));
    706         out.print(outName);
    707 
    708         String rsignature = getJniName(jfunc.getType());
    709 
    710         String signature = "";
    711         int numArgs = jfunc.getNumArgs();
    712         for (int i = 0; i < numArgs; i++) {
    713             JType argType = jfunc.getArgType(i);
    714             signature += getJniName(argType);
    715         }
    716         if (isPointerFunc) {
    717             signature += "I";
    718         }
    719 
    720         // Append signature to function name
    721         String sig = getJniMangledName(signature).replace('.', '_').replace('/', '_');
    722         out.print("__" + sig);
    723         outName += "__" + sig;
    724 
    725         signature = signature.replace('.', '/');
    726         rsignature = rsignature.replace('.', '/');
    727 
    728         out.println();
    729         if (rsignature.length() == 0) {
    730             rsignature = "V";
    731         }
    732 
    733         String s = "{\"" +
    734             jfunc.getName() +
    735             (isPointerFunc ? "Bounds" : "") +
    736             "\", \"(" + signature +")" +
    737             rsignature +
    738             "\", (void *) " +
    739             outName +
    740             " },";
    741         nativeRegistrations.add(s);
    742 
    743         List<Integer> nonPrimitiveArgs = new ArrayList<Integer>();
    744         List<Integer> stringArgs = new ArrayList<Integer>();
    745         int numBufferArgs = 0;
    746         List<String> bufferArgNames = new ArrayList<String>();
    747 
    748         // Emit JNI signature (arguments)
    749         //
    750         // Example:
    751         //
    752         // (JNIEnv *_env, jobject this, jint plane, jfloatArray equation_ref, jint offset) {
    753         //
    754         out.print("  (JNIEnv *_env, jobject _this");
    755         for (int i = 0; i < numArgs; i++) {
    756             out.print(", ");
    757             JType argType = jfunc.getArgType(i);
    758             String suffix;
    759             if (!argType.isPrimitive()) {
    760                 if (argType.isArray()) {
    761                     suffix = "_ref";
    762                 } else {
    763                     suffix = "_buf";
    764                 }
    765                 nonPrimitiveArgs.add(new Integer(i));
    766                 if (jfunc.getArgType(i).isBuffer()) {
    767                     int cIndex = jfunc.getArgCIndex(i);
    768                     String cname = cfunc.getArgName(cIndex);
    769                     bufferArgNames.add(cname);
    770                     numBufferArgs++;
    771                 }
    772             } else {
    773                 suffix = "";
    774             }
    775             if (argType.isString()) {
    776                 stringArgs.add(new Integer(i));
    777             }
    778 
    779             out.print(getJniType(argType) + " " + jfunc.getArgName(i) + suffix);
    780         }
    781         if (isPointerFunc) {
    782             out.print(", jint remaining");
    783         }
    784         out.println(") {");
    785 
    786         int numArrays = 0;
    787         int numBuffers = 0;
    788         int numStrings = 0;
    789         for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
    790             int idx = nonPrimitiveArgs.get(i).intValue();
    791             JType argType = jfunc.getArgType(idx);
    792             if (argType.isArray()) {
    793                 ++numArrays;
    794             }
    795             if (argType.isBuffer()) {
    796                 ++numBuffers;
    797             }
    798             if (argType.isString()) {
    799                 ++numStrings;
    800             }
    801         }
    802 
    803         // Emit method body
    804 
    805         // Emit local variable declarations for _exception and _returnValue
    806         //
    807         // Example:
    808         //
    809         // android::gl::ogles_context_t *ctx;
    810         //
    811         // jint _exception;
    812         // GLenum _returnValue;
    813         //
    814         CType returnType = cfunc.getType();
    815         boolean isVoid = returnType.isVoid();
    816 
    817         boolean isUnsupported = isUnsupportedFunc(cfunc);
    818         if (isUnsupported) {
    819             out.println(indent +
    820                         "_env->ThrowNew(UOEClass,");
    821             out.println(indent +
    822                         "    \"" + cfunc.getName() + "\");");
    823             if (!isVoid) {
    824                 String retval = getErrorReturnValue(cfunc);
    825                 out.println(indent + "return " + retval + ";");
    826             }
    827             out.println("}");
    828             out.println();
    829             return;
    830         }
    831 
    832         String requiresExtension = isRequiresFunc(cfunc);
    833         if (requiresExtension != null) {
    834             out.println(indent +
    835                         "if (! supportsExtension(_env, _this, have_" + requiresExtension + "ID)) {");
    836             out.println(indent + indent +
    837                         "_env->ThrowNew(UOEClass,");
    838             out.println(indent + indent +
    839                         "    \"" + cfunc.getName() + "\");");
    840             if (isVoid) {
    841                 out.println(indent + indent + "    return;");
    842             } else {
    843                 String retval = getErrorReturnValue(cfunc);
    844                 out.println(indent + indent + "    return " + retval + ";");
    845             }
    846             out.println(indent + "}");
    847         }
    848         if (mUseContextPointer) {
    849             out.println(indent +
    850                 "android::gl::ogles_context_t *ctx = getContext(_env, _this);");
    851         }
    852 
    853         boolean initializeReturnValue = stringArgs.size() > 0;
    854 
    855         boolean emitExceptionCheck = (numArrays > 0 || numBuffers > 0 || numStrings > 0) &&
    856             hasNonConstArg(jfunc, cfunc, nonPrimitiveArgs);
    857         // mChecker.getChecks(cfunc.getName()) != null
    858 
    859         // Emit an _exeption variable if there will be error checks
    860         if (emitExceptionCheck) {
    861             out.println(indent + "jint _exception = 0;");
    862         }
    863 
    864         // Emit a single _array or multiple _XXXArray variables
    865         if (numBufferArgs == 1) {
    866                 out.println(indent + "jarray _array = (jarray) 0;");
    867         } else {
    868             for (int i = 0; i < numBufferArgs; i++) {
    869                 out.println(indent + "jarray _" + bufferArgNames.get(i) +
    870                             "Array = (jarray) 0;");
    871             }
    872         }
    873         if (!isVoid) {
    874             String retval = getErrorReturnValue(cfunc);
    875             if (retval != null) {
    876                 out.println(indent + returnType.getDeclaration() +
    877                             " _returnValue = " + retval + ";");
    878             } else if (initializeReturnValue) {
    879                 out.println(indent + returnType.getDeclaration() +
    880                 " _returnValue = 0;");
    881             } else {
    882                 out.println(indent + returnType.getDeclaration() +
    883                             " _returnValue;");
    884             }
    885         }
    886 
    887         // Emit local variable declarations for pointer arguments
    888         //
    889         // Example:
    890         //
    891         // GLfixed *eqn_base;
    892         // GLfixed *eqn;
    893         //
    894         String offset = "offset";
    895         String remaining = "_remaining";
    896         if (nonPrimitiveArgs.size() > 0) {
    897             for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
    898                 int idx = nonPrimitiveArgs.get(i).intValue();
    899                 int cIndex = jfunc.getArgCIndex(idx);
    900                 String cname = cfunc.getArgName(cIndex);
    901 
    902                 CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
    903                 String decl = type.getDeclaration();
    904                 if (jfunc.getArgType(idx).isArray()) {
    905                     out.println(indent +
    906                                 decl +
    907                                 (decl.endsWith("*") ? "" : " ") +
    908                                 jfunc.getArgName(idx) +
    909                                 "_base = (" + decl + ") 0;");
    910                 }
    911                 remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
    912                     "_" + cname + "Remaining";
    913                 out.println(indent +
    914                             "jint " + remaining + ";");
    915                 out.println(indent +
    916                             decl +
    917                             (decl.endsWith("*") ? "" : " ") +
    918                             jfunc.getArgName(idx) +
    919                             " = (" + decl + ") 0;");
    920             }
    921 
    922             out.println();
    923         }
    924 
    925         // Emit local variable declaration for strings
    926         if (stringArgs.size() > 0) {
    927             for (int i = 0; i < stringArgs.size(); i++) {
    928                 int idx = stringArgs.get(i).intValue();
    929                 int cIndex = jfunc.getArgCIndex(idx);
    930                 String cname = cfunc.getArgName(cIndex);
    931 
    932                 out.println(indent + "const char* _native" + cname + " = 0;");
    933             }
    934 
    935             out.println();
    936         }
    937 
    938         // Null pointer checks and GetStringUTFChars
    939         if (stringArgs.size() > 0) {
    940             for (int i = 0; i < stringArgs.size(); i++) {
    941                 int idx = stringArgs.get(i).intValue();
    942                 int cIndex = jfunc.getArgCIndex(idx);
    943                 String cname = cfunc.getArgName(cIndex);
    944 
    945                 CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
    946                 String decl = type.getDeclaration();
    947                 out.println(indent + "if (!" + cname + ") {");
    948                 out.println(indent + "    _env->ThrowNew(IAEClass, \"" + cname + " == null\");");
    949                 out.println(indent + "    goto exit;");
    950                 needsExit = true;
    951                 out.println(indent + "}");
    952 
    953                 out.println(indent + "_native" + cname + " = _env->GetStringUTFChars(" + cname + ", 0);");
    954             }
    955 
    956             out.println();
    957         }
    958 
    959         // Emit 'GetPrimitiveArrayCritical' for arrays
    960         // Emit 'GetPointer' calls for Buffer pointers
    961         int bufArgIdx = 0;
    962         if (nonPrimitiveArgs.size() > 0) {
    963             for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
    964                 int idx = nonPrimitiveArgs.get(i).intValue();
    965                 int cIndex = jfunc.getArgCIndex(idx);
    966 
    967                 String cname = cfunc.getArgName(cIndex);
    968                 offset = numArrays <= 1 ? "offset" :
    969                     cname + "Offset";
    970                 remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
    971                     "_" + cname + "Remaining";
    972 
    973                 if (jfunc.getArgType(idx).isArray()) {
    974                     out.println(indent +
    975                                 "if (!" +
    976                                 cname +
    977                                 "_ref) {");
    978                     if (emitExceptionCheck) {
    979                         out.println(indent + indent + "_exception = 1;");
    980                     }
    981                     out.println(indent + "    " +
    982                                 (mUseCPlusPlus ? "_env" : "(*_env)") +
    983                                 "->ThrowNew(" +
    984                                 (mUseCPlusPlus ? "" : "_env, ") +
    985                                 "IAEClass, " +
    986                                 "\"" + cname +
    987                                 " == null\");");
    988                     out.println(indent + "    goto exit;");
    989                     needsExit = true;
    990                     out.println(indent + "}");
    991 
    992                     out.println(indent + "if (" + offset + " < 0) {");
    993                     if (emitExceptionCheck) {
    994                         out.println(indent + indent + "_exception = 1;");
    995                     }
    996                     out.println(indent + "    " +
    997                                 (mUseCPlusPlus ? "_env" : "(*_env)") +
    998                                 "->ThrowNew(" +
    999                                 (mUseCPlusPlus ? "" : "_env, ") +
   1000                                 "IAEClass, " +
   1001                                 "\"" + offset + " < 0\");");
   1002                     out.println(indent + "    goto exit;");
   1003                     needsExit = true;
   1004                     out.println(indent + "}");
   1005 
   1006                     out.println(indent + remaining + " = " +
   1007                                     (mUseCPlusPlus ? "_env" : "(*_env)") +
   1008                                     "->GetArrayLength(" +
   1009                                     (mUseCPlusPlus ? "" : "_env, ") +
   1010                                     cname + "_ref) - " + offset + ";");
   1011 
   1012                     emitNativeBoundsChecks(cfunc, cname, out, false,
   1013                                            emitExceptionCheck,
   1014                                            offset, remaining, "    ");
   1015 
   1016                     out.println(indent +
   1017                                 cname +
   1018                                 "_base = (" +
   1019                                 cfunc.getArgType(cIndex).getDeclaration() +
   1020                                 ")");
   1021                     out.println(indent + "    " +
   1022                                 (mUseCPlusPlus ? "_env" : "(*_env)") +
   1023                                 "->GetPrimitiveArrayCritical(" +
   1024                                 (mUseCPlusPlus ? "" : "_env, ") +
   1025                                 jfunc.getArgName(idx) +
   1026                                 "_ref, (jboolean *)0);");
   1027                     out.println(indent +
   1028                                 cname + " = " + cname + "_base + " + offset +
   1029                                 ";");
   1030                     out.println();
   1031                 } else {
   1032                     String array = numBufferArgs <= 1 ? "_array" :
   1033                         "_" + bufferArgNames.get(bufArgIdx++) + "Array";
   1034 
   1035                     boolean nullAllowed = isNullAllowed(cfunc) || isPointerFunc;
   1036                     if (nullAllowed) {
   1037                         out.println(indent + "if (" + cname + "_buf) {");
   1038                         out.print(indent);
   1039                     }
   1040 
   1041                     if (isPointerFunc) {
   1042                         out.println(indent +
   1043                                 cname +
   1044                                 " = (" +
   1045                                 cfunc.getArgType(cIndex).getDeclaration() +
   1046                                 ") getDirectBufferPointer(_env, " +
   1047                                 cname + "_buf);");
   1048                         String iii = "    ";
   1049                         out.println(iii + indent + "if ( ! " + cname + " ) {");
   1050                         out.println(iii + iii + indent + "return;");
   1051                         out.println(iii + indent + "}");
   1052                     } else {
   1053                         out.println(indent +
   1054                                     cname +
   1055                                     " = (" +
   1056                                     cfunc.getArgType(cIndex).getDeclaration() +
   1057                                     ")getPointer(_env, " +
   1058                                     cname +
   1059                                     "_buf, &" + array + ", &" + remaining +
   1060                                     ");");
   1061                     }
   1062 
   1063                     emitNativeBoundsChecks(cfunc, cname, out, true,
   1064                                            emitExceptionCheck,
   1065                                            offset, remaining, nullAllowed ? "        " : "    ");
   1066 
   1067                     if (nullAllowed) {
   1068                         out.println(indent + "}");
   1069                     }
   1070                 }
   1071             }
   1072         }
   1073 
   1074         if (!isVoid) {
   1075             out.print(indent + "_returnValue = ");
   1076         } else {
   1077             out.print(indent);
   1078         }
   1079         String name = cfunc.getName();
   1080 
   1081         if (mUseContextPointer) {
   1082             name = name.substring(2, name.length()); // Strip off 'gl' prefix
   1083             name = name.substring(0, 1).toLowerCase() +
   1084                 name.substring(1, name.length());
   1085             out.print("ctx->procs.");
   1086         }
   1087 
   1088         out.print(name + (isPointerFunc ? "Bounds" : "") + "(");
   1089 
   1090         numArgs = cfunc.getNumArgs();
   1091         if (numArgs == 0) {
   1092             if (mUseContextPointer) {
   1093                 out.println("ctx);");
   1094             } else {
   1095                 out.println(");");
   1096             }
   1097         } else {
   1098             if (mUseContextPointer) {
   1099                 out.println("ctx,");
   1100             } else {
   1101                 out.println();
   1102             }
   1103             for (int i = 0; i < numArgs; i++) {
   1104                 String typecast;
   1105                 if (i == numArgs - 1 && isVBOPointerFunc) {
   1106                     typecast = "const GLvoid *";
   1107                 } else {
   1108                     typecast = cfunc.getArgType(i).getDeclaration();
   1109                 }
   1110                 out.print(indent + indent +
   1111                           "(" +
   1112                           typecast +
   1113                           ")");
   1114                 if (cfunc.getArgType(i).isConstCharPointer()) {
   1115                     out.print("_native");
   1116                 }
   1117                 out.print(cfunc.getArgName(i));
   1118 
   1119                 if (i == numArgs - 1) {
   1120                     if (isPointerFunc) {
   1121                         out.println(",");
   1122                         out.println(indent + indent + "(GLsizei)remaining");
   1123                     } else {
   1124                         out.println();
   1125                     }
   1126                 } else {
   1127                     out.println(",");
   1128                 }
   1129             }
   1130             out.println(indent + ");");
   1131         }
   1132 
   1133         if (needsExit) {
   1134             out.println();
   1135             out.println("exit:");
   1136             needsExit = false;
   1137         }
   1138 
   1139         bufArgIdx = 0;
   1140         if (nonPrimitiveArgs.size() > 0) {
   1141             for (int i = nonPrimitiveArgs.size() - 1; i >= 0; i--) {
   1142                 int idx = nonPrimitiveArgs.get(i).intValue();
   1143 
   1144                 int cIndex = jfunc.getArgCIndex(idx);
   1145                 if (jfunc.getArgType(idx).isArray()) {
   1146 
   1147                     // If the argument is 'const', GL will not write to it.
   1148                     // In this case, we can use the 'JNI_ABORT' flag to avoid
   1149                     // the need to write back to the Java array
   1150                     out.println(indent +
   1151                                 "if (" + jfunc.getArgName(idx) + "_base) {");
   1152                     out.println(indent + indent +
   1153                                 (mUseCPlusPlus ? "_env" : "(*_env)") +
   1154                                 "->ReleasePrimitiveArrayCritical(" +
   1155                                 (mUseCPlusPlus ? "" : "_env, ") +
   1156                                 jfunc.getArgName(idx) + "_ref, " +
   1157                                 cfunc.getArgName(cIndex) +
   1158                                 "_base,");
   1159                     out.println(indent + indent + indent +
   1160                                 (cfunc.getArgType(cIndex).isConst() ?
   1161                                  "JNI_ABORT" :
   1162                                  "_exception ? JNI_ABORT: 0") +
   1163                                 ");");
   1164                     out.println(indent + "}");
   1165                 } else if (jfunc.getArgType(idx).isBuffer()) {
   1166                     if (! isPointerFunc) {
   1167                         String array = numBufferArgs <= 1 ? "_array" :
   1168                             "_" + bufferArgNames.get(bufArgIdx++) + "Array";
   1169                         out.println(indent + "if (" + array + ") {");
   1170                         out.println(indent + indent +
   1171                                     "releasePointer(_env, " + array + ", " +
   1172                                     cfunc.getArgName(cIndex) +
   1173                                     ", " +
   1174                                     (cfunc.getArgType(cIndex).isConst() ?
   1175                                      "JNI_FALSE" : "_exception ? JNI_FALSE :" +
   1176                                              " JNI_TRUE") +
   1177                                     ");");
   1178                         out.println(indent + "}");
   1179                     }
   1180                 }
   1181             }
   1182         }
   1183 
   1184         // Emit local variable declaration for strings
   1185         if (stringArgs.size() > 0) {
   1186             for (int i = 0; i < stringArgs.size(); i++) {
   1187                 int idx = stringArgs.get(i).intValue();
   1188                 int cIndex = jfunc.getArgCIndex(idx);
   1189                 String cname = cfunc.getArgName(cIndex);
   1190 
   1191                 out.println(indent + "if (_native" + cname + ") {");
   1192                 out.println(indent + "    _env->ReleaseStringUTFChars(" + cname + ", _native" + cname + ");");
   1193                 out.println(indent + "}");
   1194             }
   1195 
   1196             out.println();
   1197         }
   1198 
   1199 
   1200         if (!isVoid) {
   1201             out.println(indent + "return _returnValue;");
   1202         }
   1203 
   1204         out.println("}");
   1205         out.println();
   1206     }
   1207 
   1208 }
   1209