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
17import java.io.PrintStream;
18import java.util.ArrayList;
19import java.util.HashSet;
20import java.util.Iterator;
21import java.util.List;
22
23public class JniCodeEmitter {
24
25    static final boolean mUseCPlusPlus = true;
26    protected boolean mUseContextPointer = true;
27    protected boolean mUseStaticMethods = false;
28    protected boolean mUseSimpleMethodNames = false;
29    protected boolean mUseHideCommentForAPI = false;
30    protected String mClassPathName;
31    protected ParameterChecker mChecker;
32    protected List<String> nativeRegistrations = new ArrayList<String>();
33    boolean needsExit;
34    protected static String indent = "    ";
35    HashSet<String> mFunctionsEmitted = new HashSet<String>();
36
37    public static String getJniName(JType jType) {
38        String jniName = "";
39        if (jType.isEGLHandle()) {
40            return (jType.isArray() ? "[" : "" ) + "Landroid/opengl/" + jType.getBaseType() + ";";
41        } else if (jType.isClass()) {
42            return "L" + jType.getBaseType() + ";";
43        } else if (jType.isArray()) {
44            jniName = "[";
45        }
46
47        String baseType = jType.getBaseType();
48        if (baseType.equals("int")) {
49            jniName += "I";
50        } else if (baseType.equals("float")) {
51            jniName += "F";
52        } else if (baseType.equals("boolean")) {
53            jniName += "Z";
54        } else if (baseType.equals("short")) {
55            jniName += "S";
56        } else if (baseType.equals("long")) {
57            jniName += "J";
58        } else if (baseType.equals("byte")) {
59            jniName += "B";
60        } else if (baseType.equals("String")) {
61            jniName += "Ljava/lang/String;";
62        } else if (baseType.equals("void")) {
63            // nothing.
64        } else {
65            throw new RuntimeException("Unknown primitive basetype " + baseType);
66        }
67        return jniName;
68    }
69
70    public void emitCode(CFunc cfunc, String original,
71            PrintStream javaInterfaceStream,
72            PrintStream javaImplStream,
73            PrintStream cStream) {
74        JFunc jfunc;
75        String signature;
76        boolean duplicate;
77
78        if (cfunc.hasTypedPointerArg()) {
79            jfunc = JFunc.convert(cfunc, true);
80
81            // Don't emit duplicate functions
82            // These may appear because they are defined in multiple
83            // Java interfaces (e.g., GL11/GL11ExtensionPack)
84            signature = jfunc.toString();
85            duplicate = false;
86            if (mFunctionsEmitted.contains(signature)) {
87                duplicate = true;
88            } else {
89                mFunctionsEmitted.add(signature);
90            }
91
92            if (!duplicate) {
93                emitNativeDeclaration(jfunc, javaImplStream);
94                emitJavaCode(jfunc, javaImplStream);
95            }
96            if (javaInterfaceStream != null) {
97                emitJavaInterfaceCode(jfunc, javaInterfaceStream);
98            }
99            if (!duplicate) {
100                emitJniCode(jfunc, cStream);
101            }
102            // Don't create IOBuffer versions of the EGL functions
103            if (cfunc.hasEGLHandleArg()) {
104                return;
105            }
106        }
107
108        jfunc = JFunc.convert(cfunc, false);
109
110        signature = jfunc.toString();
111        duplicate = false;
112        if (mFunctionsEmitted.contains(signature)) {
113            duplicate = true;
114        } else {
115            mFunctionsEmitted.add(signature);
116        }
117
118        if (!duplicate) {
119            emitNativeDeclaration(jfunc, javaImplStream);
120        }
121        if (javaInterfaceStream != null) {
122            emitJavaInterfaceCode(jfunc, javaInterfaceStream);
123        }
124        if (!duplicate) {
125            emitJavaCode(jfunc, javaImplStream);
126            emitJniCode(jfunc, cStream);
127        }
128    }
129
130    public void emitNativeDeclaration(JFunc jfunc, PrintStream out) {
131        if (mUseHideCommentForAPI) {
132            out.println("    /* @hide C function " + jfunc.getCFunc().getOriginal() + " */");
133            out.println();
134        } else {
135            out.println("    // C function " + jfunc.getCFunc().getOriginal());
136            out.println();
137        }
138
139        emitFunction(jfunc, out, true, false);
140    }
141
142    public void emitJavaInterfaceCode(JFunc jfunc, PrintStream out) {
143        emitFunction(jfunc, out, false, true);
144    }
145
146    public void emitJavaCode(JFunc jfunc, PrintStream out) {
147        emitFunction(jfunc, out, false, false);
148    }
149
150    boolean isPointerFunc(JFunc jfunc) {
151        String name = jfunc.getName();
152        return (name.endsWith("Pointer") || name.endsWith("PointerOES"))
153            && jfunc.getCFunc().hasPointerArg();
154    }
155
156    void emitFunctionCall(JFunc jfunc, PrintStream out, String iii, boolean grabArray) {
157        boolean isVoid = jfunc.getType().isVoid();
158        boolean isPointerFunc = isPointerFunc(jfunc);
159
160        if (!isVoid) {
161            out.println(iii +
162                        jfunc.getType() + " _returnValue;");
163        }
164        out.println(iii +
165                    (isVoid ? "" : "_returnValue = ") +
166                    jfunc.getName() +
167                    (isPointerFunc ? "Bounds" : "" ) +
168                    "(");
169
170        int numArgs = jfunc.getNumArgs();
171        for (int i = 0; i < numArgs; i++) {
172            String argName = jfunc.getArgName(i);
173            JType argType = jfunc.getArgType(i);
174
175            if (grabArray && argType.isTypedBuffer()) {
176                String typeName = argType.getBaseType();
177                typeName = typeName.substring(9, typeName.length() - 6);
178                out.println(iii + indent + "get" + typeName + "Array(" + argName + "),");
179                out.print(iii + indent + "getOffset(" + argName + ")");
180            } else {
181                out.print(iii + indent + argName);
182            }
183            if (i == numArgs - 1) {
184                if (isPointerFunc) {
185                    out.println(",");
186                    out.println(iii + indent + argName + ".remaining()");
187                } else {
188                    out.println();
189                }
190            } else {
191                out.println(",");
192            }
193        }
194
195        out.println(iii + ");");
196    }
197
198    void printIfcheckPostamble(PrintStream out, boolean isBuffer, boolean emitExceptionCheck,
199            String iii) {
200        printIfcheckPostamble(out, isBuffer, emitExceptionCheck,
201                "offset", "_remaining", iii);
202    }
203
204    void printIfcheckPostamble(PrintStream out, boolean isBuffer, boolean emitExceptionCheck,
205            String offset, String remaining, String iii) {
206        out.println(iii + "    default:");
207        out.println(iii + "        _needed = 1;");
208        out.println(iii + "        break;");
209        out.println(iii + "}");
210
211        out.println(iii + "if (" + remaining + " < _needed) {");
212        out.println(iii + indent + "_exception = 1;");
213        out.println(iii + indent +
214                "_exceptionType = \"java/lang/IllegalArgumentException\";");
215        out.println(iii + indent +
216                "_exceptionMessage = \"" +
217                (isBuffer ? "remaining()" : "length - " + offset) +
218                " < needed\";");
219        out.println(iii + indent + "goto exit;");
220        out.println(iii + "}");
221
222        needsExit = true;
223    }
224
225    boolean isNullAllowed(CFunc cfunc, String cname) {
226        String[] checks = mChecker.getChecks(cfunc.getName());
227        int index = 1;
228        if (checks != null) {
229            while (index < checks.length) {
230                if (checks[index].equals("nullAllowed") &&
231                    checks[index + 1].equals(cname)) {
232                    return true;
233                } else {
234                    index = skipOneCheck(checks, index);
235                }
236            }
237        }
238        return false;
239    }
240
241    boolean hasCheckTest(CFunc cfunc) {
242        String[] checks = mChecker.getChecks(cfunc.getName());
243        int index = 1;
244        if (checks != null) {
245            while (index < checks.length) {
246                if (checks[index].startsWith("check")) {
247                    return true;
248                } else {
249                    index = skipOneCheck(checks, index);
250                }
251            }
252        }
253        return false;
254    }
255
256    boolean hasCheckTest(CFunc cfunc, String cname) {
257        String[] checks = mChecker.getChecks(cfunc.getName());
258        int index = 1;
259        if (checks != null) {
260            while (index < checks.length) {
261                if (checks[index].startsWith("check") &&
262                    cname != null && cname.equals(checks[index + 1])) {
263                    return true;
264                } else {
265                    index = skipOneCheck(checks, index);
266                }
267            }
268        }
269        return false;
270    }
271
272    boolean hasIfTest(CFunc cfunc) {
273        String[] checks = mChecker.getChecks(cfunc.getName());
274        int index = 1;
275        if (checks != null) {
276            while (index < checks.length) {
277                if (checks[index].startsWith("ifcheck")) {
278                    return true;
279                } else {
280                    index = skipOneCheck(checks, index);
281                }
282            }
283        }
284        return false;
285    }
286
287    int skipOneCheck(String[] checks, int index) {
288        if (checks[index].equals("return")) {
289            index += 2;
290        } else if (checks[index].startsWith("check")) {
291            index += 3;
292        } else if (checks[index].startsWith("sentinel")) {
293            index += 3;
294        } else if (checks[index].equals("ifcheck")) {
295            index += 5;
296        } else if (checks[index].equals("unsupported")) {
297            index += 1;
298        } else if (checks[index].equals("requires")) {
299            index += 2;
300        } else if (checks[index].equals("nullAllowed")) {
301            index += 2;
302        } else {
303            System.out.println("Error: unknown keyword \"" +
304                               checks[index] + "\"");
305            System.exit(0);
306        }
307
308        return index;
309    }
310
311    String getErrorReturnValue(CFunc cfunc) {
312        CType returnType = cfunc.getType();
313        boolean isVoid = returnType.isVoid();
314        if (isVoid) {
315            return null;
316        }
317
318        if (returnType.getBaseType().startsWith("EGL")) {
319            return "(" + returnType.getDeclaration() + ") 0";
320        }
321
322        String[] checks = mChecker.getChecks(cfunc.getName());
323
324        int index = 1;
325        if (checks != null) {
326            while (index < checks.length) {
327                if (checks[index].equals("return")) {
328                    return checks[index + 1];
329                } else {
330                    index = skipOneCheck(checks, index);
331                }
332            }
333        }
334
335        return null;
336    }
337
338    boolean isUnsupportedFunc(CFunc cfunc) {
339        String[] checks = mChecker.getChecks(cfunc.getName());
340        int index = 1;
341        if (checks != null) {
342            while (index < checks.length) {
343                if (checks[index].equals("unsupported")) {
344                    return true;
345                } else {
346                    index = skipOneCheck(checks, index);
347                }
348            }
349        }
350        return false;
351    }
352
353    String isRequiresFunc(CFunc cfunc) {
354        String[] checks = mChecker.getChecks(cfunc.getName());
355        int index = 1;
356        if (checks != null) {
357            while (index < checks.length) {
358                if (checks[index].equals("requires")) {
359                    return checks[index+1];
360                } else {
361                    index = skipOneCheck(checks, index);
362                }
363            }
364        }
365        return null;
366    }
367
368    void emitNativeBoundsChecks(CFunc cfunc, String cname, PrintStream out,
369            boolean isBuffer, boolean emitExceptionCheck, String offset, String remaining, String iii) {
370
371        String[] checks = mChecker.getChecks(cfunc.getName());
372
373        boolean lastWasIfcheck = false;
374
375        int index = 1;
376        if (checks != null) {
377            while (index < checks.length) {
378                if (checks[index].startsWith("check")) {
379                    if (lastWasIfcheck) {
380                        printIfcheckPostamble(out, isBuffer, emitExceptionCheck,
381                                offset, remaining, iii);
382                    }
383                    lastWasIfcheck = false;
384                    if (cname != null && !cname.equals(checks[index + 1])) {
385                        index += 3;
386                        continue;
387                    }
388                    out.println(iii + "if (" + remaining + " < " + checks[index + 2] + ") {");
389                    out.println(iii + indent + "_exception = 1;");
390                    String exceptionClassName = "java/lang/IllegalArgumentException";
391                    // If the "check" keyword was of the form
392                    // "check_<class name>", use the class name in the
393                    // exception to be thrown
394                    int underscore = checks[index].indexOf('_');
395                    if (underscore >= 0) {
396                        String abbr = checks[index].substring(underscore + 1);
397                        if (abbr.equals("AIOOBE")) {
398                            exceptionClassName = "java/lang/ArrayIndexOutOfBoundsException";
399                        } else {
400                            throw new RuntimeException("unknown exception abbreviation: " + abbr);
401                        }
402                    }
403                    out.println(iii + indent +
404                                "_exceptionType = \""+exceptionClassName+"\";");
405                    out.println(iii + indent +
406                               "_exceptionMessage = \"" +
407                               (isBuffer ? "remaining()" : "length - " +
408                               offset) + " < " + checks[index + 2] +
409                               " < needed\";");
410
411                    out.println(iii + indent + "goto exit;");
412                    out.println(iii + "}");
413
414                    needsExit = true;
415
416                    index += 3;
417                } else if (checks[index].equals("ifcheck")) {
418                    String[] matches = checks[index + 4].split(",");
419
420                    if (!lastWasIfcheck) {
421                        out.println(iii + "int _needed;");
422                        out.println(iii + "switch (" + checks[index + 3] + ") {");
423                    }
424
425                    for (int i = 0; i < matches.length; i++) {
426                        out.println("#if defined(" + matches[i] + ")");
427                        out.println(iii + "    case " + matches[i] + ":");
428                        out.println("#endif // defined(" + matches[i] + ")");
429                    }
430                    out.println(iii + "        _needed = " + checks[index + 2] + ";");
431                    out.println(iii + "        break;");
432
433                    lastWasIfcheck = true;
434                    index += 5;
435                } else {
436                    index = skipOneCheck(checks, index);
437                }
438            }
439        }
440
441        if (lastWasIfcheck) {
442            printIfcheckPostamble(out, isBuffer, emitExceptionCheck, iii);
443        }
444    }
445
446    void emitSentinelCheck(CFunc cfunc, String cname, PrintStream out,
447            boolean isBuffer, boolean emitExceptionCheck, String offset, String remaining, String iii) {
448
449        String[] checks = mChecker.getChecks(cfunc.getName());
450
451        int index = 1;
452        if (checks != null) {
453            while (index < checks.length) {
454                if (checks[index].startsWith("sentinel")) {
455                    if (cname != null && !cname.equals(checks[index + 1])) {
456                        index += 3;
457                        continue;
458                    }
459
460                    out.println(iii + cname + "_sentinel = false;");
461                    out.println(iii + "for (int i = " + remaining +
462                                " - 1; i >= 0; i--)  {");
463                    out.println(iii + indent + "if (" + cname +
464                                "[i] == " + checks[index + 2] + "){");
465                    out.println(iii + indent + indent +
466                                cname + "_sentinel = true;");
467                    out.println(iii + indent + indent + "break;");
468                    out.println(iii + indent + "}");
469                    out.println(iii + "}");
470                    out.println(iii +
471                                "if (" + cname + "_sentinel == false) {");
472                    out.println(iii + indent + "_exception = 1;");
473                    out.println(iii + indent +
474                                "_exceptionType = \"java/lang/IllegalArgumentException\";");
475                    out.println(iii + indent + "_exceptionMessage = \"" + cname +
476                                " must contain " + checks[index + 2] + "!\";");
477                    out.println(iii + indent + "goto exit;");
478                    out.println(iii + "}");
479
480                    needsExit = true;
481                    index += 3;
482                } else {
483                    index = skipOneCheck(checks, index);
484                }
485            }
486        }
487    }
488
489    void emitStringCheck(CFunc cfunc, String cname, PrintStream out, String iii) {
490
491        String[] checks = mChecker.getChecks(cfunc.getName());
492
493        int index = 1;
494        if (checks != null) {
495            while (index < checks.length) {
496                if (checks[index].startsWith("check")) {
497                    if (cname != null && !cname.equals(checks[index + 1])) {
498                    index += 3;
499                    continue;
500                }
501                    out.println(iii + "_stringlen = _env->GetStringUTFLength(" + cname + ");");
502                    out.println(iii + "if (" + checks[index + 2] + " > _stringlen) {");
503                    out.println(iii + indent + "_exception = 1;");
504                    out.println(iii + indent +
505                            "_exceptionType = \"java/lang/ArrayIndexOutOfBoundsException\";");
506                    out.println(iii + indent +
507                            "_exceptionMessage = \"length of " + cname + " is shorter than " +
508                            checks[index + 2] + " argument\";");
509                    out.println(iii + indent + "goto exit;");
510                    out.println(iii + "}");
511                    index += 3;
512                    needsExit = true;
513                } else {
514                    index = skipOneCheck(checks, index);
515                }
516            }
517        }
518    }
519
520    void emitLocalVariablesForSentinel(CFunc cfunc, PrintStream out) {
521
522        String[] checks = mChecker.getChecks(cfunc.getName());
523
524        int index = 1;
525        if (checks != null) {
526            while (index < checks.length) {
527                if (checks[index].startsWith("sentinel")) {
528                    String cname = checks[index + 1];
529                    out.println(indent + "bool " + cname + "_sentinel = false;");
530
531                    index += 3;
532
533                } else {
534                    index = skipOneCheck(checks, index);
535                }
536            }
537        }
538    }
539
540    boolean hasNonConstArg(JFunc jfunc, CFunc cfunc, List<Integer> nonPrimitiveArgs) {
541        if (nonPrimitiveArgs.size() > 0) {
542            for (int i = nonPrimitiveArgs.size() - 1; i >= 0; i--) {
543                int idx = nonPrimitiveArgs.get(i).intValue();
544                int cIndex = jfunc.getArgCIndex(idx);
545                if (jfunc.getArgType(idx).isArray()) {
546                    if (!cfunc.getArgType(cIndex).isConst()) {
547                        return true;
548                    }
549                } else if (jfunc.getArgType(idx).isBuffer()) {
550                    if (!cfunc.getArgType(cIndex).isConst()) {
551                        return true;
552                    }
553                }
554            }
555        }
556
557        return false;
558    }
559
560    /**
561     * Emit a function in several variants:
562     *
563     * if nativeDecl: public native <returntype> func(args);
564     *
565     * if !nativeDecl:
566     *   if interfaceDecl:  public <returntype> func(args);
567     *   if !interfaceDecl: public <returntype> func(args) { body }
568     */
569    void emitFunction(JFunc jfunc, PrintStream out, boolean nativeDecl, boolean interfaceDecl) {
570        boolean isPointerFunc = isPointerFunc(jfunc);
571
572        if (!nativeDecl && !interfaceDecl && !isPointerFunc) {
573            // If it's not a pointer function, we've already emitted it
574            // with nativeDecl == true
575            return;
576        }
577
578        String maybeStatic = mUseStaticMethods ? "static " : "";
579
580        if (isPointerFunc) {
581            out.println(indent +
582                        (nativeDecl ? "private " + maybeStatic +"native " :
583                         (interfaceDecl ? "" : "public ") + maybeStatic) +
584                        jfunc.getType() + " " +
585                        jfunc.getName() +
586                        (nativeDecl ? "Bounds" : "") +
587                        "(");
588        } else {
589            out.println(indent +
590                        (nativeDecl ? "public " + maybeStatic +"native " :
591                         (interfaceDecl ? "" : "public ") + maybeStatic) +
592                        jfunc.getType() + " " +
593                        jfunc.getName() +
594                        "(");
595        }
596
597        int numArgs = jfunc.getNumArgs();
598        for (int i = 0; i < numArgs; i++) {
599            String argName = jfunc.getArgName(i);
600            JType argType = jfunc.getArgType(i);
601
602            out.print(indent + indent + argType + " " + argName);
603            if (i == numArgs - 1) {
604                if (isPointerFunc && nativeDecl) {
605                    out.println(",");
606                    out.println(indent + indent + "int remaining");
607                } else {
608                    out.println();
609                }
610            } else {
611                out.println(",");
612            }
613        }
614
615        if (nativeDecl || interfaceDecl) {
616            out.println(indent + ");");
617        } else {
618            out.println(indent + ") {");
619
620            String iii = indent + indent;
621
622            // emitBoundsChecks(jfunc, out, iii);
623            emitFunctionCall(jfunc, out, iii, false);
624
625            // Set the pointer after we call the native code, so that if
626            // the native code throws an exception we don't modify the
627            // pointer. We assume that the native code is written so that
628            // if an exception is thrown, then the underlying glXXXPointer
629            // function will not have been called.
630
631            String fname = jfunc.getName();
632            if (isPointerFunc) {
633                // TODO - deal with VBO variants
634                if (fname.equals("glColorPointer")) {
635                    out.println(iii + "if ((size == 4) &&");
636                    out.println(iii + "    ((type == GL_FLOAT) ||");
637                    out.println(iii + "     (type == GL_UNSIGNED_BYTE) ||");
638                    out.println(iii + "     (type == GL_FIXED)) &&");
639                    out.println(iii + "    (stride >= 0)) {");
640                    out.println(iii + indent + "_colorPointer = pointer;");
641                    out.println(iii + "}");
642                } else if (fname.equals("glNormalPointer")) {
643                    out.println(iii + "if (((type == GL_FLOAT) ||");
644                    out.println(iii + "     (type == GL_BYTE) ||");
645                    out.println(iii + "     (type == GL_SHORT) ||");
646                    out.println(iii + "     (type == GL_FIXED)) &&");
647                    out.println(iii + "    (stride >= 0)) {");
648                    out.println(iii + indent + "_normalPointer = pointer;");
649                    out.println(iii + "}");
650                } else if (fname.equals("glTexCoordPointer")) {
651                    out.println(iii + "if (((size == 2) ||");
652                    out.println(iii + "     (size == 3) ||");
653                    out.println(iii + "     (size == 4)) &&");
654                    out.println(iii + "    ((type == GL_FLOAT) ||");
655                    out.println(iii + "     (type == GL_BYTE) ||");
656                    out.println(iii + "     (type == GL_SHORT) ||");
657                    out.println(iii + "     (type == GL_FIXED)) &&");
658                    out.println(iii + "    (stride >= 0)) {");
659                    out.println(iii + indent + "_texCoordPointer = pointer;");
660                    out.println(iii + "}");
661                } else if (fname.equals("glVertexPointer")) {
662                    out.println(iii + "if (((size == 2) ||");
663                    out.println(iii + "     (size == 3) ||");
664                    out.println(iii + "     (size == 4)) &&");
665                    out.println(iii + "    ((type == GL_FLOAT) ||");
666                    out.println(iii + "     (type == GL_BYTE) ||");
667                    out.println(iii + "     (type == GL_SHORT) ||");
668                    out.println(iii + "     (type == GL_FIXED)) &&");
669                    out.println(iii + "    (stride >= 0)) {");
670                    out.println(iii + indent + "_vertexPointer = pointer;");
671                    out.println(iii + "}");
672                } else if (fname.equals("glPointSizePointerOES")) {
673                    out.println(iii + "if (((type == GL_FLOAT) ||");
674                    out.println(iii + "     (type == GL_FIXED)) &&");
675                    out.println(iii + "    (stride >= 0)) {");
676                    out.println(iii + indent + "_pointSizePointerOES = pointer;");
677                    out.println(iii + "}");
678                } else if (fname.equals("glMatrixIndexPointerOES")) {
679                    out.println(iii + "if (((size == 2) ||");
680                    out.println(iii + "     (size == 3) ||");
681                    out.println(iii + "     (size == 4)) &&");
682                    out.println(iii + "    ((type == GL_FLOAT) ||");
683                    out.println(iii + "     (type == GL_BYTE) ||");
684                    out.println(iii + "     (type == GL_SHORT) ||");
685                    out.println(iii + "     (type == GL_FIXED)) &&");
686                    out.println(iii + "    (stride >= 0)) {");
687                    out.println(iii + indent + "_matrixIndexPointerOES = pointer;");
688                    out.println(iii + "}");
689                } else if (fname.equals("glWeightPointer")) {
690                    out.println(iii + "if (((size == 2) ||");
691                    out.println(iii + "     (size == 3) ||");
692                    out.println(iii + "     (size == 4)) &&");
693                    out.println(iii + "    ((type == GL_FLOAT) ||");
694                    out.println(iii + "     (type == GL_BYTE) ||");
695                    out.println(iii + "     (type == GL_SHORT) ||");
696                    out.println(iii + "     (type == GL_FIXED)) &&");
697                    out.println(iii + "    (stride >= 0)) {");
698                    out.println(iii + indent + "_weightPointerOES = pointer;");
699                    out.println(iii + "}");
700                }
701            }
702
703            boolean isVoid = jfunc.getType().isVoid();
704
705            if (!isVoid) {
706                out.println(indent + indent + "return _returnValue;");
707            }
708            out.println(indent + "}");
709        }
710        out.println();
711    }
712
713    public void addNativeRegistration(String s) {
714        nativeRegistrations.add(s);
715    }
716
717    public void emitNativeRegistration(String registrationFunctionName,
718            PrintStream cStream) {
719        cStream.println("static const char *classPathName = \"" +
720                        mClassPathName +
721                        "\";");
722        cStream.println();
723
724        cStream.println("static const JNINativeMethod methods[] = {");
725
726        cStream.println("{\"_nativeClassInit\", \"()V\", (void*)nativeClassInit },");
727
728        Iterator<String> i = nativeRegistrations.iterator();
729        while (i.hasNext()) {
730            cStream.println(i.next());
731        }
732
733        cStream.println("};");
734        cStream.println();
735
736
737        cStream.println("int " + registrationFunctionName + "(JNIEnv *_env)");
738        cStream.println("{");
739        cStream.println(indent +
740                        "int err;");
741
742        cStream.println(indent +
743                        "err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods));");
744
745        cStream.println(indent + "return err;");
746        cStream.println("}");
747    }
748
749    public JniCodeEmitter() {
750        super();
751    }
752
753    String getJniType(JType jType) {
754        if (jType.isVoid()) {
755            return "void";
756        }
757
758        String baseType = jType.getBaseType();
759        if (jType.isPrimitive()) {
760            if (baseType.equals("String")) {
761                return "jstring";
762            } else {
763                return "j" + baseType;
764            }
765        } else if (jType.isArray()) {
766            return jType.isClass() ? "jobjectArray" : "j" + baseType + "Array";
767        } else {
768            return "jobject";
769        }
770    }
771
772    String getJniMangledName(String name) {
773        name = name.replaceAll("_", "_1");
774        name = name.replaceAll(";", "_2");
775        name = name.replaceAll("\\[", "_3");
776        return name;
777    }
778
779    public void emitJniCode(JFunc jfunc, PrintStream out) {
780        CFunc cfunc = jfunc.getCFunc();
781
782        // Emit comment identifying original C function
783        //
784        // Example:
785        //
786        // /* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */
787        //
788        out.println("/* " + cfunc.getOriginal() + " */");
789
790        // Emit JNI signature (name)
791        //
792        // Example:
793        //
794        // void
795        // android_glClipPlanef__I_3FI
796        //
797
798        String outName = "android_" + jfunc.getName();
799        boolean isPointerFunc = isPointerFunc(jfunc);
800        boolean isPointerOffsetFunc =
801            (outName.endsWith("Pointer") || outName.endsWith("PointerOES") ||
802             outName.endsWith("glDrawElements") ||
803             outName.endsWith("glDrawRangeElements") ||
804             outName.endsWith("glTexImage2D") ||
805             outName.endsWith("glTexSubImage2D") ||
806             outName.endsWith("glCompressedTexImage2D") ||
807             outName.endsWith("glCompressedTexSubImage2D") ||
808             outName.endsWith("glTexImage3D") ||
809             outName.endsWith("glTexSubImage3D") ||
810             outName.endsWith("glCompressedTexImage3D") ||
811             outName.endsWith("glCompressedTexSubImage3D") ||
812             outName.endsWith("glReadPixels"))
813            && !jfunc.getCFunc().hasPointerArg();
814        if (isPointerFunc) {
815            outName += "Bounds";
816        }
817
818        out.print("static ");
819        out.println(getJniType(jfunc.getType()));
820        out.print(outName);
821
822        String rsignature = getJniName(jfunc.getType());
823
824        String signature = "";
825        int numArgs = jfunc.getNumArgs();
826        for (int i = 0; i < numArgs; i++) {
827            JType argType = jfunc.getArgType(i);
828            signature += getJniName(argType);
829        }
830        if (isPointerFunc) {
831            signature += "I";
832        }
833
834        // Append signature to function name
835        String sig = getJniMangledName(signature).replace('.', '_').replace('/', '_');
836        if (!mUseSimpleMethodNames) {
837            out.print("__" + sig);
838            outName += "__" + sig;
839        }
840
841        signature = signature.replace('.', '/');
842        rsignature = rsignature.replace('.', '/');
843
844        out.println();
845        if (rsignature.length() == 0) {
846            rsignature = "V";
847        }
848
849        String s = "{\"" +
850            jfunc.getName() +
851            (isPointerFunc ? "Bounds" : "") +
852            "\", \"(" + signature +")" +
853            rsignature +
854            "\", (void *) " +
855            outName +
856            " },";
857        nativeRegistrations.add(s);
858
859        List<Integer> nonPrimitiveArgs = new ArrayList<Integer>();
860        List<Integer> stringArgs = new ArrayList<Integer>();
861        int numBufferArgs = 0;
862        List<String> bufferArgNames = new ArrayList<String>();
863        List<JType> bufferArgTypes = new ArrayList<JType>();
864
865        // Emit JNI signature (arguments)
866        //
867        // Example:
868        //
869        // (JNIEnv *_env, jobject this, jint plane, jfloatArray equation_ref, jint offset) {
870        //
871        out.print("  (JNIEnv *_env, jobject _this");
872        for (int i = 0; i < numArgs; i++) {
873            out.print(", ");
874            JType argType = jfunc.getArgType(i);
875            String suffix = "";
876            if (!argType.isPrimitive()) {
877                if (argType.isArray()) {
878                    suffix = "_ref";
879                } else if (argType.isBuffer()) {
880                    suffix = "_buf";
881                }
882                nonPrimitiveArgs.add(new Integer(i));
883                if (jfunc.getArgType(i).isBuffer()) {
884                    int cIndex = jfunc.getArgCIndex(i);
885                    String cname = cfunc.getArgName(cIndex);
886                    bufferArgNames.add(cname);
887                    bufferArgTypes.add(jfunc.getArgType(i));
888                    numBufferArgs++;
889                }
890            }
891
892            if (argType.isString()) {
893                stringArgs.add(new Integer(i));
894            }
895
896            out.print(getJniType(argType) + " " + jfunc.getArgName(i) + suffix);
897        }
898        if (isPointerFunc) {
899            out.print(", jint remaining");
900        }
901        out.println(") {");
902
903        int numArrays = 0;
904        int numBuffers = 0;
905        int numStrings = 0;
906        for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
907            int idx = nonPrimitiveArgs.get(i).intValue();
908            JType argType = jfunc.getArgType(idx);
909            if (argType.isArray()) {
910                ++numArrays;
911            }
912            if (argType.isBuffer()) {
913                ++numBuffers;
914            }
915            if (argType.isString()) {
916                ++numStrings;
917            }
918        }
919
920        // Emit method body
921
922        // Emit local variable declarations for _exception and _returnValue
923        //
924        // Example:
925        //
926        // android::gl::ogles_context_t *ctx;
927        //
928        // jint _exception;
929        // GLenum _returnValue;
930        //
931        CType returnType = cfunc.getType();
932        boolean isVoid = returnType.isVoid();
933
934        boolean isUnsupported = isUnsupportedFunc(cfunc);
935        if (isUnsupported) {
936            out.println(indent +
937                        "jniThrowException(_env, \"java/lang/UnsupportedOperationException\",");
938            out.println(indent +
939                        "    \"" + cfunc.getName() + "\");");
940            if (!isVoid) {
941                String retval = getErrorReturnValue(cfunc);
942                if (cfunc.getType().isEGLHandle()) {
943                    String baseType = cfunc.getType().getBaseType().toLowerCase();
944                    out.println(indent +
945                                "return toEGLHandle(_env, " + baseType + "Class, " +
946                                baseType + "Constructor, " + retval + ");");
947                } else {
948                    out.println(indent + "return " + retval + ";");
949                }
950            }
951            out.println("}");
952            out.println();
953            return;
954        }
955
956        String requiresExtension = isRequiresFunc(cfunc);
957        if (requiresExtension != null) {
958            out.println(indent +
959                        "if (! supportsExtension(_env, _this, have_" + requiresExtension + "ID)) {");
960            out.println(indent + indent +
961                        "jniThrowException(_env, \"java/lang/UnsupportedOperationException\",");
962            out.println(indent + indent +
963                        "    \"" + cfunc.getName() + "\");");
964            if (isVoid) {
965                out.println(indent + indent + "    return;");
966            } else {
967                String retval = getErrorReturnValue(cfunc);
968                if (cfunc.getType().isEGLHandle()) {
969                    String baseType = cfunc.getType().getBaseType().toLowerCase();
970                    out.println(indent +
971                                "return toEGLHandle(_env, " + baseType + "Class, " +
972                                baseType + "Constructor, " + retval + ");");
973                } else {
974                    out.println(indent + "return " + retval + ";");
975                }
976            }
977            out.println(indent + "}");
978        }
979        if (mUseContextPointer) {
980            out.println(indent +
981                "android::gl::ogles_context_t *ctx = getContext(_env, _this);");
982        }
983
984        boolean initializeReturnValue = stringArgs.size() > 0;
985        boolean emitExceptionCheck = ((numArrays > 0 || numStrings > 0)
986                                             && (hasNonConstArg(jfunc, cfunc, nonPrimitiveArgs)
987                                                 || (cfunc.hasPointerArg() && numArrays > 0))
988                                         || hasCheckTest(cfunc)
989                                         || hasIfTest(cfunc))
990                                         || (stringArgs.size() > 0);
991        // mChecker.getChecks(cfunc.getName()) != null
992        // Emit an _exeption variable if there will be error checks
993        if (emitExceptionCheck) {
994            out.println(indent + "jint _exception = 0;");
995            out.println(indent + "const char * _exceptionType = NULL;");
996            out.println(indent + "const char * _exceptionMessage = NULL;");
997        }
998
999        // Emit a single _array or multiple _XXXArray variables
1000        if (numBufferArgs == 1) {
1001            JType bufferType = bufferArgTypes.get(0);
1002            if (bufferType.isTypedBuffer()) {
1003                String typedArrayType = getJniType(bufferType.getArrayTypeForTypedBuffer());
1004                out.println(indent + typedArrayType + " _array = (" + typedArrayType + ") 0;");
1005            } else {
1006                out.println(indent + "jarray _array = (jarray) 0;");
1007            }
1008            out.println(indent + "jint _bufferOffset = (jint) 0;");
1009        } else {
1010            for (int i = 0; i < numBufferArgs; i++) {
1011                JType bufferType = bufferArgTypes.get(0);
1012                if (bufferType.isTypedBuffer()) {
1013                    String typedArrayType = getJniType(bufferType.getArrayTypeForTypedBuffer());
1014                    out.println(indent + typedArrayType + " _" + bufferArgNames.get(i) +
1015                                "Array = (" + typedArrayType + ") 0;");
1016                } else {
1017                    out.println(indent + "jarray _" + bufferArgNames.get(i) +
1018                                "Array = (jarray) 0;");
1019                }
1020                out.println(indent + "jint _" + bufferArgNames.get(i) +
1021                            "BufferOffset = (jint) 0;");
1022            }
1023        }
1024        if (!isVoid) {
1025            String retval = getErrorReturnValue(cfunc);
1026            if (retval != null) {
1027                out.println(indent + returnType.getDeclaration() +
1028                            " _returnValue = " + retval + ";");
1029            } else if (initializeReturnValue) {
1030                out.println(indent + returnType.getDeclaration() +
1031                            " _returnValue = 0;");
1032            } else {
1033                out.println(indent + returnType.getDeclaration() +
1034                            " _returnValue;");
1035            }
1036        }
1037
1038        // Emit local variable declarations for EGL Handles
1039        //
1040        // Example:
1041        //
1042        // EGLSurface surface_native = (EGLHandle)fromEGLHandle(_env, surfaceClass, surfaceConstructor, surface);
1043        //
1044        if (nonPrimitiveArgs.size() > 0) {
1045            for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
1046                int idx = nonPrimitiveArgs.get(i).intValue();
1047                int cIndex = jfunc.getArgCIndex(idx);
1048                String cname = cfunc.getArgName(cIndex);
1049
1050                if (jfunc.getArgType(idx).isBuffer()
1051                   || jfunc.getArgType(idx).isArray()
1052                   || !jfunc.getArgType(idx).isEGLHandle())
1053                    continue;
1054
1055                CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
1056                String decl = type.getDeclaration();
1057                out.println(indent +
1058                            decl + " " + cname + "_native = (" +
1059                            decl + ") fromEGLHandle(_env, " +
1060                            type.getBaseType().toLowerCase() +
1061                            "GetHandleID, " + jfunc.getArgName(idx) +
1062                            ");");
1063            }
1064        }
1065
1066        // Emit local variable declarations for element/sentinel checks
1067        //
1068        // Example:
1069        //
1070        // bool attrib_list_sentinel_found = false;
1071        //
1072        emitLocalVariablesForSentinel(cfunc, out);
1073
1074        // Emit local variable declarations for pointer arguments
1075        //
1076        // Example:
1077        //
1078        // GLfixed *eqn_base;
1079        // GLfixed *eqn;
1080        //
1081        String offset = "offset";
1082        String remaining = "_remaining";
1083        if (nonPrimitiveArgs.size() > 0) {
1084            for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
1085                int idx = nonPrimitiveArgs.get(i).intValue();
1086                int cIndex = jfunc.getArgCIndex(idx);
1087                String cname = cfunc.getArgName(cIndex);
1088
1089                if (!jfunc.getArgType(idx).isBuffer() && !jfunc.getArgType(idx).isArray())
1090                    continue;
1091
1092                CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
1093                String decl = type.getDeclaration();
1094                if (jfunc.getArgType(idx).isArray() && !jfunc.getArgType(idx).isClass()) {
1095                    out.println(indent +
1096                                decl +
1097                                (decl.endsWith("*") ? "" : " ") +
1098                                jfunc.getArgName(idx) +
1099                                "_base = (" + decl + ") 0;");
1100                }
1101                remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
1102                    "_" + cname + "Remaining";
1103                out.println(indent +
1104                            "jint " + remaining + ";");
1105                out.println(indent +
1106                                decl +
1107                                (decl.endsWith("*") ? "" : " ") +
1108                                jfunc.getArgName(idx) +
1109                                " = (" + decl + ") 0;");
1110            }
1111
1112            out.println();
1113        }
1114
1115        // Emit local variable declaration for strings
1116        if (stringArgs.size() > 0) {
1117            boolean requiresStringLengthCheck = false;
1118            for (int i = 0; i < stringArgs.size(); i++) {
1119                int idx = stringArgs.get(i).intValue();
1120                int cIndex = jfunc.getArgCIndex(idx);
1121                String cname = cfunc.getArgName(cIndex);
1122
1123                out.println(indent + "const char* _native" + cname + " = 0;");
1124                if (hasCheckTest(cfunc, cname)) {
1125                    requiresStringLengthCheck = true;
1126                }
1127            }
1128
1129            if (requiresStringLengthCheck) {
1130                out.println(indent + "jsize _stringlen = 0;");
1131            }
1132
1133            out.println();
1134        }
1135
1136        // Null pointer checks and GetStringUTFChars
1137        if (stringArgs.size() > 0) {
1138            for (int i = 0; i < stringArgs.size(); i++) {
1139                int idx = stringArgs.get(i).intValue();
1140                int cIndex = jfunc.getArgCIndex(idx);
1141                String cname = cfunc.getArgName(cIndex);
1142
1143                boolean nullAllowed = isNullAllowed(cfunc, cname);
1144                String nullAllowedIndent = nullAllowed ? indent : "";
1145
1146                CType type = cfunc.getArgType(jfunc.getArgCIndex(idx));
1147                String decl = type.getDeclaration();
1148
1149                if (nullAllowed) {
1150                    out.println(indent + "if (" + cname + ") {");
1151                } else {
1152                    needsExit = true;
1153                    out.println(indent + "if (!" + cname + ") {");
1154                    out.println(indent + indent + "_exception = 1;");
1155                    out.println(indent + indent +
1156                            "_exceptionType = \"java/lang/IllegalArgumentException\";");
1157                    out.println(indent + indent +
1158                            "_exceptionMessage = \"" + cname + " == null\";");
1159                    out.println(indent + indent + "goto exit;");
1160                    out.println(indent + "}");
1161                }
1162
1163                out.println(nullAllowedIndent + indent + "_native" + cname +
1164                        " = _env->GetStringUTFChars(" + cname + ", 0);");
1165
1166                emitStringCheck(cfunc, cname, out, nullAllowedIndent + indent);
1167
1168                if (nullAllowed) {
1169                    out.println(indent + "}");
1170                }
1171            }
1172
1173            out.println();
1174        }
1175
1176        // Emit 'GetPrimitiveArrayCritical' for non-object arrays
1177        // Emit 'GetPointer' calls for Buffer pointers
1178        if (nonPrimitiveArgs.size() > 0) {
1179            for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
1180                int idx = nonPrimitiveArgs.get(i).intValue();
1181                int cIndex = jfunc.getArgCIndex(idx);
1182
1183                String cname = cfunc.getArgName(cIndex);
1184                offset = numArrays <= 1 ? "offset" :
1185                    cname + "Offset";
1186                remaining = ((numArrays + numBuffers) <= 1) ? "_remaining" :
1187                    "_" + cname + "Remaining";
1188
1189                boolean nullAllowed = isNullAllowed(cfunc, cname);
1190                String nullAllowedIndent = nullAllowed ? indent : "";
1191
1192                if (jfunc.getArgType(idx).isArray()
1193                       && !jfunc.getArgType(idx).isEGLHandle()) {
1194                    needsExit = true;
1195
1196                    if (nullAllowed) {
1197                        out.println(indent + "if (" + cname + "_ref) {");
1198                    }
1199                    else
1200                    {
1201                        out.println(indent + "if (!" + cname + "_ref) {");
1202                        out.println(indent + indent + "_exception = 1;");
1203                        out.println(indent + indent +
1204                                "_exceptionType = " +
1205                                "\"java/lang/IllegalArgumentException\";");
1206                        out.println(indent + indent +
1207                                "_exceptionMessage = \"" + cname +
1208                                " == null\";");
1209                        out.println(indent + indent + "goto exit;");
1210                        out.println(indent + "}");
1211                    }
1212
1213                    out.println(nullAllowedIndent + indent + "if (" + offset +
1214                            " < 0) {");
1215                    out.println(nullAllowedIndent + indent + indent +
1216                            "_exception = 1;");
1217                    out.println(nullAllowedIndent + indent + indent +
1218                            "_exceptionType = " +
1219                            "\"java/lang/IllegalArgumentException\";");
1220                    out.println(nullAllowedIndent + indent + indent +
1221                            "_exceptionMessage = \"" + offset +" < 0\";");
1222                    out.println(nullAllowedIndent + indent + indent +
1223                            "goto exit;");
1224                    out.println(nullAllowedIndent + indent + "}");
1225
1226                    out.println(nullAllowedIndent + indent + remaining + " = " +
1227                            (mUseCPlusPlus ? "_env" : "(*_env)") +
1228                            "->GetArrayLength(" +
1229                            (mUseCPlusPlus ? "" : "_env, ") +
1230                            cname + "_ref) - " + offset + ";");
1231
1232                    emitNativeBoundsChecks(cfunc, cname, out, false,
1233                            emitExceptionCheck, offset, remaining,
1234                            nullAllowedIndent + indent);
1235
1236                    out.println(nullAllowedIndent + indent +
1237                                cname +
1238                                "_base = (" +
1239                                cfunc.getArgType(cIndex).getDeclaration() +
1240                                ")");
1241                    String arrayGetter = jfunc.getArgType(idx).getArrayGetterForPrimitiveArray();
1242                    out.println(nullAllowedIndent + indent + "    " +
1243                                (mUseCPlusPlus ? "_env" : "(*_env)") +
1244                                "->" + arrayGetter + "(" +
1245                                (mUseCPlusPlus ? "" : "_env, ") +
1246                                jfunc.getArgName(idx) +
1247                                "_ref, (jboolean *)0);");
1248                    out.println(nullAllowedIndent + indent +
1249                                cname + " = " + cname + "_base + " + offset + ";");
1250
1251                    emitSentinelCheck(cfunc, cname, out, false,
1252                            emitExceptionCheck, offset, remaining,
1253                            nullAllowedIndent + indent);
1254
1255                    if (nullAllowed) {
1256                        out.println(indent + "}");
1257                    }
1258
1259                    out.println();
1260                } else if (jfunc.getArgType(idx).isArray()
1261                              && jfunc.getArgType(idx).isEGLHandle()) {
1262                    needsExit = true;
1263
1264                    if (nullAllowed) {
1265                        out.println(indent + "if (" + cname + "_ref) {");
1266                    }
1267                    else
1268                    {
1269                        out.println(indent + "if (!" + cname + "_ref) {");
1270                        out.println(indent + indent + "_exception = 1;");
1271                        out.println(indent + indent + "_exceptionType = " +
1272                                "\"java/lang/IllegalArgumentException\";");
1273                        out.println(indent + indent + "_exceptionMessage = \"" +
1274                                cname +" == null\";");
1275                        out.println(indent + indent + "goto exit;");
1276                        out.println(indent + "}");
1277                    }
1278
1279                    out.println(nullAllowedIndent + indent + "if (" + offset +
1280                            " < 0) {");
1281                    out.println(nullAllowedIndent + indent + indent +
1282                            "_exception = 1;");
1283                    out.println(nullAllowedIndent + indent + indent +
1284                            "_exceptionType = " +
1285                            "\"java/lang/IllegalArgumentException\";");
1286                    out.println(nullAllowedIndent + indent + indent +
1287                            "_exceptionMessage = \"" + offset +" < 0\";");
1288                    out.println(nullAllowedIndent + indent + indent +
1289                            "goto exit;");
1290                    out.println(nullAllowedIndent + indent + "}");
1291
1292                    out.println(nullAllowedIndent + indent + remaining + " = " +
1293                                    (mUseCPlusPlus ? "_env" : "(*_env)") +
1294                                    "->GetArrayLength(" +
1295                                    (mUseCPlusPlus ? "" : "_env, ") +
1296                                    cname + "_ref) - " + offset + ";");
1297                    emitNativeBoundsChecks(cfunc, cname, out, false,
1298                            emitExceptionCheck, offset, remaining,
1299                            nullAllowedIndent + indent);
1300                    out.println(nullAllowedIndent + indent +
1301                                jfunc.getArgName(idx) + " = new " +
1302                                cfunc.getArgType(cIndex).getBaseType() +
1303                               "["+ remaining + "];");
1304
1305                    if (nullAllowed) {
1306                        out.println(indent + "}");
1307                    }
1308
1309                    out.println();
1310                } else if (jfunc.getArgType(idx).isBuffer()) {
1311                    String array = numBufferArgs <= 1 ? "_array" :
1312                        "_" + cfunc.getArgName(cIndex) + "Array";
1313                    String bufferOffset = numBufferArgs <= 1 ? "_bufferOffset" :
1314                        "_" + cfunc.getArgName(cIndex) + "BufferOffset";
1315
1316                    nullAllowed = nullAllowed || isPointerFunc;
1317                    if (nullAllowed) {
1318                        out.println(indent + "if (" + cname + "_buf) {");
1319                        out.print(indent);
1320                    }
1321
1322                    if (isPointerFunc) {
1323                        out.println(indent +
1324                                cname +
1325                                " = (" +
1326                                cfunc.getArgType(cIndex).getDeclaration() +
1327                                ") getDirectBufferPointer(_env, " +
1328                                cname + "_buf);");
1329                        String iii = "    ";
1330                        out.println(iii + indent + "if ( ! " + cname + " ) {");
1331                        out.println(iii + indent + indent + "return;");
1332                        out.println(iii + indent + "}");
1333                    } else {
1334                        out.println(indent +
1335                                    cname +
1336                                    " = (" +
1337                                    cfunc.getArgType(cIndex).getDeclaration() +
1338                                    ")getPointer(_env, " +
1339                                    cname +
1340                                    "_buf, (jarray*)&" + array + ", &" + remaining + ", &" + bufferOffset +
1341                                    ");");
1342                    }
1343
1344                    emitNativeBoundsChecks(cfunc, cname, out, true,
1345                                           emitExceptionCheck,
1346                                           offset, remaining, nullAllowed ? "        " : "    ");
1347
1348                    if (nullAllowed) {
1349                        out.println(indent + "}");
1350                    }
1351                }
1352            }
1353        }
1354
1355        // Emit 'GetPrimitiveArrayCritical' for pointers if needed
1356        if (nonPrimitiveArgs.size() > 0) {
1357            for (int i = 0; i < nonPrimitiveArgs.size(); i++) {
1358                int idx = nonPrimitiveArgs.get(i).intValue();
1359                int cIndex = jfunc.getArgCIndex(idx);
1360
1361                if(!jfunc.getArgType(idx).isBuffer() || isPointerFunc) continue;
1362
1363                String cname = cfunc.getArgName(cIndex);
1364                String bufferOffset = numBufferArgs <= 1 ? "_bufferOffset" :
1365                            "_" + cname + "BufferOffset";
1366                String array = numBufferArgs <= 1 ? "_array" :
1367                            "_" + cfunc.getArgName(cIndex) + "Array";
1368
1369                boolean nullAllowed = isNullAllowed(cfunc, cname) ||
1370                        isPointerFunc;
1371                if (nullAllowed) {
1372                    out.println(indent + "if (" + cname + "_buf && " + cname +" == NULL) {");
1373                } else {
1374                    out.println(indent + "if (" + cname +" == NULL) {");
1375                }
1376                JType argType = jfunc.getArgType(idx);
1377                if (argType.isTypedBuffer()) {
1378                    String arrayGetter = argType.getArrayTypeForTypedBuffer().getArrayGetterForPrimitiveArray();
1379                    out.println(indent + indent + "char * _" + cname + "Base = (char *)_env->" + arrayGetter + "(" + array + ", (jboolean *) 0);");
1380                    out.println(indent + indent + cname + " = (" +cfunc.getArgType(cIndex).getDeclaration() +") (_" + cname + "Base + " + bufferOffset + ");");
1381                    out.println(indent + "}");
1382                } else {
1383                    out.println(indent + indent + "char * _" + cname + "Base = (char *)_env->GetPrimitiveArrayCritical(" + array + ", (jboolean *) 0);");
1384                    out.println(indent + indent + cname + " = (" +cfunc.getArgType(cIndex).getDeclaration() +") (_" + cname + "Base + " + bufferOffset + ");");
1385                    out.println(indent + "}");
1386                }
1387             }
1388        }
1389
1390
1391        if (!isVoid) {
1392            out.print(indent + "_returnValue = ");
1393        } else {
1394            out.print(indent);
1395        }
1396        String name = cfunc.getName();
1397
1398        if (mUseContextPointer) {
1399            name = name.substring(2, name.length()); // Strip off 'gl' prefix
1400            name = name.substring(0, 1).toLowerCase() +
1401                name.substring(1, name.length());
1402            out.print("ctx->procs.");
1403        }
1404
1405        out.print(name + (isPointerFunc ? "Bounds" : "") + "(");
1406
1407        numArgs = cfunc.getNumArgs();
1408        if (numArgs == 0) {
1409            if (mUseContextPointer) {
1410                out.println("ctx);");
1411            } else {
1412                out.println(");");
1413            }
1414        } else {
1415            if (mUseContextPointer) {
1416                out.println("ctx,");
1417            } else {
1418                out.println();
1419            }
1420            for (int i = 0; i < numArgs; i++) {
1421                String typecast;
1422                if (i == numArgs - 1 && isPointerOffsetFunc) {
1423                    typecast = "reinterpret_cast<GLvoid *>";
1424                } else {
1425                    typecast = "(" + cfunc.getArgType(i).getDeclaration() + ")";
1426                }
1427                out.print(indent + indent +
1428                          typecast);
1429
1430                if (cfunc.getArgType(i).isConstCharPointer()) {
1431                    out.print("_native");
1432                }
1433
1434                if (cfunc.getArgType(i).isEGLHandle() &&
1435                    !cfunc.getArgType(i).isPointer()){
1436                    out.print(cfunc.getArgName(i)+"_native");
1437                } else if (i == numArgs - 1 && isPointerOffsetFunc){
1438                    out.print("("+cfunc.getArgName(i)+")");
1439                } else {
1440                    out.print(cfunc.getArgName(i));
1441                }
1442
1443                if (i == numArgs - 1) {
1444                    if (isPointerFunc) {
1445                        out.println(",");
1446                        out.println(indent + indent + "(GLsizei)remaining");
1447                    } else {
1448                        out.println();
1449                    }
1450                } else {
1451                    out.println(",");
1452                }
1453            }
1454            out.println(indent + ");");
1455        }
1456
1457        if (needsExit) {
1458            out.println();
1459            out.println("exit:");
1460            needsExit = false;
1461        }
1462
1463
1464        if (nonPrimitiveArgs.size() > 0) {
1465            for (int i = nonPrimitiveArgs.size() - 1; i >= 0; i--) {
1466                int idx = nonPrimitiveArgs.get(i).intValue();
1467
1468                int cIndex = jfunc.getArgCIndex(idx);
1469                if (jfunc.getArgType(idx).isArray() && !jfunc.getArgType(idx).isClass()) {
1470
1471                    // If the argument is 'const', GL will not write to it.
1472                    // In this case, we can use the 'JNI_ABORT' flag to avoid
1473                    // the need to write back to the Java array
1474                    out.println(indent +
1475                                "if (" + jfunc.getArgName(idx) + "_base) {");
1476                    String arrayReleaser = jfunc.getArgType(idx).getArrayReleaserForPrimitiveArray();
1477                    out.println(indent + indent +
1478                                (mUseCPlusPlus ? "_env" : "(*_env)") +
1479                                "->" + arrayReleaser + "(" +
1480                                (mUseCPlusPlus ? "" : "_env, ") +
1481                                jfunc.getArgName(idx) + "_ref, " +
1482                                "(j" + jfunc.getArgType(idx).getBaseType() + "*)" + cfunc.getArgName(cIndex) +
1483                                "_base,");
1484                    out.println(indent + indent + indent +
1485                                (cfunc.getArgType(cIndex).isConst() ?
1486                                 "JNI_ABORT" : "_exception ? JNI_ABORT: 0" ) +
1487                                ");");
1488                    out.println(indent + "}");
1489                } else if (jfunc.getArgType(idx).isBuffer()) {
1490                    if (! isPointerFunc) {
1491                        JType argType = jfunc.getArgType(idx);
1492                        String array = numBufferArgs <= 1 ? "_array" :
1493                            "_" + cfunc.getArgName(cIndex) + "Array";
1494                        out.println(indent + "if (" + array + ") {");
1495                        if (argType.isTypedBuffer()) {
1496                            String arrayReleaser =
1497                                argType.getArrayTypeForTypedBuffer().getArrayReleaserForPrimitiveArray();
1498                            out.println(indent + indent +
1499                                "_env->" + arrayReleaser + "(" + array + ", " +
1500                                "(j" + argType.getArrayTypeForTypedBuffer().getBaseType() + "*)" +
1501                                cfunc.getArgName(cIndex) +
1502                                ", " +
1503                                (cfunc.getArgType(cIndex).isConst() ?
1504                                    "JNI_ABORT" : (emitExceptionCheck ?
1505                                        "_exception ? JNI_ABORT : 0" : "0")) +
1506                                ");");
1507                        } else {
1508                            out.println(indent + indent +
1509                                "releasePointer(_env, " + array + ", " +
1510                                cfunc.getArgName(cIndex) +
1511                                ", " +
1512                                (cfunc.getArgType(cIndex).isConst() ?
1513                                    "JNI_FALSE" : (emitExceptionCheck ?
1514                                        "_exception ? JNI_FALSE : JNI_TRUE" : "JNI_TRUE")) +
1515                                ");");
1516                        }
1517                        out.println(indent + "}");
1518                    }
1519                }
1520            }
1521        }
1522
1523        // Emit local variable declaration for strings
1524        if (stringArgs.size() > 0) {
1525            for (int i = 0; i < stringArgs.size(); i++) {
1526                int idx = stringArgs.get(i).intValue();
1527                int cIndex = jfunc.getArgCIndex(idx);
1528                String cname = cfunc.getArgName(cIndex);
1529
1530                out.println(indent + "if (_native" + cname + ") {");
1531                out.println(indent + "    _env->ReleaseStringUTFChars(" + cname + ", _native" + cname + ");");
1532                out.println(indent + "}");
1533            }
1534
1535            out.println();
1536        }
1537
1538        // Copy results back to java arrays
1539       if (nonPrimitiveArgs.size() > 0) {
1540            for (int i = nonPrimitiveArgs.size() - 1; i >= 0; i--) {
1541                int idx = nonPrimitiveArgs.get(i).intValue();
1542                int cIndex = jfunc.getArgCIndex(idx);
1543                String baseType = cfunc.getArgType(cIndex).getBaseType().toLowerCase();
1544                if (jfunc.getArgType(idx).isArray() && jfunc.getArgType(idx).isClass()) {
1545                    remaining  = ((numArrays + numBuffers) <= 1) ? "_remaining" :
1546                                     "_" + cfunc.getArgName(cIndex) + "Remaining";
1547                    offset = numArrays <= 1 ? "offset" : cfunc.getArgName(cIndex) + "Offset";
1548                    out.println(indent +
1549                                "if (" + jfunc.getArgName(idx) + ") {");
1550                    out.println(indent + indent +
1551                                "for (int i = 0; i < " + remaining + "; i++) {");
1552                    out.println(indent + indent + indent +
1553                                "jobject " + cfunc.getArgName(cIndex) +
1554                                "_new = toEGLHandle(_env, " + baseType +
1555                                "Class, " + baseType + "Constructor, " +
1556                                cfunc.getArgName(cIndex) + "[i]);");
1557                    out.println(indent + indent + indent +
1558                                (mUseCPlusPlus ? "_env" : "(*_env)") +
1559                                "->SetObjectArrayElement(" +
1560                                (mUseCPlusPlus ? "" : "_env, ") +
1561                                cfunc.getArgName(cIndex) +
1562                                "_ref, i + " + offset + ", " +
1563                                cfunc.getArgName(cIndex) + "_new);");
1564                    out.println(indent + indent + "}");
1565                    out.println(indent + indent +
1566                                "delete[] " + jfunc.getArgName(idx) + ";");
1567                    out.println(indent + "}");
1568                }
1569            }
1570        }
1571
1572
1573        // Throw exception if there is one
1574        if (emitExceptionCheck) {
1575            out.println(indent + "if (_exception) {");
1576            out.println(indent + indent +
1577                        "jniThrowException(_env, _exceptionType, _exceptionMessage);");
1578            out.println(indent + "}");
1579
1580        }
1581
1582
1583        if (!isVoid) {
1584            if (cfunc.getType().isEGLHandle()) {
1585                String baseType = cfunc.getType().getBaseType().toLowerCase();
1586                out.println(indent +
1587                            "return toEGLHandle(_env, " + baseType + "Class, " +
1588                            baseType + "Constructor, _returnValue);");
1589            } else {
1590                out.println(indent + "return (" +
1591                            getJniType(jfunc.getType()) + ")_returnValue;");
1592            }
1593        }
1594
1595        out.println("}");
1596        out.println();
1597    }
1598
1599}
1600