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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*
*
* Copyright 2002-2004 The Ant-Contrib project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sf.antcontrib.cpptasks.compiler;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Vector;
import net.sf.antcontrib.cpptasks.CCTask;
import net.sf.antcontrib.cpptasks.CUtil;
import net.sf.antcontrib.cpptasks.CompilerDef;
import net.sf.antcontrib.cpptasks.DependencyInfo;
import net.sf.antcontrib.cpptasks.ProcessorDef;
import net.sf.antcontrib.cpptasks.parser.Parser;
import net.sf.antcontrib.cpptasks.TargetDef;
import net.sf.antcontrib.cpptasks.VersionInfo;
/**
* An abstract compiler implementation.
*
* @author Adam Murdoch
* @author Curt Arnold
*/
public abstract class AbstractCompiler extends AbstractProcessor
implements
Compiler {
private static final String[] emptyIncludeArray = new String[0];
private String outputSuffix;
protected AbstractCompiler(String[] sourceExtensions,
String[] headerExtensions, String outputSuffix) {
super(sourceExtensions, headerExtensions);
this.outputSuffix = outputSuffix;
}
/**
* Checks file name to see if parse should be attempted
*
* Default implementation returns false for files with extensions '.dll',
* 'tlb', '.res'
*
*/
protected boolean canParse(File sourceFile) {
String sourceName = sourceFile.toString();
int lastPeriod = sourceName.lastIndexOf('.');
if (lastPeriod >= 0 && lastPeriod == sourceName.length() - 4) {
String ext = sourceName.substring(lastPeriod).toUpperCase();
if (ext.equals(".DLL") || ext.equals(".TLB") || ext.equals(".RES")) {
return false;
}
}
return true;
}
abstract protected CompilerConfiguration createConfiguration(CCTask task,
LinkType linkType, ProcessorDef[] baseConfigs,
CompilerDef specificConfig, TargetDef targetPlatform,
VersionInfo versionInfo);
public ProcessorConfiguration createConfiguration(CCTask task,
LinkType linkType, ProcessorDef[] baseConfigs,
ProcessorDef specificConfig, TargetDef targetPlatform,
VersionInfo versionInfo) {
if (specificConfig == null) {
throw new NullPointerException("specificConfig");
}
return createConfiguration(task, linkType, baseConfigs,
(CompilerDef) specificConfig, targetPlatform, versionInfo);
}
abstract protected Parser createParser(File sourceFile);
protected String getBaseOutputName(String inputFile) {
int lastSlash = inputFile.lastIndexOf('/');
int lastReverse = inputFile.lastIndexOf('\\');
int lastSep = inputFile.lastIndexOf(File.separatorChar);
if (lastReverse > lastSlash) {
lastSlash = lastReverse;
}
if (lastSep > lastSlash) {
lastSlash = lastSep;
}
int lastPeriod = inputFile.lastIndexOf('.');
if (lastPeriod < 0) {
lastPeriod = inputFile.length();
}
return inputFile.substring(lastSlash + 1, lastPeriod);
}
public String[] getOutputFileNames(String inputFile, VersionInfo versionInfo) {
//
// if a recognized input file
//
if (bid(inputFile) > 1) {
String baseName = getBaseOutputName(inputFile);
return new String[] { baseName + outputSuffix };
}
return new String[0];
}
/**
* Returns dependency info for the specified source file
*
* @param task
* task for any diagnostic output
* @param source
* file to be parsed
* @param includePath
* include path to be used to resolve included files
*
* @param sysIncludePath
* sysinclude path from build file, files resolved using
* sysInclude path will not participate in dependency analysis
*
* @param envIncludePath
* include path from environment variable, files resolved with
* envIncludePath will not participate in dependency analysis
*
* @param baseDir
* used to produce relative paths in DependencyInfo
* @param includePathIdentifier
* used to distinguish DependencyInfo's from different include
* path settings
*
* @author Curt Arnold
*/
public final DependencyInfo parseIncludes(CCTask task, File source,
File[] includePath, File[] sysIncludePath, File[] envIncludePath,
File baseDir, String includePathIdentifier) {
//
// if any of the include files can not be identified
// change the sourceLastModified to Long.MAX_VALUE to
// force recompilation of anything that depends on it
long sourceLastModified = source.lastModified();
File[] sourcePath = new File[1];
sourcePath[0] = new File(source.getParent());
Vector onIncludePath = new Vector();
Vector onSysIncludePath = new Vector();
String baseDirPath;
try {
baseDirPath = baseDir.getCanonicalPath();
} catch (IOException ex) {
baseDirPath = baseDir.toString();
}
String relativeSource = CUtil.getRelativePath(baseDirPath, source);
String[] includes = emptyIncludeArray;
if (canParse(source)) {
Parser parser = createParser(source);
try {
Reader reader = new BufferedReader(new FileReader(source));
parser.parse(reader);
includes = parser.getIncludes();
} catch (IOException ex) {
task.log("Error parsing " + source.toString() + ":"
+ ex.toString());
includes = new String[0];
}
}
for (int i = 0; i < includes.length; i++) {
String includeName = includes[i];
if (!resolveInclude(includeName, sourcePath, onIncludePath)) {
if (!resolveInclude(includeName, includePath, onIncludePath)) {
if (!resolveInclude(includeName, sysIncludePath,
onSysIncludePath)) {
if (!resolveInclude(includeName, envIncludePath,
onSysIncludePath)) {
//
// this should be enough to require us to reparse
// the file with the missing include for dependency
// information without forcing a rebuild
sourceLastModified += 2 * CUtil.FILETIME_EPSILON;
}
}
}
}
}
for (int i = 0; i < onIncludePath.size(); i++) {
String relativeInclude = CUtil.getRelativePath(baseDirPath,
(File) onIncludePath.elementAt(i));
onIncludePath.setElementAt(relativeInclude, i);
}
for (int i = 0; i < onSysIncludePath.size(); i++) {
String relativeInclude = CUtil.getRelativePath(baseDirPath,
(File) onSysIncludePath.elementAt(i));
onSysIncludePath.setElementAt(relativeInclude, i);
}
return new DependencyInfo(includePathIdentifier, relativeSource,
sourceLastModified, onIncludePath, onSysIncludePath);
}
protected boolean resolveInclude(String includeName, File[] includePath,
Vector onThisPath) {
for (int i = 0; i < includePath.length; i++) {
File includeFile = new File(includePath[i], includeName);
if (includeFile.exists()) {
onThisPath.addElement(includeFile);
return true;
}
}
return false;
}
}
|
