← Back to branch summary

~ubuntu-branches/ubuntu/quantal/hawtjni/quantal

« back to all changes in this revision

Viewing changes to hawtjni-generator/src/main/java/org/fusesource/hawtjni/generator/StatsGenerator.java

  • Committer: Bazaar Package Importer
  • Author(s): Miguel Landaeta
  • Date: 2010-08-05 19:40:25 UTC
  • Revision ID: james.westby@ubuntu.com-20100805194025-3004hn889accwu2i
Tags: upstream-1.0~+git0c502e20c4
Import upstream version 1.0~+git0c502e20c4

Show diffs side-by-side

added added

removed removed

Lines of Context:
hawtjni-generator/src/main/java/org/fusesource/hawtjni/generator/StatsGenerator.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2009 Progress Software, Inc.
 
3
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 
4
 *
 
5
 * All rights reserved. This program and the accompanying materials
 
6
 * are made available under the terms of the Eclipse Public License v1.0
 
7
 * which accompanies this distribution, and is available at
 
8
 * http://www.eclipse.org/legal/epl-v10.html
 
9
 *
 
10
 *******************************************************************************/
 
11
package org.fusesource.hawtjni.generator;
 
12
 
 
13
import java.lang.reflect.Modifier;
 
14
import java.util.List;
 
15
 
 
16
import org.fusesource.hawtjni.generator.model.JNIClass;
 
17
import org.fusesource.hawtjni.generator.model.JNIMethod;
 
18
 
 
19
/**
 
20
 * 
 
21
 * @author <a href="http://hiramchirino.com">Hiram Chirino</a>
 
22
 */
 
23
public class StatsGenerator extends JNIGenerator {
 
24
 
 
25
    boolean header;
 
26
 
 
27
    public StatsGenerator(boolean header) {
 
28
        this.header = header;
 
29
    }
 
30
 
 
31
    public void generateCopyright() {
 
32
        outputln(fixDelimiter(getCopyright()));
 
33
    }
 
34
 
 
35
    public void generateIncludes() {
 
36
        if (!header) {
 
37
            outputln("#include \"hawtjni.h\"");
 
38
            outputln("#include \""+getOutputName()+"_stats.h\"");
 
39
            outputln();
 
40
        }
 
41
    }
 
42
 
 
43
    public void generate(JNIClass clazz) {
 
44
        if (header) {
 
45
            generateHeaderFile(clazz);
 
46
        } else {
 
47
            generateSourceFile(clazz);
 
48
        }
 
49
    }
 
50
 
 
51
    void generateHeaderFile(JNIClass clazz) {
 
52
        generateNATIVEMacros(clazz);
 
53
        List<JNIMethod> methods = clazz.getDeclaredMethods();
 
54
        sortMethods(methods);
 
55
        generateFunctionEnum(methods);
 
56
    }
 
57
 
 
58
    void generateNATIVEMacros(JNIClass clazz) {
 
59
        String className = clazz.getSimpleName();
 
60
        outputln("#ifdef NATIVE_STATS");
 
61
        output("extern int ");
 
62
        output(className);
 
63
        outputln("_nativeFunctionCount;");
 
64
        output("extern int ");
 
65
        output(className);
 
66
        outputln("_nativeFunctionCallCount[];");
 
67
        output("extern char* ");
 
68
        output(className);
 
69
        outputln("_nativeFunctionNames[];");
 
70
        output("#define ");
 
71
        output(className);
 
72
        output("_NATIVE_ENTER(env, that, func) ");
 
73
        output(className);
 
74
        outputln("_nativeFunctionCallCount[func]++;");
 
75
        output("#define ");
 
76
        output(className);
 
77
        outputln("_NATIVE_EXIT(env, that, func) ");
 
78
        outputln("#else");
 
79
        output("#ifndef ");
 
80
        output(className);
 
81
        outputln("_NATIVE_ENTER");
 
82
        output("#define ");
 
83
        output(className);
 
84
        outputln("_NATIVE_ENTER(env, that, func) ");
 
85
        outputln("#endif");
 
86
        output("#ifndef ");
 
87
        output(className);
 
88
        outputln("_NATIVE_EXIT");
 
89
        output("#define ");
 
90
        output(className);
 
91
        outputln("_NATIVE_EXIT(env, that, func) ");
 
92
        outputln("#endif");
 
93
        outputln("#endif");
 
94
        outputln();
 
95
    }
 
96
 
 
97
    void generateSourceFile(JNIClass clazz) {
 
98
        outputln("#ifdef NATIVE_STATS");
 
99
        outputln();
 
100
        List<JNIMethod> methods = clazz.getDeclaredMethods();
 
101
        int methodCount = 0;
 
102
        for (JNIMethod method : methods) {
 
103
            if ((method.getModifiers() & Modifier.NATIVE) == 0)
 
104
                continue;
 
105
            methodCount++;
 
106
        }
 
107
        String className = clazz.getSimpleName();
 
108
        output("int ");
 
109
        output(className);
 
110
        output("_nativeFunctionCount = ");
 
111
        output(String.valueOf(methodCount));
 
112
        outputln(";");
 
113
        output("int ");
 
114
        output(className);
 
115
        output("_nativeFunctionCallCount[");
 
116
        output(String.valueOf(methodCount));
 
117
        outputln("];");
 
118
        output("char * ");
 
119
        output(className);
 
120
        outputln("_nativeFunctionNames[] = {");
 
121
        sortMethods(methods);
 
122
        for (JNIMethod method : methods) {
 
123
            if ((method.getModifiers() & Modifier.NATIVE) == 0)
 
124
                continue;
 
125
            String function = getFunctionName(method), function64 = getFunctionName(method, method.getParameterTypes64());
 
126
            if (!function.equals(function64)) {
 
127
                output("#ifndef ");
 
128
                output(JNI64);
 
129
                outputln();
 
130
            }
 
131
            output("\t\"");
 
132
            output(function);
 
133
            outputln("\",");
 
134
            if (!function.equals(function64)) {
 
135
                outputln("#else");
 
136
                output("\t\"");
 
137
                output(function64);
 
138
                outputln("\",");
 
139
                outputln("#endif");
 
140
            }
 
141
            if (progress != null)
 
142
                progress.step();
 
143
        }
 
144
        outputln("};");
 
145
        outputln();
 
146
        generateStatsNatives(className);
 
147
        outputln();
 
148
        outputln("#endif");
 
149
    }
 
150
 
 
151
    void generateStatsNatives(String className) {
 
152
        outputln("#define STATS_NATIVE(func) Java_org_fusesource_hawtjni_runtime_NativeStats_##func");
 
153
        outputln();
 
154
 
 
155
        output("JNIEXPORT jint JNICALL STATS_NATIVE(");
 
156
        output(toC(className + "_GetFunctionCount"));
 
157
        outputln(")");
 
158
        outputln("\t(JNIEnv *env, jclass that)");
 
159
        outputln("{");
 
160
        output("\treturn ");
 
161
        output(className);
 
162
        outputln("_nativeFunctionCount;");
 
163
        outputln("}");
 
164
        outputln();
 
165
 
 
166
        output("JNIEXPORT jstring JNICALL STATS_NATIVE(");
 
167
        output(toC(className + "_GetFunctionName"));
 
168
        outputln(")");
 
169
        outputln("\t(JNIEnv *env, jclass that, jint index)");
 
170
        outputln("{");
 
171
        output("\treturn ");
 
172
        if (isCPP) {
 
173
            output("env->NewStringUTF(");
 
174
        } else {
 
175
            output("(*env)->NewStringUTF(env, ");
 
176
        }
 
177
        output(className);
 
178
        outputln("_nativeFunctionNames[index]);");
 
179
        outputln("}");
 
180
        outputln();
 
181
 
 
182
        output("JNIEXPORT jint JNICALL STATS_NATIVE(");
 
183
        output(toC(className + "_GetFunctionCallCount"));
 
184
        outputln(")");
 
185
        outputln("\t(JNIEnv *env, jclass that, jint index)");
 
186
        outputln("{");
 
187
        output("\treturn ");
 
188
        output(className);
 
189
        outputln("_nativeFunctionCallCount[index];");
 
190
        outputln("}");
 
191
    }
 
192
 
 
193
    void generateFunctionEnum(List<JNIMethod> methods) {
 
194
        if (methods.isEmpty())
 
195
            return;
 
196
        outputln("typedef enum {");
 
197
        for (JNIMethod method : methods) {
 
198
            if ((method.getModifiers() & Modifier.NATIVE) == 0)
 
199
                continue;
 
200
            String function = getFunctionName(method), function64 = getFunctionName(method, method.getParameterTypes64());
 
201
            if (!function.equals(function64)) {
 
202
                output("#ifndef ");
 
203
                output(JNI64);
 
204
                outputln();
 
205
            }
 
206
            output("\t");
 
207
            output(method.getDeclaringClass().getSimpleName()+"_"+function);
 
208
            outputln("_FUNC,");
 
209
            if (!function.equals(function64)) {
 
210
                outputln("#else");
 
211
                output("\t");
 
212
                output(method.getDeclaringClass().getSimpleName()+"_"+function64);
 
213
                outputln("_FUNC,");
 
214
                outputln("#endif");
 
215
            }
 
216
            if (progress != null)
 
217
                progress.step();
 
218
        }
 
219
        JNIClass clazz = methods.get(0).getDeclaringClass();
 
220
        output("} ");
 
221
        output(clazz.getSimpleName());
 
222
        outputln("_FUNCS;");
 
223
    }
 
224
 
 
225
}