Python code coverage for Lib/packaging/compiler/bcppcompiler.py

#	count	content
1	n/a	"""CCompiler implementation for the Borland C++ compiler."""
2	n/a
3	n/a	# This implementation by Lyle Johnson, based on the original msvccompiler.py
4	n/a	# module and using the directions originally published by Gordon Williams.
5	n/a
6	n/a	# XXX looks like there's a LOT of overlap between these two classes:
7	n/a	# someone should sit down and factor out the common code as
8	n/a	# WindowsCCompiler! --GPW
9	n/a
10	n/a	import os
11	n/a
12	n/a	from packaging.errors import (PackagingExecError, CompileError, LibError,
13	n/a	LinkError, UnknownFileError)
14	n/a	from packaging.compiler.ccompiler import CCompiler
15	n/a	from packaging.compiler import gen_preprocess_options
16	n/a	from packaging.file_util import write_file
17	n/a	from packaging.dep_util import newer
18	n/a	from packaging import logger
19	n/a
20	n/a
21	n/a	class BCPPCompiler(CCompiler) :
22	n/a	"""Concrete class that implements an interface to the Borland C/C++
23	n/a	compiler, as defined by the CCompiler abstract class.
24	n/a	"""
25	n/a
26	n/a	name = 'bcpp'
27	n/a	description = 'Borland C++ Compiler'
28	n/a
29	n/a	# Just set this so CCompiler's constructor doesn't barf. We currently
30	n/a	# don't use the 'set_executables()' bureaucracy provided by CCompiler,
31	n/a	# as it really isn't necessary for this sort of single-compiler class.
32	n/a	# Would be nice to have a consistent interface with UnixCCompiler,
33	n/a	# though, so it's worth thinking about.
34	n/a	executables = {}
35	n/a
36	n/a	# Private class data (need to distinguish C from C++ source for compiler)
37	n/a	_c_extensions = ['.c']
38	n/a	_cpp_extensions = ['.cc', '.cpp', '.cxx']
39	n/a
40	n/a	# Needed for the filename generation methods provided by the
41	n/a	# base class, CCompiler.
42	n/a	src_extensions = _c_extensions + _cpp_extensions
43	n/a	obj_extension = '.obj'
44	n/a	static_lib_extension = '.lib'
45	n/a	shared_lib_extension = '.dll'
46	n/a	static_lib_format = shared_lib_format = '%s%s'
47	n/a	exe_extension = '.exe'
48	n/a
49	n/a
50	n/a	def __init__(self, dry_run=False, force=False):
51	n/a	super(BCPPCompiler, self).__init__(dry_run, force)
52	n/a
53	n/a	# These executables are assumed to all be in the path.
54	n/a	# Borland doesn't seem to use any special registry settings to
55	n/a	# indicate their installation locations.
56	n/a
57	n/a	self.cc = "bcc32.exe"
58	n/a	self.linker = "ilink32.exe"
59	n/a	self.lib = "tlib.exe"
60	n/a
61	n/a	self.preprocess_options = None
62	n/a	self.compile_options = ['/tWM', '/O2', '/q', '/g0']
63	n/a	self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']
64	n/a
65	n/a	self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
66	n/a	self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
67	n/a	self.ldflags_static = []
68	n/a	self.ldflags_exe = ['/Gn', '/q', '/x']
69	n/a	self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']
70	n/a
71	n/a
72	n/a	# -- Worker methods ------------------------------------------------
73	n/a
74	n/a	def compile(self, sources,
75	n/a	output_dir=None, macros=None, include_dirs=None, debug=False,
76	n/a	extra_preargs=None, extra_postargs=None, depends=None):
77	n/a
78	n/a	macros, objects, extra_postargs, pp_opts, build = \
79	n/a	self._setup_compile(output_dir, macros, include_dirs, sources,
80	n/a	depends, extra_postargs)
81	n/a	compile_opts = extra_preargs or []
82	n/a	compile_opts.append('-c')
83	n/a	if debug:
84	n/a	compile_opts.extend(self.compile_options_debug)
85	n/a	else:
86	n/a	compile_opts.extend(self.compile_options)
87	n/a
88	n/a	for obj in objects:
89	n/a	try:
90	n/a	src, ext = build[obj]
91	n/a	except KeyError:
92	n/a	continue
93	n/a	# XXX why do the normpath here?
94	n/a	src = os.path.normpath(src)
95	n/a	obj = os.path.normpath(obj)
96	n/a	# XXX _setup_compile() did a mkpath() too but before the normpath.
97	n/a	# Is it possible to skip the normpath?
98	n/a	self.mkpath(os.path.dirname(obj))
99	n/a
100	n/a	if ext == '.res':
101	n/a	# This is already a binary file -- skip it.
102	n/a	continue # the 'for' loop
103	n/a	if ext == '.rc':
104	n/a	# This needs to be compiled to a .res file -- do it now.
105	n/a	try:
106	n/a	self.spawn(["brcc32", "-fo", obj, src])
107	n/a	except PackagingExecError as msg:
108	n/a	raise CompileError(msg)
109	n/a	continue # the 'for' loop
110	n/a
111	n/a	# The next two are both for the real compiler.
112	n/a	if ext in self._c_extensions:
113	n/a	input_opt = ""
114	n/a	elif ext in self._cpp_extensions:
115	n/a	input_opt = "-P"
116	n/a	else:
117	n/a	# Unknown file type -- no extra options. The compiler
118	n/a	# will probably fail, but let it just in case this is a
119	n/a	# file the compiler recognizes even if we don't.
120	n/a	input_opt = ""
121	n/a
122	n/a	output_opt = "-o" + obj
123	n/a
124	n/a	# Compiler command line syntax is: "bcc32 [options] file(s)".
125	n/a	# Note that the source file names must appear at the end of
126	n/a	# the command line.
127	n/a	try:
128	n/a	self.spawn([self.cc] + compile_opts + pp_opts +
129	n/a	[input_opt, output_opt] +
130	n/a	extra_postargs + [src])
131	n/a	except PackagingExecError as msg:
132	n/a	raise CompileError(msg)
133	n/a
134	n/a	return objects
135	n/a
136	n/a
137	n/a	def create_static_lib(self, objects, output_libname, output_dir=None,
138	n/a	debug=False, target_lang=None):
139	n/a	objects, output_dir = self._fix_object_args(objects, output_dir)
140	n/a	output_filename = \
141	n/a	self.library_filename(output_libname, output_dir=output_dir)
142	n/a
143	n/a	if self._need_link(objects, output_filename):
144	n/a	lib_args = [output_filename, '/u'] + objects
145	n/a	if debug:
146	n/a	pass # XXX what goes here?
147	n/a	try:
148	n/a	self.spawn([self.lib] + lib_args)
149	n/a	except PackagingExecError as msg:
150	n/a	raise LibError(msg)
151	n/a	else:
152	n/a	logger.debug("skipping %s (up-to-date)", output_filename)
153	n/a
154	n/a
155	n/a	def link(self, target_desc, objects, output_filename, output_dir=None,
156	n/a	libraries=None, library_dirs=None, runtime_library_dirs=None,
157	n/a	export_symbols=None, debug=False, extra_preargs=None,
158	n/a	extra_postargs=None, build_temp=None, target_lang=None):
159	n/a
160	n/a	# XXX this ignores 'build_temp'! should follow the lead of
161	n/a	# msvccompiler.py
162	n/a
163	n/a	objects, output_dir = self._fix_object_args(objects, output_dir)
164	n/a	libraries, library_dirs, runtime_library_dirs = \
165	n/a	self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
166	n/a
167	n/a	if runtime_library_dirs:
168	n/a	logger.warning("don't know what to do with "
169	n/a	"'runtime_library_dirs': %r", runtime_library_dirs)
170	n/a
171	n/a	if output_dir is not None:
172	n/a	output_filename = os.path.join(output_dir, output_filename)
173	n/a
174	n/a	if self._need_link(objects, output_filename):
175	n/a
176	n/a	# Figure out linker args based on type of target.
177	n/a	if target_desc == CCompiler.EXECUTABLE:
178	n/a	startup_obj = 'c0w32'
179	n/a	if debug:
180	n/a	ld_args = self.ldflags_exe_debug[:]
181	n/a	else:
182	n/a	ld_args = self.ldflags_exe[:]
183	n/a	else:
184	n/a	startup_obj = 'c0d32'
185	n/a	if debug:
186	n/a	ld_args = self.ldflags_shared_debug[:]
187	n/a	else:
188	n/a	ld_args = self.ldflags_shared[:]
189	n/a
190	n/a
191	n/a	# Create a temporary exports file for use by the linker
192	n/a	if export_symbols is None:
193	n/a	def_file = ''
194	n/a	else:
195	n/a	head, tail = os.path.split(output_filename)
196	n/a	modname, ext = os.path.splitext(tail)
197	n/a	temp_dir = os.path.dirname(objects[0]) # preserve tree structure
198	n/a	def_file = os.path.join(temp_dir, '%s.def' % modname)
199	n/a	contents = ['EXPORTS']
200	n/a	for sym in (export_symbols or []):
201	n/a	contents.append(' %s=_%s' % (sym, sym))
202	n/a	self.execute(write_file, (def_file, contents),
203	n/a	"writing %s" % def_file)
204	n/a
205	n/a	# Borland C++ has problems with '/' in paths
206	n/a	objects2 = [os.path.normpath(o) for o in objects]
207	n/a	# split objects in .obj and .res files
208	n/a	# Borland C++ needs them at different positions in the command line
209	n/a	objects = [startup_obj]
210	n/a	resources = []
211	n/a	for file in objects2:
212	n/a	base, ext = os.path.splitext(os.path.normcase(file))
213	n/a	if ext == '.res':
214	n/a	resources.append(file)
215	n/a	else:
216	n/a	objects.append(file)
217	n/a
218	n/a
219	n/a	for l in library_dirs:
220	n/a	ld_args.append("/L%s" % os.path.normpath(l))
221	n/a	ld_args.append("/L.") # we sometimes use relative paths
222	n/a
223	n/a	# list of object files
224	n/a	ld_args.extend(objects)
225	n/a
226	n/a	# XXX the command line syntax for Borland C++ is a bit wonky;
227	n/a	# certain filenames are jammed together in one big string, but
228	n/a	# comma-delimited. This doesn't mesh too well with the
229	n/a	# Unix-centric attitude (with a DOS/Windows quoting hack) of
230	n/a	# 'spawn()', so constructing the argument list is a bit
231	n/a	# awkward. Note that doing the obvious thing and jamming all
232	n/a	# the filenames and commas into one argument would be wrong,
233	n/a	# because 'spawn()' would quote any filenames with spaces in
234	n/a	# them. Arghghh!. Apparently it works fine as coded...
235	n/a
236	n/a	# name of dll/exe file
237	n/a	ld_args.extend((',',output_filename))
238	n/a	# no map file and start libraries
239	n/a	ld_args.append(',,')
240	n/a
241	n/a	for lib in libraries:
242	n/a	# see if we find it and if there is a bcpp specific lib
243	n/a	# (xxx_bcpp.lib)
244	n/a	libfile = self.find_library_file(library_dirs, lib, debug)
245	n/a	if libfile is None:
246	n/a	ld_args.append(lib)
247	n/a	# probably a BCPP internal library -- don't warn
248	n/a	else:
249	n/a	# full name which prefers bcpp_xxx.lib over xxx.lib
250	n/a	ld_args.append(libfile)
251	n/a
252	n/a	# some default libraries
253	n/a	ld_args.append('import32')
254	n/a	ld_args.append('cw32mt')
255	n/a
256	n/a	# def file for export symbols
257	n/a	ld_args.extend((',',def_file))
258	n/a	# add resource files
259	n/a	ld_args.append(',')
260	n/a	ld_args.extend(resources)
261	n/a
262	n/a
263	n/a	if extra_preargs:
264	n/a	ld_args[:0] = extra_preargs
265	n/a	if extra_postargs:
266	n/a	ld_args.extend(extra_postargs)
267	n/a
268	n/a	self.mkpath(os.path.dirname(output_filename))
269	n/a	try:
270	n/a	self.spawn([self.linker] + ld_args)
271	n/a	except PackagingExecError as msg:
272	n/a	raise LinkError(msg)
273	n/a
274	n/a	else:
275	n/a	logger.debug("skipping %s (up-to-date)", output_filename)
276	n/a
277	n/a	# -- Miscellaneous methods -----------------------------------------
278	n/a
279	n/a
280	n/a	def find_library_file(self, dirs, lib, debug=False):
281	n/a	# List of effective library names to try, in order of preference:
282	n/a	# xxx_bcpp.lib is better than xxx.lib
283	n/a	# and xxx_d.lib is better than xxx.lib if debug is set
284	n/a	#
285	n/a	# The "_bcpp" suffix is to handle a Python installation for people
286	n/a	# with multiple compilers (primarily Packaging hackers, I suspect
287	n/a	# ;-). The idea is they'd have one static library for each
288	n/a	# compiler they care about, since (almost?) every Windows compiler
289	n/a	# seems to have a different format for static libraries.
290	n/a	if debug:
291	n/a	dlib = (lib + "_d")
292	n/a	try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
293	n/a	else:
294	n/a	try_names = (lib + "_bcpp", lib)
295	n/a
296	n/a	for dir in dirs:
297	n/a	for name in try_names:
298	n/a	libfile = os.path.join(dir, self.library_filename(name))
299	n/a	if os.path.exists(libfile):
300	n/a	return libfile
301	n/a	else:
302	n/a	# Oops, didn't find it in any of 'dirs'
303	n/a	return None
304	n/a
305	n/a	# overwrite the one from CCompiler to support rc and res-files
306	n/a	def object_filenames(self, source_filenames, strip_dir=False,
307	n/a	output_dir=''):
308	n/a	if output_dir is None:
309	n/a	output_dir = ''
310	n/a	obj_names = []
311	n/a	for src_name in source_filenames:
312	n/a	# use normcase to make sure '.rc' is really '.rc' and not '.RC'
313	n/a	base, ext = os.path.splitext(os.path.normcase(src_name))
314	n/a	if ext not in (self.src_extensions + ['.rc','.res']):
315	n/a	raise UnknownFileError("unknown file type '%s' (from '%s')" % \
316	n/a	(ext, src_name))
317	n/a	if strip_dir:
318	n/a	base = os.path.basename(base)
319	n/a	if ext == '.res':
320	n/a	# these can go unchanged
321	n/a	obj_names.append(os.path.join(output_dir, base + ext))
322	n/a	elif ext == '.rc':
323	n/a	# these need to be compiled to .res-files
324	n/a	obj_names.append(os.path.join(output_dir, base + '.res'))
325	n/a	else:
326	n/a	obj_names.append(os.path.join(output_dir,
327	n/a	base + self.obj_extension))
328	n/a	return obj_names
329	n/a
330	n/a
331	n/a	def preprocess(self, source, output_file=None, macros=None,
332	n/a	include_dirs=None, extra_preargs=None,
333	n/a	extra_postargs=None):
334	n/a	_, macros, include_dirs = \
335	n/a	self._fix_compile_args(None, macros, include_dirs)
336	n/a	pp_opts = gen_preprocess_options(macros, include_dirs)
337	n/a	pp_args = ['cpp32.exe'] + pp_opts
338	n/a	if output_file is not None:
339	n/a	pp_args.append('-o' + output_file)
340	n/a	if extra_preargs:
341	n/a	pp_args[:0] = extra_preargs
342	n/a	if extra_postargs:
343	n/a	pp_args.extend(extra_postargs)
344	n/a	pp_args.append(source)
345	n/a
346	n/a	# We need to preprocess: either we're being forced to, or the
347	n/a	# source file is newer than the target (or the target doesn't
348	n/a	# exist).
349	n/a	if self.force or output_file is None or newer(source, output_file):
350	n/a	if output_file:
351	n/a	self.mkpath(os.path.dirname(output_file))
352	n/a	try:
353	n/a	self.spawn(pp_args)
354	n/a	except PackagingExecError as msg:
355	n/a	raise CompileError(msg)