KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > proguard > ant > ProGuardTask


1 /*
2  * ProGuard -- shrinking, optimization, obfuscation, and preverification
3  * of Java bytecode.
4  *
5  * Copyright (c) 2002-2007 Eric Lafortune (eric@graphics.cornell.edu)
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by the Free
9  * Software Foundation; either version 2 of the License, or (at your option)
10  * any later version.
11  *
12  * This program is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with this program; if not, write to the Free Software Foundation, Inc.,
19  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */

21 package proguard.ant;
22
23 import org.apache.tools.ant.*;
24 import proguard.*;
25 import proguard.classfile.util.*;
26
27 import java.io.*;
28
29 /**
30  * This Task allows to configure and run ProGuard from Ant.
31  *
32  * @author Eric Lafortune
33  */

34 public class ProGuardTask extends ConfigurationTask
35 {
36     // Ant task attributes.
37

38     public void setConfiguration(File configurationFile) throws BuildException
39     {
40         try
41         {
42             ConfigurationParser parser = new ConfigurationParser(configurationFile);
43
44             try
45             {
46                 parser.parse(configuration);
47             }
48             catch (ParseException ex)
49             {
50                 throw new BuildException(ex.getMessage());
51             }
52             finally
53             {
54                 parser.close();
55             }
56         }
57         catch (IOException ex)
58         {
59             throw new BuildException(ex.getMessage());
60         }
61     }
62
63
64     /**
65      * @deprecated Use the nested outjar element instead.
66      */

67     public void setOutjar(String JavaDoc parameters)
68     {
69         throw new BuildException("Use the <outjar> nested element instead of the 'outjar' attribute");
70     }
71
72
73     public void setSkipnonpubliclibraryclasses(boolean skipNonPublicLibraryClasses)
74     {
75         configuration.skipNonPublicLibraryClasses = skipNonPublicLibraryClasses;
76     }
77
78
79     public void setSkipnonpubliclibraryclassmembers(boolean skipNonPublicLibraryClassMembers)
80     {
81         configuration.skipNonPublicLibraryClassMembers = skipNonPublicLibraryClassMembers;
82     }
83
84
85     public void setTarget(String JavaDoc target)
86     {
87         configuration.targetClassVersion = ClassUtil.internalClassVersion(target);
88         if (configuration.targetClassVersion == 0)
89         {
90             throw new BuildException("Unsupported target '"+target+"'");
91         }
92     }
93
94
95     public void setForceprocessing(boolean forceProcessing)
96     {
97         configuration.lastModified = forceProcessing ? Long.MAX_VALUE : 0;
98     }
99
100
101     public void setPrintseeds(File printSeeds)
102     {
103         configuration.printSeeds = optionalFile(printSeeds);
104     }
105
106
107     public void setShrink(boolean shrink)
108     {
109         configuration.shrink = shrink;
110     }
111
112
113     public void setPrintusage(File printUsage)
114     {
115         configuration.printUsage = optionalFile(printUsage);
116     }
117
118
119     public void setOptimize(boolean optimize)
120     {
121         configuration.optimize = optimize;
122     }
123
124
125     public void setOptimizationpasses(int optimizationPasses)
126     {
127         configuration.optimizationPasses = optimizationPasses;
128     }
129
130
131     public void setAllowaccessmodification(boolean allowAccessModification)
132     {
133         configuration.allowAccessModification = allowAccessModification;
134     }
135
136
137     public void setObfuscate(boolean obfuscate)
138     {
139         configuration.obfuscate = obfuscate;
140     }
141
142
143     public void setPrintmapping(File printMapping)
144     {
145         configuration.printMapping = optionalFile(printMapping);
146     }
147
148
149     public void setApplymapping(File applyMapping)
150     {
151         configuration.applyMapping = resolvedFile(applyMapping);
152     }
153
154
155     public void setObfuscationdictionary(File obfuscationDictionary)
156     {
157         configuration.obfuscationDictionary = resolvedFile(obfuscationDictionary);
158     }
159
160
161     public void setOverloadaggressively(boolean overloadAggressively)
162     {
163         configuration.overloadAggressively = overloadAggressively;
164     }
165
166
167     public void setUseuniqueclassmembernames(boolean useUniqueClassMemberNames)
168     {
169         configuration.useUniqueClassMemberNames = useUniqueClassMemberNames;
170     }
171
172
173     public void setUsemixedcaseclassnames(boolean useMixedCaseClassNames)
174     {
175         configuration.useMixedCaseClassNames = useMixedCaseClassNames;
176     }
177
178
179     public void setFlattenpackagehierarchy(String JavaDoc flattenPackageHierarchy)
180     {
181         configuration.flattenPackageHierarchy = ClassUtil.internalClassName(flattenPackageHierarchy);
182     }
183
184
185     public void setRepackageclasses(String JavaDoc repackageClasses)
186     {
187         configuration.repackageClasses = ClassUtil.internalClassName(repackageClasses);
188     }
189
190     /**
191      * @deprecated Use the repackageclasses attribute instead.
192      */

193     public void setDefaultpackage(String JavaDoc defaultPackage)
194     {
195         configuration.repackageClasses = ClassUtil.internalClassName(defaultPackage);
196     }
197
198
199     public void setRenamesourcefileattribute(String JavaDoc newSourceFileAttribute)
200     {
201         configuration.newSourceFileAttribute = newSourceFileAttribute;
202     }
203
204
205     public void setPreverify(boolean preverify)
206     {
207         configuration.preverify = preverify;
208     }
209
210
211     public void setMicroedition(boolean microEdition)
212     {
213         configuration.microEdition = microEdition;
214     }
215
216
217     public void setVerbose(boolean verbose)
218     {
219         configuration.verbose = verbose;
220     }
221
222
223     public void setNote(boolean note)
224     {
225         configuration.note = note;
226     }
227
228
229     public void setWarn(boolean warn)
230     {
231         configuration.warn = warn;
232     }
233
234
235     public void setIgnorewarnings(boolean ignoreWarnings)
236     {
237         configuration.ignoreWarnings = ignoreWarnings;
238     }
239
240
241     public void setPrintconfiguration(File printConfiguration)
242     {
243         configuration.printConfiguration = optionalFile(printConfiguration);
244     }
245
246
247     public void setDump(File dump)
248     {
249         configuration.dump = optionalFile(dump);
250     }
251
252
253     // Implementations for Task.
254

255     public void execute() throws BuildException
256     {
257         try
258         {
259             ProGuard proGuard = new ProGuard(configuration);
260             proGuard.execute();
261         }
262         catch (IOException ex)
263         {
264             throw new BuildException(ex.getMessage());
265         }
266     }
267
268
269     // Small utility methods.
270

271     /**
272      * Returns a file that is properly resolved with respect to the project
273      * directory, or <code>null</code> or empty if its name is actually a
274      * boolean flag.
275      */

276     private File optionalFile(File file)
277     {
278         String JavaDoc fileName = file.getName();
279
280         return
281             fileName.equalsIgnoreCase("false") ||
282             fileName.equalsIgnoreCase("no") ||
283             fileName.equalsIgnoreCase("off") ? null :
284             fileName.equalsIgnoreCase("true") ||
285             fileName.equalsIgnoreCase("yes") ||
286             fileName.equalsIgnoreCase("on") ? new File("") :
287                                                   resolvedFile(file);
288     }
289
290
291     /**
292      * Returns a file that is properly resolved with respect to the project
293      * directory.
294      */

295     private File resolvedFile(File file)
296     {
297         return file.isAbsolute() ? file :
298                                    new File(getProject().getBaseDir(),
299                                             file.getName());
300     }
301 }
302
Popular Tags