1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2013 Eric Lafortune (eric@graphics.cornell.edu)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard;
import proguard.io.*;
import proguard.util.*;
import java.util.List;
/**
* This class can create DataEntryWriter instances based on class paths. The
* writers will wrap the output in the proper jars, wars, ears, and zips.
*
* @author Eric Lafortune
*/
public class DataEntryWriterFactory
{
/**
* Creates a DataEntryWriter that can write to the given class path entries.
*
* @param classPath the output class path.
* @param fromIndex the start index in the class path.
* @param toIndex the end index in the class path.
* @return a DataEntryWriter for writing to the given class path entries.
*/
public static DataEntryWriter createDataEntryWriter(ClassPath classPath,
int fromIndex,
int toIndex)
{
DataEntryWriter writer = null;
// Create a chain of writers, one for each class path entry.
for (int index = toIndex - 1; index >= fromIndex; index--)
{
ClassPathEntry entry = classPath.get(index);
writer = createClassPathEntryWriter(entry, writer);
}
return writer;
}
/**
* Creates a DataEntryWriter that can write to the given class path entry,
* or delegate to another DataEntryWriter if its filters don't match.
*/
private static DataEntryWriter createClassPathEntryWriter(ClassPathEntry classPathEntry,
DataEntryWriter alternativeWriter)
{
boolean isJar = classPathEntry.isJar();
boolean isWar = classPathEntry.isWar();
boolean isEar = classPathEntry.isEar();
boolean isZip = classPathEntry.isZip();
List filter = classPathEntry.getFilter();
List jarFilter = classPathEntry.getJarFilter();
List warFilter = classPathEntry.getWarFilter();
List earFilter = classPathEntry.getEarFilter();
List zipFilter = classPathEntry.getZipFilter();
System.out.println("Preparing output " +
(isJar ? "jar" :
isWar ? "war" :
isEar ? "ear" :
isZip ? "zip" :
"directory") +
" [" + classPathEntry.getName() + "]" +
(filter != null ||
jarFilter != null ||
warFilter != null ||
earFilter != null ||
zipFilter != null ? " (filtered)" : ""));
DataEntryWriter writer = new DirectoryWriter(classPathEntry.getFile(),
isJar ||
isWar ||
isEar ||
isZip);
// Set up the filtered jar writers.
writer = wrapInJarWriter(writer, isZip, zipFilter, ".zip", isJar || isWar || isEar);
writer = wrapInJarWriter(writer, isEar, earFilter, ".ear", isJar || isWar);
writer = wrapInJarWriter(writer, isWar, warFilter, ".war", isJar);
writer = wrapInJarWriter(writer, isJar, jarFilter, ".jar", false);
// Add a filter, if specified.
writer = filter != null?
new FilteredDataEntryWriter(
new DataEntryNameFilter(
new ListParser(new FileNameParser()).parse(filter)),
writer) :
writer;
// Let the writer cascade, if specified.
return alternativeWriter != null ?
new CascadingDataEntryWriter(writer, alternativeWriter) :
writer;
}
/**
* Wraps the given DataEntryWriter in a JarWriter, filtering if necessary.
*/
private static DataEntryWriter wrapInJarWriter(DataEntryWriter writer,
boolean isJar,
List jarFilter,
String jarExtension,
boolean dontWrap)
{
// Zip up jars, if necessary.
DataEntryWriter jarWriter = dontWrap ?
(DataEntryWriter)new ParentDataEntryWriter(writer) :
(DataEntryWriter)new JarWriter(writer);
// Add a filter, if specified.
DataEntryWriter filteredJarWriter = jarFilter != null?
new FilteredDataEntryWriter(
new DataEntryParentFilter(
new DataEntryNameFilter(
new ListParser(new FileNameParser()).parse(jarFilter))),
jarWriter) :
jarWriter;
// Only zip up jars, unless the output is a jar file itself.
return new FilteredDataEntryWriter(
new DataEntryParentFilter(
new DataEntryNameFilter(
new ExtensionMatcher(jarExtension))),
filteredJarWriter,
isJar ? jarWriter : writer);
}
}
|
