KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javassist > reflect > Compiler


1 /*
2  * Javassist, a Java-bytecode translator toolkit.
3  * Copyright (C) 1999-2005 Shigeru Chiba. All Rights Reserved.
4  *
5  * The contents of this file are subject to the Mozilla Public License Version
6  * 1.1 (the "License"); you may not use this file except in compliance with
7  * the License. Alternatively, the contents of this file may be used under
8  * the terms of the GNU Lesser General Public License Version 2.1 or later.
9  *
10  * Software distributed under the License is distributed on an "AS IS" basis,
11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12  * for the specific language governing rights and limitations under the
13  * License.
14  */
15
16 package javassist.reflect;
17
18 import javassist.CtClass;
19 import javassist.ClassPool;
20 import java.io.PrintStream JavaDoc;
21
22 class CompiledClass {
23     public String JavaDoc classname;
24     public String JavaDoc metaobject;
25     public String JavaDoc classobject;
26 }
27
28 /**
29  * A bytecode translator for reflection.
30  *
31  * <p>This translator directly modifies class files on a local disk so that
32  * the classes represented by those class files are reflective.
33  * After the modification, the class files can be run with the standard JVM
34  * without <code>javassist.reflect.Loader</code>
35  * or any other user-defined class loader.
36  *
37  * <p>The modified class files are given as the command-line parameters,
38  * which are a sequence of fully-qualified class names followed by options:
39  *
40  * <p><code>-m <i>classname</i></code> : specifies the class of the
41  * metaobjects associated with instances of the class followed by
42  * this option. The default is <code>javassit.reflect.Metaobject</code>.
43  *
44  * <p><code>-c <i>classname</i></code> : specifies the class of the
45  * class metaobjects associated with instances of the class followed by
46  * this option. The default is <code>javassit.reflect.ClassMetaobject</code>.
47  *
48  * <p>If a class name is not followed by any options, the class indicated
49  * by that class name is not reflective.
50  *
51  * <p>For example,
52  * <ul><pre>% java Compiler Dog -m MetaDog -c CMetaDog Cat -m MetaCat Cow
53  * </pre></ul>
54  *
55  * <p>modifies class files <code>Dog.class</code>, <code>Cat.class</code>,
56  * and <code>Cow.class</code>.
57  * The metaobject of a Dog object is a MetaDog object and the class
58  * metaobject is a CMetaDog object.
59  * The metaobject of a Cat object is a MetaCat object but
60  * the class metaobject is a default one.
61  * Cow objects are not reflective.
62  *
63  * <p>Note that if the super class is also made reflective, it must be done
64  * before the sub class.
65  *
66  * @see javassist.reflect.Metaobject
67  * @see javassist.reflect.ClassMetaobject
68  * @see javassist.reflect.Reflection
69  */
70 public class Compiler {
71
72     public static void main(String JavaDoc[] args) throws Exception JavaDoc {
73         if (args.length == 0) {
74             help(System.err);
75             return;
76         }
77
78         CompiledClass[] entries = new CompiledClass[args.length];
79         int n = parse(args, entries);
80
81         if (n < 1) {
82             System.err.println("bad parameter.");
83             return;
84         }
85
86         processClasses(entries, n);
87     }
88
89     private static void processClasses(CompiledClass[] entries, int n)
90         throws Exception JavaDoc
91     {
92         Reflection implementor = new Reflection();
93         ClassPool pool = ClassPool.getDefault();
94         implementor.start(pool);
95
96         for (int i = 0; i < n; ++i) {
97             CtClass c = pool.get(entries[i].classname);
98             if (entries[i].metaobject != null
99                                         || entries[i].classobject != null) {
100                 String JavaDoc metaobj, classobj;
101
102                 if (entries[i].metaobject == null)
103                     metaobj = "javassist.reflect.Metaobject";
104                 else
105                     metaobj = entries[i].metaobject;
106
107                 if (entries[i].classobject == null)
108                     classobj = "javassist.reflect.ClassMetaobject";
109                 else
110                     classobj = entries[i].classobject;
111
112                 if (!implementor.makeReflective(c, pool.get(metaobj),
113                                               pool.get(classobj)))
114                     System.err.println("Warning: " + c.getName()
115                                 + " is reflective. It was not changed.");
116
117                 System.err.println(c.getName() + ": " + metaobj + ", "
118                                    + classobj);
119             }
120             else
121                 System.err.println(c.getName() + ": not reflective");
122         }
123
124         for (int i = 0; i < n; ++i) {
125             implementor.onLoad(pool, entries[i].classname);
126             pool.get(entries[i].classname).writeFile();
127         }
128     }
129
130     private static int parse(String JavaDoc[] args, CompiledClass[] result) {
131         int n = -1;
132         for (int i = 0; i < args.length; ++i) {
133             String JavaDoc a = args[i];
134             if (a.equals("-m"))
135                 if (n < 0 || i + 1 > args.length)
136                     return -1;
137                 else
138                     result[n].metaobject = args[++i];
139             else if (a.equals("-c"))
140                 if (n < 0 || i + 1 > args.length)
141                     return -1;
142                 else
143                     result[n].classobject = args[++i];
144             else if (a.charAt(0) == '-')
145                 return -1;
146             else {
147                 CompiledClass cc = new CompiledClass();
148                 cc.classname = a;
149                 cc.metaobject = null;
150                 cc.classobject = null;
151                 result[++n] = cc;
152             }
153         }
154
155         return n + 1;
156     }
157
158     private static void help(PrintStream JavaDoc out) {
159         out.println("Usage: java javassist.reflect.Compiler");
160         out.println(" (<class> [-m <metaobject>] [-c <class metaobject>])+");
161     }
162 }
163
Popular Tags