KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > caucho > es > wrapper > Wrapper


1 /*
2  * Copyright (c) 1998-2006 Caucho Technology -- all rights reserved
3  *
4  * This file is part of Resin(R) Open Source
5  *
6  * Each copy or derived work must preserve the copyright notice and this
7  * notice unmodified.
8  *
9  * Resin Open Source is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Resin Open Source is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
17  * of NON-INFRINGEMENT. See the GNU General Public License for more
18  * details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Resin Open Source; if not, write to the
22  * Free SoftwareFoundation, Inc.
23  * 59 Temple Place, Suite 330
24  * Boston, MA 02111-1307 USA
25  *
26  * @author Scott Ferguson
27  */

28
29 package com.caucho.es.wrapper;
30
31 import com.caucho.es.ESArrayWrapper;
32 import com.caucho.es.ESBase;
33 import com.caucho.es.ESBeanWrapper;
34 import com.caucho.es.Global;
35 import com.caucho.java.JavaCompiler;
36 import com.caucho.loader.SimpleLoader;
37 import com.caucho.log.Log;
38 import com.caucho.server.util.CauchoSystem;
39 import com.caucho.util.CharBuffer;
40 import com.caucho.util.IntMap;
41 import com.caucho.vfs.JarPath;
42 import com.caucho.vfs.MergePath;
43 import com.caucho.vfs.Path;
44 import com.caucho.vfs.Vfs;
45 import com.caucho.vfs.WriteStream;
46
47 import java.beans.PropertyDescriptor JavaDoc;
48 import java.io.IOException JavaDoc;
49 import java.lang.reflect.Constructor JavaDoc;
50 import java.lang.reflect.Field JavaDoc;
51 import java.lang.reflect.Method JavaDoc;
52 import java.lang.reflect.Modifier JavaDoc;
53 import java.net.URL JavaDoc;
54 import java.util.ArrayList JavaDoc;
55 import java.util.HashMap JavaDoc;
56 import java.util.Iterator JavaDoc;
57 import java.util.Map JavaDoc;
58 import java.util.logging.Logger JavaDoc;
59
60 public class Wrapper {
61   private static final Integer JavaDoc LOCK = new Integer JavaDoc(0);
62   private static final Logger JavaDoc log = Log.open(Wrapper.class);
63   
64   private String JavaDoc name;
65   private String JavaDoc javaClassName;
66   private Class JavaDoc cl;
67   private boolean isPublic;
68   private Path dest;
69   private WriteStream os;
70   private ClassLoader JavaDoc loader;
71   private JavaCompiler compiler;
72
73   private ESBeanInfo beanInfo;
74   private IntMap hasDispatch;
75   private IntMap staticHasDispatch;
76   private IntMap setDispatch;
77   private IntMap staticSetDispatch;
78   private IntMap methodDispatch;
79   private IntMap staticMethodDispatch;
80   private HashMap JavaDoc namedProperties;
81   
82   private ArrayList JavaDoc overloadDispatch;
83   
84   private int depth;
85   private boolean isNewline;
86   private Class JavaDoc esBase;
87
88   /**
89    * Creates the instance of the wrapper generator.
90    *
91    * @param resin the global parent object
92    * @param cl the class to wrap.
93    */

94   private Wrapper(Global resin, Class JavaDoc cl)
95   {
96     name = cl.getName().replace('/', '.');
97
98     MergePath mergePath = new MergePath();
99     mergePath.addClassPath(cl.getClassLoader());
100     Path destClass = mergePath.lookup(name.replace('.', '/') + ".class");
101
102     // technically, need to resort to dynamic. This is a cheat.
103
if (! destClass.exists() && cl.getInterfaces().length > 0) {
104       cl = cl.getInterfaces()[0];
105       name = cl.getName().replace('/', '.');
106     }
107     
108     javaClassName = toJavaClassName(name);
109
110     CharBuffer cb = new CharBuffer();
111     for (int i = 0; i < name.length(); i++) {
112       char ch = name.charAt(i);
113
114       if (ch == '$')
115         cb.append("_0");
116       else if (ch == '_')
117         cb.append("__");
118       else
119         cb.append(ch);
120     }
121       
122     name = "_jsbean." + cb + "_es";
123
124     this.cl = cl;
125
126     isPublic = Modifier.isPublic(cl.getModifiers());
127
128     //this.loader = resin.getParentLoader();
129
loader = cl.getClassLoader();
130
131     compiler = JavaCompiler.create(loader);
132     //compiler.setEncoding("utf8");
133
Path workPath = CauchoSystem.getWorkPath();
134     
135     dest = workPath.lookup(name.replace('.', '/') + ".java");
136
137     hasDispatch = new IntMap();
138     staticHasDispatch = new IntMap();
139     setDispatch = new IntMap();
140     staticSetDispatch = new IntMap();
141     methodDispatch = new IntMap();
142     staticMethodDispatch = new IntMap();
143     namedProperties = new HashMap JavaDoc();
144     
145     overloadDispatch = new ArrayList JavaDoc();
146
147     try {
148       esBase = Class.forName("com.caucho.es.ESBase");
149     } catch (Exception JavaDoc e) {
150     }
151   }
152
153   public static ESBase []bean(Global resin, Class JavaDoc cl)
154     throws Throwable JavaDoc
155   {
156     Wrapper wrapper = null;
157     
158     if (cl.isArray()) {
159       ESBase arrayWrapper = ESArrayWrapper.wrapper(resin, cl);
160       return new ESBase[] { arrayWrapper.getProperty("CONSTRUCTOR"),
161                             arrayWrapper };
162     }
163
164     synchronized (LOCK) {
165       wrapper = new Wrapper(resin, cl);
166       ESBeanWrapper beanWrapper = wrapper.wrap();
167       beanWrapper.n = 0;
168       
169       return new ESBase[] { beanWrapper.wrapStatic(), beanWrapper };
170     }
171   }
172
173   /**
174    * Creates the wrapper for a class
175    */

176   private ESBeanWrapper wrap() throws Throwable JavaDoc
177   {
178     dest.getParent().mkdirs();
179
180     Path workPath = CauchoSystem.getWorkPath();
181     Path destClass = workPath.lookup(name.replace('.', '/') + ".class");
182
183     ClassLoader JavaDoc beanLoader;
184     beanLoader = SimpleLoader.create(loader,
185                                           CauchoSystem.getWorkPath(),
186                                           name);
187     ESBeanWrapper wrapper;
188
189     try {
190       Class JavaDoc cl = CauchoSystem.loadClass(name, false, beanLoader);
191       wrapper = (ESBeanWrapper) cl.newInstance();
192
193       if (! wrapper.isModified() && wrapper.getVersionId() == CauchoSystem.getVersionId())
194     return wrapper;
195     } catch (Throwable JavaDoc e) {
196     }
197     
198     destClass.remove();
199     os = dest.openWrite();
200
201     beanInfo = ESIntrospector.getBeanInfo(cl);
202
203     try {
204       printHeader();
205       printConstructors();
206       printHasProperty();
207       printSetProperty();
208       printKeys();
209       printDeletes();
210       printMethods();
211       printInit();
212       printFooter();
213     } finally {
214       os.close();
215     }
216
217     compiler.compile(name.replace('.', '/') + ".java", null);
218
219     beanLoader = SimpleLoader.create(loader,
220                                           CauchoSystem.getWorkPath(),
221                                           name);
222     
223     try {
224       Class JavaDoc cl = CauchoSystem.loadClass(name, false, beanLoader);
225       wrapper = (ESBeanWrapper) cl.newInstance();
226     } catch (NoClassDefFoundError JavaDoc e) {
227       e.printStackTrace();
228       throw e;
229     }
230
231     return wrapper;
232   }
233
234   private long getSourceLastModified(Class JavaDoc cl)
235   {
236     long lastModified = 0;
237     String JavaDoc classPath;
238     
239     URL JavaDoc resource = null;
240     String JavaDoc clName = cl.getName().replace('.', '/') + ".class";
241     String JavaDoc name;
242
243     if (loader != null)
244       resource = loader.getResource(clName);
245
246     String JavaDoc fileName = resource != null ? resource.toExternalForm() : null;
247
248     // XXX: need to implement jar: filesystem
249
if (resource == null ||
250         fileName.startsWith("systemresource:") ||
251         fileName.startsWith("jar:"))
252       return getClassPathLastModified(cl);
253
254     Path path = Vfs.lookup(fileName);
255
256     if (path != null && path.canRead())
257       return path.getLastModified();
258     else
259       return 0;
260   }
261
262   private long getClassPathLastModified(Class JavaDoc cl)
263   {
264     String JavaDoc clName = cl.getName().replace('.', '/') + ".class";
265
266     String JavaDoc classPath = System.getProperty("java.class.path");
267         
268     char sep = CauchoSystem.getPathSeparatorChar();
269     int head = 0;
270     int tail;
271     for (; (tail = classPath.indexOf(sep, head)) >= 0; head = tail + 1) {
272       String JavaDoc name = classPath.substring(head, tail);
273       Path path = Vfs.lookupNative(name);
274
275       if (name.endsWith(".jar") || name.endsWith(".zip"))
276         path = JarPath.create(path);
277
278       if (path != null && path.lookup(clName).canRead()) {
279         return path.lookup(clName).getLastModified();
280       }
281     }
282
283     String JavaDoc name = classPath.substring(head);
284     Path path = Vfs.lookupNative(name);
285
286     if (name.endsWith(".jar") || name.endsWith(".zip"))
287       path = JarPath.create(path);
288
289     if (path != null && path.lookup(clName).canRead())
290       return path.lookup(clName).getLastModified();
291     
292     return 0;
293   }
294
295   private void printHeader() throws IOException JavaDoc
296   {
297     int p = name.lastIndexOf('.');
298     String JavaDoc pkg = name.substring(0, p);
299     String JavaDoc clName = name.substring(p + 1);
300
301     println("package " + pkg + ";");
302     println("import com.caucho.es.*;");
303     Iterator JavaDoc iter = beanInfo.getNonPkgClasses().iterator();
304     while (iter.hasNext()) {
305       String JavaDoc name = (String JavaDoc) iter.next();
306       println("import " + name + ";");
307     }
308     println();
309     println("public class " + clName + " extends ESBeanWrapper {");
310     pushDepth();
311     if (isPublic)
312       println("private " + javaClassName + " _value;");
313
314     println();
315     println("public long getVersionId() { return " +
316             CauchoSystem.getVersionId() + "L; }");
317     
318     println();
319     println("protected ESBeanWrapper dup()");
320     println("{");
321     println(" return new " + clName + "();");
322     println("}");
323
324     println();
325     println("public ESBeanWrapper wrap(Object value)");
326     println("{");
327     pushDepth();
328     println("if (value == null) throw new NullPointerException();");
329     println(name + " child = new " + name + "();");
330     println("child.value = value;");
331     if (isPublic)
332       println("child._value = (" + javaClassName + ") value;");
333     println("child.hasDispatch = instanceHasDispatch;");
334     println("child.setDispatch = instanceSetDispatch;");
335     println("child.methodDispatch = instanceMethodDispatch;");
336     println("child.n = -1;");
337     println("return child;");
338     popDepth();
339     println("}");
340     
341     println();
342     println("public ESBeanWrapper wrapStatic()");
343     println("{");
344     pushDepth();
345     println(name + " child = new " + name + "();");
346     println("child.hasDispatch = staticHasDispatch;");
347     println("child.setDispatch = staticSetDispatch;");
348     println("child.methodDispatch = staticMethodDispatch;");
349     println("child.n = -2;");
350     println("child.name = \"" + javaClassName + "\";");
351     println("try {");
352     println(" child.value = Class.forName(child.name);");
353     println("} catch (Exception e) {}");
354     println("return child;");
355     popDepth();
356     println("}");
357
358     println();
359     println("public Class getJavaType()");
360     println("{");
361     pushDepth();
362     println("return value.getClass();");
363     popDepth();
364     println("}");
365   }
366   
367   private void printConstructors() throws IOException JavaDoc
368   {
369     println();
370     println("public ESBase construct(Call call, int length)");
371     println(" throws Throwable");
372     println("{");
373     pushDepth();
374     println("if (n != -2)");
375     println(" throw new ESException(\"can't create `" + javaClassName + "'\");");
376     println();
377
378     if (printMethodConstructor()) {
379       popDepth();
380       println("}");
381       return;
382     }
383     
384     ArrayList JavaDoc overload = beanInfo.getConstructors();
385     if (Modifier.isAbstract(cl.getModifiers()))
386       overload = null;
387     
388     if (overload == null || overload.size() == 0) {
389       println(" throw new ESException(\"can't create `" + javaClassName + "'\");");
390     }
391     else {
392
393     Constructor JavaDoc last = null;
394     for (int i = 0; i < overload.size(); i++) {
395       if (overload.get(i) instanceof Constructor JavaDoc)
396         last = (Constructor JavaDoc) overload.get(i);
397     }
398
399     for (int i = 0; i < overload.size(); i++) {
400       Object JavaDoc o = overload.get(i);
401       if (! (o instanceof Constructor JavaDoc))
402         continue;
403
404       Constructor JavaDoc constructor = (Constructor JavaDoc) o;
405       if (constructor != last) {
406         println("if (length <= " + i + ")");
407         print(" ");
408       }
409
410       print("return wrap(new " + javaClassName + "(");
411       Class JavaDoc []param = constructor.getParameterTypes();
412       for (int j = 0; j < param.length; j++) {
413         if (j > 0)
414           print(", ");
415
416         printArgToJava(param[j], j);
417       }
418       println("));");
419     }
420     
421     if (last == null)
422       println("throw new ESException(\"can't create `" + javaClassName + "'\");");
423     }
424
425     popDepth();
426     println("}");
427   }
428
429   private boolean printMethodConstructor() throws IOException JavaDoc
430   {
431     ArrayList JavaDoc overload = (ArrayList JavaDoc) beanInfo._staticMethodMap.get("create");
432     if (overload != null) {
433       printMethod(Integer.MIN_VALUE, "create", overload, null);
434       return true;
435     }
436     else
437       return false;
438   }
439
440   /**
441    * Print the code for accessing properties.
442    */

443   private void printHasProperty() throws IOException JavaDoc
444   {
445     println();
446     println("public ESBase hasProperty(ESString name)");
447     println(" throws Throwable");
448     println("{");
449     pushDepth();
450     println("ESBase temp;");
451     println("switch (hasDispatch.get(name)) {");
452     
453     PropertyDescriptor JavaDoc []props = beanInfo.getPropertyDescriptors();
454
455     int index = 1;
456     for (int i = 0; i < props.length; i++) {
457       if (props[i] instanceof NamedPropertyDescriptor)
458         index = doHasNamedProperty(index, (NamedPropertyDescriptor) props[i]);
459       else if (props[i] instanceof ESIndexedPropertyDescriptor)
460         index = doHasIndexProperty(index,
461                                    (ESIndexedPropertyDescriptor) props[i]);
462       else if (props[i] instanceof ESPropertyDescriptor)
463         index = doHasProperty(index, (ESPropertyDescriptor) props[i]);
464       else
465         throw new RuntimeException JavaDoc();
466     }
467     println("default:");
468     println(" return ESBase.esEmpty;");
469     println("}");
470     popDepth();
471     println("}");
472   }
473
474   private int doHasIndexProperty(int i, ESIndexedPropertyDescriptor prop)
475     throws IOException JavaDoc
476   {
477     Named named = new Named(prop.getName(), namedProperties.size());
478     int n = named.n;
479     
480     namedProperties.put(prop.getName(), named);
481     hasDispatch.put(prop.getName(), i);
482
483     println("case " + i + ":");
484     pushDepth();
485     println("if (name" + n + " == null) {");
486     println(" name" + n + " = new " + name + "();");
487     println(" name" + n + ".value = value;");
488     if (isPublic)
489       println(" name" + n + "._value = _value;");
490     println(" name" + n + ".hasDispatch = has" + n + ";");
491     println(" name" + n + ".setDispatch = set" + n + ";");
492     println(" name" + n + ".delId = " + n + ";");
493     println("}");
494     println("return name" + n + ";");
495     popDepth();
496
497     i += 1;
498
499     ESMethodDescriptor md = prop.getESReadMethod();
500     if (md == null)
501       return i;
502
503     println("case " + i + ":");
504     pushDepth();
505     named.get = i;
506     
507     ESMethodDescriptor size = prop.getESSizeMethod();
508
509     if (size != null) {
510       println("if (name.equals(LENGTH)) {");
511       pushDepth();
512       Method JavaDoc method = size.getMethod();
513       Class JavaDoc resultClass = method.getReturnType();
514       print("return ");
515       startJavaToES(resultClass);
516       startProp(size);
517       print(")");
518       endJavaToES(resultClass);
519       println(";");
520       popDepth();
521       println("} else {");
522       pushDepth();
523     }
524     Method JavaDoc method = md.getMethod();
525     Class JavaDoc resultClass = method.getReturnType();
526     print("return ");
527     startJavaToES(resultClass);
528     int p = startProp(md);
529     if (p > 0)
530       print(", ");
531     print("name.toInt32())");
532     endJavaToES(resultClass);
533     println(";");
534     if (size != null) {
535       popDepth();
536       println("}");
537     }
538
539     popDepth();
540
541     return i + 1;
542   }
543
544   private int doHasNamedProperty(int i, NamedPropertyDescriptor prop)
545     throws IOException JavaDoc
546   {
547     Named named = new Named(prop.getName(), namedProperties.size());
548     int n = named.n;
549     
550     namedProperties.put(prop.getName(), named);
551     hasDispatch.put(prop.getName(), i);
552
553     println("case " + i + ":");
554     pushDepth();
555     println("if (name" + n + " == null) {");
556     println(" name" + n + " = new " + name + "();");
557     println(" name" + n + ".value = value;");
558     if (isPublic)
559       println(" name" + n + "._value = _value;");
560     println(" name" + n + ".hasDispatch = has" + n + ";");
561     println(" name" + n + ".setDispatch = set" + n + ";");
562     println(" name" + n + ".delId = " + n + ";");
563     println("}");
564     println("return name" + n + ";");
565     popDepth();
566
567     i += 1;
568
569     ESMethodDescriptor md = prop.getNamedReadMethod();
570     if (md == null)
571       return i;
572
573     println("case " + i + ":");
574     pushDepth();
575     named.get = i;
576
577     Method JavaDoc method = md.getMethod();
578     if (Modifier.isStatic(method.getModifiers()) && ! md.isStaticVirtual())
579       staticHasDispatch.put(prop.getName(), i - 1);
580     
581     Class JavaDoc resultClass = method.getReturnType();
582     print("return ");
583     startJavaToES(resultClass);
584     int p = startProp(md);
585     if (p > 0)
586       print(", ");
587     print("name.toJavaString())");
588     endJavaToES(resultClass);
589     println(";");
590     popDepth();
591  
592     return i + 1;
593   }
594
595   private int doHasProperty(int i, ESPropertyDescriptor prop)
596     throws IOException JavaDoc
597   {
598     Field JavaDoc field = prop.getESField();
599     ESMethodDescriptor md = prop.getESReadMethod();
600
601     if (field != null && ! Modifier.isPublic(field.getModifiers()))
602       field = null;
603
604     if (md == null && field == null)
605       return i;
606     
607     hasDispatch.put(prop.getName(), i);
608     
609     println("case " + i + ":");
610     pushDepth();
611
612     if (field != null) {
613       Class JavaDoc resultClass = field.getType();
614       print("return ");
615       startJavaToES(resultClass);
616       if (isPublic && field.getDeclaringClass().getName().equals(cl.getName()))
617         print("_value.");
618       else if (Modifier.isStatic(field.getModifiers()))
619         print(toJavaClassName(field.getDeclaringClass().getName()) + ".");
620       else
621         print("((" + toJavaClassName(field.getDeclaringClass().getName()) + ") value).");
622       print(field.getName());
623       endJavaToES(resultClass);
624       println(";");
625       popDepth();
626       
627       if (Modifier.isStatic(field.getModifiers()))
628         staticHasDispatch.put(prop.getName(), i);
629       
630       return i + 1;
631     }
632     
633     Method JavaDoc method = md.getMethod();
634     
635     if (Modifier.isStatic(method.getModifiers()) && ! md.isStaticVirtual())
636       staticHasDispatch.put(prop.getName(), i);
637       
638     print("return ");
639
640     Class JavaDoc resultClass = method.getReturnType();
641     
642     startJavaToES(resultClass);
643     int p = startProp(md);
644     print(")");
645     endJavaToES(resultClass);
646     println(";");
647     popDepth();
648
649     return i + 1;
650   }
651   
652   private void printSetProperty() throws IOException JavaDoc
653   {
654     println();
655     println("public void setProperty(ESString name, ESBase newValue)");
656     println(" throws Throwable");
657     println("{");
658     pushDepth();
659     println("ESBase temp;");
660     println("switch (setDispatch.get(name)) {");
661     
662     PropertyDescriptor JavaDoc []props = beanInfo.getPropertyDescriptors();
663
664     int index = 0;
665     for (int i = 0; i < props.length; i++) {
666       if (props[i] instanceof NamedPropertyDescriptor) {
667         index = doSetNamedProperty(index,
668                                    (NamedPropertyDescriptor) props[i]);
669       }
670       else if (props[i] instanceof ESIndexedPropertyDescriptor) {
671         index = doSetIndexProperty(index,
672                                    (ESIndexedPropertyDescriptor) props[i]);
673       }
674       else if (props[i] instanceof ESPropertyDescriptor)
675         index = doSetProperty(index, (ESPropertyDescriptor) props[i]);
676       else
677         throw new RuntimeException JavaDoc();
678     }
679     println("default:");
680     println(" return;");
681     println("}");
682     popDepth();
683     println("}");
684   }
685
686   private int doSetNamedProperty(int i, NamedPropertyDescriptor prop)
687     throws IOException JavaDoc
688   {
689     Named named = (Named) namedProperties.get(prop.getName());
690     if (named == null)
691       return i;
692     
693     int n = named.n;
694
695     ESMethodDescriptor md = prop.getNamedWriteMethod();
696     if (md == null)
697       return i;
698
699     println("case " + i + ":");
700     pushDepth();
701     named.set = i;
702     
703     int p = startProp(md);
704     Class JavaDoc []param = md.getParameterTypes();
705     
706     if (p != 0)
707       print(", ");
708     print("name.toJavaString(), ");
709     printValueToJava(param[1], "newValue");
710     println(");");
711
712     println("return;");
713     popDepth();
714
715     return i + 1;
716   }
717
718   private int doSetIndexProperty(int i, ESIndexedPropertyDescriptor prop)
719     throws IOException JavaDoc
720   {
721     Named named = (Named) namedProperties.get(prop.getName());
722     if (named == null)
723       return i;
724     
725     int n = named.n;
726
727     ESMethodDescriptor md = prop.getESWriteMethod();
728     if (md == null)
729       return i;
730
731     println("case " + i + ":");
732     pushDepth();
733     named.set = i;
734     
735     int p = startProp(md);
736     Class JavaDoc []param = md.getParameterTypes();
737     
738     if (p != 0)
739       print(", ");
740     print("name.toInt32(), ");
741     printValueToJava(param[1], "newValue");
742     println(");");
743
744     println("return;");
745     popDepth();
746
747     return i + 1;
748   }
749
750   private int doSetProperty(int i, ESPropertyDescriptor prop)
751     throws IOException JavaDoc
752   {
753     ESMethodDescriptor md = prop.getESWriteMethod();
754     Field JavaDoc field = prop.getESField();
755     if (field != null && Modifier.isFinal(field.getModifiers()))
756       field = null;
757
758     if (md == null && field == null)
759       return i;
760
761     println("case " + i + ":");
762     pushDepth();
763     
764     setDispatch.put(prop.getName(), i);
765
766     if (field != null) {
767       Class JavaDoc resultClass = field.getType();
768       if (isPublic)
769         print("_value.");
770       else
771         print("((" + field.getDeclaringClass().getName() + ") value).");
772       print(field.getName());
773       print(" = ");
774       printValueToJava(resultClass, "newValue");
775       println(";");
776       println("return;");
777       popDepth();
778       return i + 1;
779     }
780     
781     Method JavaDoc method = md.getMethod();
782     
783     if (Modifier.isStatic(method.getModifiers()) && ! md.isStaticVirtual())
784       staticSetDispatch.put(prop.getName(), i);
785     
786     Class JavaDoc []param = md.getParameterTypes();
787     
788     int p = startProp(md);
789     if (p != 0)
790       print(", ");
791     printValueToJava(param[0], "newValue");
792     println(");");
793
794     println("return;");
795     
796     popDepth();
797
798     return i + 1;
799   }
800   
801   private void printKeys() throws IOException JavaDoc
802   {
803     println();
804     println("public java.util.Iterator keys()");
805     println(" throws Throwable");
806     println("{");
807     pushDepth();
808     println("switch (delId) {");
809
810     ESMethodDescriptor md = beanInfo.iterator;
811     if (md != null) {
812       println("case -1:");
813       print(" return Call.toESIterator(");
814       startProp(md);
815       println("));");
816     }
817
818     PropertyDescriptor JavaDoc []props = beanInfo.getPropertyDescriptors();
819     for (int i = 0; i < props.length; i++) {
820       if (props[i] instanceof NamedPropertyDescriptor)
821         printNamedKey((NamedPropertyDescriptor) props[i]);
822     }
823     
824     println("default:");
825     println(" return super.keys();");
826     println("}");
827     popDepth();
828     println("}");
829   }
830
831   private void printNamedKey(NamedPropertyDescriptor prop)
832     throws IOException JavaDoc
833   {
834     ESMethodDescriptor md = prop.getNamedIteratorMethod();
835     if (md == null)
836       return;
837
838     Named named = (Named) namedProperties.get(prop.getName());
839     println("case " + named.n + ":");
840     pushDepth();
841     print("return Call.toESIterator(");
842     int p = startProp(md);
843     println("));");
844     popDepth();
845   }
846   
847   private void printDeletes() throws IOException JavaDoc
848   {
849     println();
850     println("public ESBase delete(ESString key)");
851     println(" throws Throwable");
852     println("{");
853     pushDepth();
854     println("switch (delId) {");
855
856     PropertyDescriptor JavaDoc []props = beanInfo.getPropertyDescriptors();
857     for (int i = 0; i < props.length; i++) {
858       if (props[i] instanceof NamedPropertyDescriptor)
859         printNamedDelete((NamedPropertyDescriptor) props[i]);
860     }
861     
862     println("default:");
863     println(" return ESBoolean.FALSE;");
864     println("}");
865     popDepth();
866     println("}");
867   }
868
869   private void printNamedDelete(NamedPropertyDescriptor prop)
870     throws IOException JavaDoc
871   {
872     ESMethodDescriptor md = prop.getNamedRemoveMethod();
873     if (md == null)
874       return;
875
876     Named named = (Named) namedProperties.get(prop.getName());
877     println("case " + named.n + ":");
878     pushDepth();
879     int p = startProp(md);
880     if (p > 0)
881       print(", ");
882     println("key.toJavaString());");
883     println("return ESBoolean.TRUE;");
884     popDepth();
885   }
886
887   /**
888    * Prints all the accessible methods in this object.
889    */

890   private void printMethods() throws IOException JavaDoc
891   {
892     println();
893     println("public ESBase call(Call call, int length, int n)");
894     println(" throws Throwable");
895     println("{");
896     pushDepth();
897     println("ESBase temp;");
898     println("switch (n) {");
899     
900     ArrayList JavaDoc overload = (ArrayList JavaDoc) beanInfo._methodMap.get("call");
901     if (overload != null)
902       printMethod(-1, "call", overload, null);
903
904     // Print the constructor (code -2)
905
ArrayList JavaDoc create = (ArrayList JavaDoc) beanInfo._staticMethodMap.get("create");
906     ArrayList JavaDoc call = (ArrayList JavaDoc) beanInfo._staticMethodMap.get("call");
907     if (create != null)
908       printMethod(-2, "create", create, null);
909     else if (call != null)
910       printMethod(-2, "call", create, null);
911     else {
912       println("case -2:");
913       println(" return construct(call, length);");
914     }
915     
916     Iterator JavaDoc iter = beanInfo._methodMap.entrySet().iterator();
917     int i = 0;
918     while (iter.hasNext()) {
919       Map.Entry entry = (Map.Entry) iter.next();
920       overload = (ArrayList JavaDoc) entry.getValue();
921       String JavaDoc name = (String JavaDoc) entry.getKey();
922
923       i = printMethod(i, name, overload, methodDispatch);
924     }
925     
926     iter = beanInfo._staticMethodMap.entrySet().iterator();
927     while (iter.hasNext()) {
928       Map.Entry entry = (Map.Entry) iter.next();
929       overload = (ArrayList JavaDoc) entry.getValue();
930       String JavaDoc name = (String JavaDoc) entry.getKey();
931
932       i = printMethod(i, name, overload, staticMethodDispatch);
933     }
934
935     println("}");
936     println("return ESBase.esUndefined;");
937     popDepth();
938     println("}");
939   }
940
941   /**
942    * Prints a method in a method dispatch.
943    */

944   private int printMethod(int i, String JavaDoc name, ArrayList JavaDoc overload,
945                           IntMap dispatch)
946     throws IOException JavaDoc
947   {
948     ESMethodDescriptor []last = null;
949
950     if (overload == null)
951       return i;
952     
953     for (int j = 0; j < overload.size(); j++) {
954       last = (ESMethodDescriptor []) overload.get(j);
955     }
956
957     if (last == null) {
958       return i;
959     }
960
961     if (i > -100) {
962       println("case " + i + ":");
963       pushDepth();
964       if (dispatch != null)
965         dispatch.put(name, i++);
966     }
967
968     if (overload.size() > 2) {
969       ESMethodDescriptor []mds = (ESMethodDescriptor []) overload.get(2);
970
971       for (int j = 0; mds != null && j < mds.length; j++) {
972         Class JavaDoc []cl = mds[j].getParameterTypes();
973         int p = cl.length - 2;
974
975         if (cl[0].getName().equals("com.caucho.es.Call") &&
976             cl[1].getName().equals("int")) {
977           printMethod(mds[j], dispatch == null);
978           popDepth();
979           return i;
980         }
981       }
982     }
983
984     for (int j = 0; j < overload.size(); j++) {
985       Object JavaDoc o = overload.get(j);
986
987       if (o == null)
988         continue;
989
990       ESMethodDescriptor []mds = (ESMethodDescriptor []) o;
991       if (mds != last) {
992         println("if (length <= " + j + ") {");
993         pushDepth();
994       }
995
996       if (mds.length == 1)
997         printMethod(mds[0], dispatch == null);
998       else {
999         String JavaDoc var = "dispatch" + overloadDispatch.size();
1000        
1001        overloadDispatch.add(mds);
1002
1003        println("switch (" + var + ".select(call, length)) {");
1004        for (int k = 0; k < mds.length; k++) {
1005          println("case " + k + ":");
1006          pushDepth();
1007          printMethod(mds[k], dispatch == null);
1008          popDepth();
1009        }
1010
1011        println("default:");
1012        println(" throw new ESException(\"no matching method " + mds[0].getName() + "\");");
1013        println("}");
1014      }
1015      
1016      if (mds != last) {
1017        popDepth();
1018        println("}");
1019      }
1020    }
1021
1022    if (i > -100) {
1023      popDepth();
1024    }
1025    
1026    return i;
1027  }
1028
1029  /**
1030   * Print a single method based on a method descriptor. The arguments
1031   * are assumed to come from a Call object.
1032   *
1033   * @param md the method descriptor.
1034   */

1035  private void printMethod(ESMethodDescriptor md, boolean isProp)
1036    throws IOException JavaDoc
1037  {
1038    boolean hasThrowable = hasException(md.getMethod().getExceptionTypes(),
1039                                        Throwable JavaDoc.class);
1040
1041    /*
1042    if (hasThrowable) {
1043      println("try {");
1044      pushDepth();
1045    }
1046    */

1047    
1048    Class JavaDoc returnCl = md.getReturnType();
1049    if (! returnCl.getName().equals("void")) {
1050      print("return ");
1051      startJavaToES(returnCl);
1052    }
1053
1054    Class JavaDoc []param = md.getParameterTypes();
1055    
1056    int p;
1057
1058    if (isProp)
1059      p = startProp(md);
1060    else
1061      p = startCall(md);
1062
1063    if (param.length == 2 &&
1064        param[0].getName().equals("com.caucho.es.Call") &&
1065        param[1].getName().equals("int")) {
1066      if (p > 0)
1067        print(", ");
1068      print("call, length");
1069    }
1070    else {
1071      for (int j = 0; j < param.length; j++) {
1072        if (j + p > 0)
1073          print(", ");
1074      
1075        printArgToJava(param[j], j);
1076      }
1077    }
1078
1079    if (returnCl.getName().equals("void")) {
1080      println(");");
1081      println("return ESBase.esUndefined;");
1082    }
1083    else {
1084      print(")");
1085      endJavaToES(returnCl);
1086      println(";");
1087    }
1088
1089    /*
1090    if (hasThrowable) {
1091      popDepth();
1092      println("} catch (Exception e) {");
1093      println(" throw e;");
1094      println("} catch (RuntimeException e) {");
1095      println(" throw e;");
1096      println("} catch (Error e) {");
1097      println(" throw e;");
1098      println("} catch (Throwable e) {");
1099      println(" throw new com.caucho.es.ESException(String.valueOf(e));");
1100      println("}");
1101    }
1102    */

1103  }
1104
1105  private boolean hasException(Class JavaDoc []exn, Class JavaDoc cl)
1106  {
1107    for (int i = 0; i < exn.length; i++)
1108      if (exn[i].isAssignableFrom(cl))
1109        return true;
1110
1111    return false;
1112  }
1113
1114  /**
1115   * Starts a method call that overloads a property.
1116   */

1117  private int startProp(ESMethodDescriptor md)
1118    throws IOException JavaDoc
1119  {
1120    Method JavaDoc method = md.getMethod();
1121    
1122    int p = 0;
1123    if (md.isStaticVirtual()) {
1124      print(md.getMethodClassName());
1125      print(".");
1126      print(md.getMethod().getName());
1127      if (isPublic)
1128        print("(_value");
1129      else
1130        print("((" + toJavaClassName(md.getObjectClassName()) + ") value");
1131      p = 1;
1132    } else if (Modifier.isStatic(method.getModifiers())) {
1133      print(md.getMethodClassName());
1134      print(".");
1135      print(md.getMethod().getName());
1136      print("(");
1137    } else {
1138      if (isPublic)
1139        print("_value.");
1140      else
1141        print("((" + toJavaClassName(md.getObjectClassName()) + ") value).");
1142      print(md.getMethod().getName());
1143      print("(");
1144    }
1145
1146    return p;
1147  }
1148
1149  private int startCall(ESMethodDescriptor md)
1150    throws IOException JavaDoc
1151  {
1152    Method JavaDoc method = md.getMethod();
1153
1154    int p = 0;
1155    if (md.isStaticVirtual()) {
1156      print(toJavaClassName(md.getMethodClassName()));
1157      print(".");
1158      print(md.getMethod().getName());
1159      print("((" + md.getObjectClassName() + ") call.getThisWrapper()");
1160      p = 1;
1161    } else if (Modifier.isStatic(method.getModifiers())) {
1162      print(toJavaClassName(md.getMethodClassName()));
1163      print(".");
1164      print(md.getMethod().getName());
1165      print("(");
1166    } else {
1167      print("((" + toJavaClassName(md.getObjectClassName()) + ") call.getThisWrapper()).");
1168      print(md.getMethod().getName());
1169      print("(");
1170    }
1171
1172    return p;
1173  }
1174
1175  private void startJavaToES(Class JavaDoc cl)
1176    throws IOException JavaDoc
1177  {
1178    String JavaDoc name = cl.getName();
1179    
1180    switch (classTypes.get(name)) {
1181    case T_V:
1182      //addJsUndefinedRef();
1183
break;
1184
1185    case T_Z:
1186      print("ESBoolean.create(");
1187      break;
1188
1189    case T_C:
1190      print("ESString.createFromCharCode(");
1191      break;
1192      
1193    case T_B: case T_S: case T_I: case T_L:
1194    case T_F: case T_D:
1195      print("ESNumber.create(");
1196      break;
1197
1198    case T_STRING:
1199      print("ESString.toStr(");
1200      break;
1201
1202    default:
1203      if (esBase.isAssignableFrom(cl))
1204        print("((temp = ");
1205      else
1206        print("Global.wrap(");
1207      break;
1208    }
1209  }
1210  
1211  private void endJavaToES(Class JavaDoc cl)
1212    throws IOException JavaDoc
1213  {
1214    String JavaDoc name = cl.getName();
1215    
1216    switch (classTypes.get(name)) {
1217    case T_V:
1218      //addJsUndefinedRef();
1219
break;
1220
1221    case T_Z:
1222    case T_C:
1223    case T_B: case T_S: case T_I: case T_L:
1224    case T_F: case T_D:
1225    case T_STRING:
1226      print(")");
1227      break;
1228
1229    default:
1230      if (esBase.isAssignableFrom(cl))
1231        print(") == null ? ESBase.esNull : temp)");
1232      else
1233        print(")");
1234      break;
1235    }
1236  }
1237
1238  private void printValueToJava(Class JavaDoc cl, String JavaDoc value)
1239    throws IOException JavaDoc
1240  {
1241    String JavaDoc name = cl.getName();
1242    
1243    switch (classTypes.get(name)) {
1244    case T_V:
1245      throw new RuntimeException JavaDoc();
1246
1247    case T_Z:
1248      print(value + ".toBoolean()");
1249      break;
1250
1251    case T_C:
1252      print("(char) " + value + ".toStr().carefulCharAt(0)");
1253      break;
1254      
1255    case T_B:
1256      print("(byte) " + value + ".toInt32()");
1257      break;
1258      
1259    case T_S:
1260      print("(short) " + value + ".toInt32()");
1261      break;
1262      
1263    case T_I:
1264      print(value + ".toInt32()");
1265      break;
1266      
1267    case T_L:
1268      print("(long)" + value + ".toNum()");
1269      break;
1270      
1271    case T_F:
1272      print("(float)" + value + ".toNum()");
1273      break;
1274      
1275    case T_D:
1276      print(value + ".toNum()");
1277      break;
1278
1279    case T_STRING:
1280      print("(" + value + ").toJavaString()");
1281      break;
1282      
1283    default:
1284      if (cl.isAssignableFrom(esBase))
1285        print(value);
1286      else if (esBase.isAssignableFrom(cl)) {
1287        print("(");
1288        printClassType(cl);
1289        print(") " + value);
1290      }
1291      else {
1292        print("(");
1293        printClassType(cl);
1294        print(") " + value + ".toJavaObject()");
1295      }
1296      break;
1297    }
1298  }
1299
1300  private void printArgToJava(Class JavaDoc cl, int i)
1301    throws IOException JavaDoc
1302  {
1303    String JavaDoc name = cl.getName();
1304    
1305    switch (classTypes.get(name)) {
1306    case T_V:
1307      throw new RuntimeException JavaDoc();
1308
1309    case T_Z:
1310      print("call.getArg(" + i + ", length).toBoolean()");
1311      break;
1312
1313    case T_C:
1314      print("(char) call.getArg(" + i + ", length).toStr().carefulCharAt(0)");
1315      break;
1316      
1317    case T_B:
1318      print("(byte) call.getArgInt32(" + i + ", length)");
1319      break;
1320      
1321    case T_S:
1322      print("(short) call.getArgInt32(" + i + ", length)");
1323      break;
1324      
1325    case T_I:
1326      print("call.getArgInt32(" + i + ", length)");
1327      break;
1328      
1329    case T_L:
1330      print("(long) call.getArgNum(" + i + ", length)");
1331      break;
1332      
1333    case T_F:
1334      print("(float)call.getArgNum(" + i + ", length)");
1335      break;
1336      
1337    case T_D:
1338      print("call.getArgNum(" + i + ", length)");
1339      break;
1340
1341    case T_STRING:
1342      print("call.getArgString(" + i + ", length)");
1343      break;
1344      
1345    default:
1346      if (cl.isAssignableFrom(esBase) &&
1347          ! cl.getName().equals("java.lang.Object"))
1348        print("call.getArg(" + i + ", length)");
1349      else if (esBase.isAssignableFrom(cl)) {
1350        print("(");
1351        printClassType(cl);
1352        print(") ");
1353        print("call.getArg(" + i + ", length)");
1354      }
1355      else {
1356        print("(");
1357        printClassType(cl);
1358        print(") call.getArgObject(" + i + ", length)");
1359      }
1360      break;
1361    }
1362  }
1363
1364  private void printClassType(Class JavaDoc cl)
1365    throws IOException JavaDoc
1366  {
1367    if (cl.isArray()) {
1368      printClassType(cl.getComponentType());
1369      print("[]");
1370    }
1371    else {
1372      print(cl.getName().replace('$', '.'));
1373    }
1374  }
1375
1376  private void printInit() throws IOException JavaDoc
1377  {
1378    println("private int delId = -1;");
1379    println();
1380    println("private static com.caucho.util.IntMap instanceHasDispatch;");
1381    println("private static com.caucho.util.IntMap instanceSetDispatch;");
1382    println("private static com.caucho.util.IntMap instanceMethodDispatch;");
1383    println("private static com.caucho.util.IntMap staticMethodDispatch;");
1384    println("private static com.caucho.util.IntMap staticHasDispatch;");
1385    println("private static com.caucho.util.IntMap staticSetDispatch;");
1386    Iterator JavaDoc iter = namedProperties.values().iterator();
1387    while (iter.hasNext()) {
1388      Named named = (Named) iter.next();
1389      println(name + " name" + named.n + ";");
1390      print("private static ConstIntMap has" + named.n);
1391      println(" = new ConstIntMap(" + named.get + ");");
1392      print("private static ConstIntMap set" + named.n);
1393      println(" = new ConstIntMap(" + named.set + ");");
1394    }
1395    
1396    for (int i = 0; i < overloadDispatch.size(); i++) {
1397      print("private static com.caucho.es.wrapper.MethodDispatcher dispatch" + i);
1398      println(" = new com.caucho.es.wrapper.MethodDispatcher(new Class[][] {");
1399      pushDepth();
1400
1401      ESMethodDescriptor []mds;
1402      mds = (ESMethodDescriptor []) overloadDispatch.get(i);
1403
1404      for (int j = 0; j < mds.length; j++) {
1405        print("new Class[] {");
1406
1407        Class JavaDoc []param = mds[j].getParameterTypes();
1408
1409        for (int k = 0; k < param.length; k++) {
1410          printClass(param[k]);
1411          print(", ");
1412        }
1413        println("},");
1414      }
1415      popDepth();
1416      println("});");
1417    }
1418    
1419    println();
1420    println("static { _init(); }");
1421
1422    println();
1423    println("public boolean isModified()");
1424    println("{");
1425    pushDepth();
1426    com.caucho.make.ClassDependency dep = new com.caucho.make.ClassDependency(cl);
1427    println("try {");
1428    println(" Class cl = Class.forName(\"" + cl.getName() + "\", false, Thread.currentThread().getContextClassLoader());");
1429    println(" return new com.caucho.make.ClassDependency(cl, " + dep.getDigest() + "L).isModified();");
1430    println("} catch (Throwable e) {");
1431    println(" return true;");
1432    println("}");
1433    popDepth();
1434    println("}");
1435    
1436    println();
1437    println("private static void _init()");
1438    println("{");
1439    
1440    pushDepth();
1441    println("instanceHasDispatch = new com.caucho.util.IntMap();");
1442    iter = hasDispatch.iterator();
1443    while (iter.hasNext()) {
1444      String JavaDoc key = (String JavaDoc) iter.next();
1445      
1446      println("instanceHasDispatch.put(ESId.intern(\"" + key + "\"), " +
1447              hasDispatch.get(key) + ");");
1448    }
1449
1450    println();
1451    println("staticHasDispatch = new com.caucho.util.IntMap();");
1452    iter = staticHasDispatch.iterator();
1453    while (iter.hasNext()) {
1454      String JavaDoc key = (String JavaDoc) iter.next();
1455      
1456      println("staticHasDispatch.put(ESId.intern(\"" + key + "\"), " +
1457              staticHasDispatch.get(key) + ");");
1458    }
1459    
1460    println();
1461    println("instanceSetDispatch = new com.caucho.util.IntMap();");
1462    iter = setDispatch.iterator();
1463    while (iter.hasNext()) {
1464      String JavaDoc key = (String JavaDoc) iter.next();
1465      
1466      println("instanceSetDispatch.put(ESId.intern(\"" + key + "\"), " +
1467              setDispatch.get(key) + ");");
1468    }
1469    
1470    println();
1471    println("staticSetDispatch = new com.caucho.util.IntMap();");
1472    iter = staticSetDispatch.iterator();
1473    while (iter.hasNext()) {
1474      String JavaDoc key = (String JavaDoc) iter.next();
1475      
1476      println("staticSetDispatch.put(ESId.intern(\"" + key + "\"), " +
1477              staticSetDispatch.get(key) + ");");
1478    }
1479    
1480    println();
1481    println("instanceMethodDispatch = new com.caucho.util.IntMap();");
1482    iter = methodDispatch.iterator();
1483    while (iter.hasNext()) {
1484      String JavaDoc key = (String JavaDoc) iter.next();
1485      
1486      println("instanceMethodDispatch.put(ESId.intern(\"" + key + "\"), " +
1487              methodDispatch.get(key) + ");");
1488    }
1489    
1490    println();
1491    println("staticMethodDispatch = new com.caucho.util.IntMap();");
1492    iter = staticMethodDispatch.iterator();
1493    while (iter.hasNext()) {
1494      String JavaDoc key = (String JavaDoc) iter.next();
1495      
1496      println("staticMethodDispatch.put(ESId.intern(\"" + key + "\"), " +
1497              staticMethodDispatch.get(key) + ");");
1498    }
1499    
1500    popDepth();
1501    println("}");
1502  }
1503
1504  private void printClass(Class JavaDoc cl)
1505    throws IOException JavaDoc
1506  {
1507    if (! cl.isArray()) {
1508      print(cl.getName() + ".class");
1509      return;
1510    }
1511
1512    print("(new ");
1513    printArrayClass(cl.getComponentType());
1514    print("[0]).getClass()");
1515  }
1516
1517  private void printArrayClass(Class JavaDoc cl)
1518    throws IOException JavaDoc
1519  {
1520    if (cl.isArray()) {
1521      printArrayClass(cl.getComponentType());
1522      print("[]");
1523    }
1524    else
1525      print(cl.getName());
1526  }
1527  
1528  private void printFooter() throws IOException JavaDoc
1529  {
1530    popDepth();
1531    println("}");
1532  }
1533
1534  private void pushDepth()
1535  {
1536    depth += 2;
1537  }
1538
1539  private void popDepth()
1540  {
1541    depth -= 2;
1542  }
1543    
1544  private void print(String JavaDoc s) throws IOException JavaDoc
1545  {
1546    if (isNewline)
1547      printDepth();
1548    os.print(s);
1549  }
1550
1551  private void println(String JavaDoc s) throws IOException JavaDoc
1552  {
1553    if (isNewline)
1554      printDepth();
1555    os.println(s);
1556    isNewline = true;
1557  }
1558
1559  private void println() throws IOException JavaDoc
1560  {
1561    if (isNewline)
1562      printDepth();
1563    os.println();
1564    isNewline = true;
1565  }
1566
1567  private void printDepth() throws IOException JavaDoc
1568  {
1569    for (int i = 0; i < depth; i++)
1570      os.print(' ');
1571    isNewline = false;
1572  }
1573
1574  private String JavaDoc toJavaClassName(String JavaDoc name)
1575  {
1576    CharBuffer cb = CharBuffer.allocate();
1577    for (int i = 0; i < name.length(); i++) {
1578      char ch = name.charAt(i);
1579
1580      if (ch == '$' && i > 0 && name.charAt(i - 1) != '.')
1581        cb.append(".");
1582      else
1583        cb.append(ch);
1584    }
1585    return cb.close();
1586  }
1587
1588  static HashMap JavaDoc<String JavaDoc,String JavaDoc> classNames;
1589  static {
1590    classNames = new HashMap JavaDoc<String JavaDoc,String JavaDoc>();
1591    classNames.put("void", "V");
1592    classNames.put("boolean", "Z");
1593    classNames.put("byte", "B");
1594    classNames.put("short", "S");
1595    classNames.put("char", "C");
1596    classNames.put("int", "I");
1597    classNames.put("long", "J");
1598    classNames.put("float", "F");
1599    classNames.put("double", "D");
1600  }
1601
1602  static IntMap classTypes;
1603  static final int T_V = 0;
1604  static final int T_Z = T_V + 1;
1605  static final int T_B = T_Z + 1;
1606  static final int T_S = T_B + 1;
1607  static final int T_C = T_S + 1;
1608  static final int T_I = T_C + 1;
1609  static final int T_L = T_I + 1;
1610  static final int T_F = T_L + 1;
1611  static final int T_D = T_F + 1;
1612  static final int T_STRING = T_D + 1;
1613  static {
1614    classTypes = new IntMap();
1615    classTypes.put("void", T_V);
1616    classTypes.put("boolean", T_Z);
1617    classTypes.put("byte", T_B);
1618    classTypes.put("short", T_S);
1619    classTypes.put("char", T_C);
1620    classTypes.put("int", T_I);
1621    classTypes.put("long", T_L);
1622    classTypes.put("float", T_F);
1623    classTypes.put("double", T_D);
1624    classTypes.put("java.lang.String", T_STRING);
1625  }
1626
1627  static class Named {
1628    String JavaDoc name;
1629    int n;
1630    int get = -1;
1631    int set = -1;
1632    int keys = -1;
1633    int remove = -1;
1634    
1635    Named(String JavaDoc name, int n)
1636    {
1637      this.name = name;
1638      this.n = n;
1639    }
1640  }
1641}
1642
1643
Popular Tags