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.util.ArrayList;
18 import java.util.List;
19 
20 public class JFunc {
21 
22     String className = "com.google.android.gles_jni.GL11Impl";
23 
24     CFunc cfunc;
25     JType ftype;
26     String fname;
27 
28     List<String> argNames = new ArrayList<String>();
29     List<JType> argTypes = new ArrayList<JType>();
30     List<Integer> argCIndices = new ArrayList<Integer>();
31 
32     boolean hasBufferArg = false;
33     boolean hasTypedBufferArg = false;
34     ArrayList<String> bufferArgNames = new ArrayList<String>();
35 
JFunc(CFunc cfunc)36     public JFunc(CFunc cfunc) {
37         this.cfunc = cfunc;
38     }
39 
getCFunc()40     public CFunc getCFunc() {
41         return cfunc;
42     }
43 
setName(String fname)44     public void setName(String fname) {
45         this.fname = fname;
46     }
47 
getName()48     public String getName() {
49         return fname;
50     }
51 
setType(JType ftype)52     public void setType(JType ftype) {
53         this.ftype = ftype;
54     }
55 
getType()56     public JType getType() {
57         return ftype;
58     }
59 
setClassName(String className)60     public void setClassName(String className) {
61         this.className = className;
62     }
63 
getClassName()64     public String getClassName() {
65         return className;
66     }
67 
hasBufferArg()68     public boolean hasBufferArg() {
69         return hasBufferArg;
70     }
71 
hasTypedBufferArg()72     public boolean hasTypedBufferArg() {
73         return hasTypedBufferArg;
74     }
75 
getBufferArgName(int index)76     public String getBufferArgName(int index) {
77         return bufferArgNames.get(index);
78     }
79 
addArgument(String argName, JType argType, int cindex)80     public void addArgument(String argName, JType argType, int cindex) {
81         argNames.add(argName);
82         argTypes.add(argType);
83         argCIndices.add(new Integer(cindex));
84 
85         if (argType.isBuffer()) {
86             hasBufferArg = true;
87             bufferArgNames.add(argName);
88         }
89         if (argType.isTypedBuffer()) {
90             hasTypedBufferArg = true;
91             bufferArgNames.add(argName);
92         }
93     }
94 
getNumArgs()95     public int getNumArgs() {
96         return argNames.size();
97     }
98 
getArgIndex(String name)99     public int getArgIndex(String name) {
100         int len = argNames.size();
101         for (int i = 0; i < len; i++) {
102             if (name.equals(argNames.get(i))) {
103                 return i;
104             }
105         }
106         return -1;
107     }
108 
getArgName(int index)109     public String getArgName(int index) {
110         return argNames.get(index);
111     }
112 
getArgType(int index)113     public JType getArgType(int index) {
114         return argTypes.get(index);
115     }
116 
getArgCIndex(int index)117     public int getArgCIndex(int index) {
118         return argCIndices.get(index).intValue();
119     }
120 
convert(CFunc cfunc, boolean useArray)121     public static JFunc convert(CFunc cfunc, boolean useArray) {
122         try {
123             JFunc jfunc = new JFunc(cfunc);
124             jfunc.setName(cfunc.getName());
125             jfunc.setType(JType.convert(cfunc.getType(), false));
126 
127             int numArgs = cfunc.getNumArgs();
128             int numOffsets = 0;
129             for (int i = 0; i < numArgs; i++) {
130                 CType cArgType = cfunc.getArgType(i);
131                 if (cArgType.isTypedPointer() && useArray) {
132                     ++numOffsets;
133                 }
134             }
135 
136             for (int i = 0; i < numArgs; i++) {
137                 String cArgName = cfunc.getArgName(i);
138                 CType cArgType = cfunc.getArgType(i);
139 
140                 jfunc.addArgument(cArgName, JType.convert(cArgType, useArray), i);
141                 if (cArgType.isTypedPointer() && useArray) {
142                     if (numOffsets > 1) {
143                         jfunc.addArgument(cArgName + "Offset", new JType("int"), i);
144                     } else {
145                         jfunc.addArgument("offset", new JType("int"), i);
146                     }
147                 }
148             }
149 
150             return jfunc;
151         } catch (RuntimeException e) {
152             System.err.println("Failed to convert function " + cfunc);
153             throw e;
154         }
155     }
156 
157     @Override
toString()158     public String toString() {
159         String s =  "Function " + fname + " returns " + ftype + ": ";
160         for (int i = 0; i < argNames.size(); i++) {
161             if (i > 0) {
162                 s += ", ";
163             }
164             s += argTypes.get(i) + " " + argNames.get(i);
165         }
166         return s;
167     }
168 
169 }
170