Context Navigation

source: rtems-libbsd/builder.py @ bce3e5e

55-freebsd-126-freebsd-12

Last change on this file since bce3e5e was 5c3223f, checked in by Christian Mauderer <Christian.Mauderer@…>, on 11/16/16 at 15:29:17
ifconfig/wlan, expat, lib80211: Port to RTEMS.
Property mode set to `100755`
File size: 24.6 KB

Line
1	#
2	# Copyright (c) 2015-2016 Chris Johns <chrisj@rtems.org>. All rights reserved.
3	#
4	# Copyright (c) 2009-2015 embedded brains GmbH. All rights reserved.
5	#
6	# embedded brains GmbH
7	# Dornierstr. 4
8	# 82178 Puchheim
9	# Germany
10	# <info@embedded-brains.de>
11	#
12	# Copyright (c) 2012 OAR Corporation. All rights reserved.
13	#
14	# Redistribution and use in source and binary forms, with or without
15	# modification, are permitted provided that the following conditions
16	# are met:
17	# 1. Redistributions of source code must retain the above copyright
18	# notice, this list of conditions and the following disclaimer.
19	# 2. Redistributions in binary form must reproduce the above copyright
20	# notice, this list of conditions and the following disclaimer in the
21	# documentation and/or other materials provided with the distribution.
22	#
23	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24	# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25	# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26	# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27	# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28	# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29	# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33	# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
35	# FreeBSD: http://svn.freebsd.org/base/releng/8.2/sys (revision 222485)
36
37	from __future__ import print_function
38
39	import shutil
40	import os
41	import re
42	import sys
43	import getopt
44	import filecmp
45	import difflib
46	import codecs
47
48	#
49	# Global controls.
50	#
51	RTEMS_DIR = "."
52	FreeBSD_DIR = "freebsd-org"
53	verboseLevel = 0
54	isDryRun = False
55	isDiffMode = False
56	filesProcessedCount = 0
57	filesProcessed = []
58	filesTotal = 0
59	filesTotalLines = 0
60	filesTotalInserts = 0
61	filesTotalDeletes = 0
62	diffDetails = { }
63
64	verboseInfo = 1
65	verboseDetail = 2
66	verboseMoreDetail = 3
67	verboseDebug = 4
68
69	def verbose(level = verboseInfo):
70	return verboseLevel >= level
71
72	def changedFileSummary(statsReport = False):
73
74	global filesTotal, filesTotalLines, filesTotalInserts, filesTotalDeletes
75
76	if isDiffMode == False:
77	if verbose():
78	print('%d file(s) were changed:' % (filesProcessedCount))
79	for f in sorted(filesProcessed):
80	print(' %s' % (f))
81	else:
82	print('%d file(s) were changed.' % (filesProcessedCount))
83	if statsReport:
84	print('Stats Report:')
85	transparent = filesTotal - len(diffDetails)
86	changes = filesTotalInserts + filesTotalDeletes
87	opacity = (float(changes) / (filesTotalLines + changes)) * 100.0
88	print(' Total File(s):%d Unchanged:%d (%.1f%%) Changed:%d' \
89	' Opacity:%5.1f%% Lines:%d Edits:%d (+):%d (-):%d' % \
90	(filesTotal, transparent, (float(transparent) / filesTotal) * 100.0, len(diffDetails), \
91	opacity, filesTotalLines, changes, filesTotalInserts, filesTotalDeletes))
92	#
93	# Sort by opacity.
94	#
95	ordered_diffs = sorted(diffDetails.items(), key = lambda diff: diff[1].opacity, reverse = True)
96	for f in ordered_diffs:
97	print(' %s' % (diffDetails[f[0]].status()))
98
99	def readFile(name):
100	try:
101	contents = codecs.open(name, mode = 'r', encoding = 'utf-8', errors = 'ignore').read()
102	except UnicodeDecodeError as ude:
103	print('error: reading: %s: %s' % (name, ude))
104	sys.exit(1)
105	return contents
106
107	def writeFile(name, contents):
108	path = os.path.dirname(name)
109	if not os.path.exists(path):
110	try:
111	os.makedirs(path)
112	except OSError as oe:
113	print('error: cannot create directory: %s: %s' % (path, oe))
114	sys.exit(1)
115	try:
116	codecs.open(name, mode = 'w', encoding = 'utf-8', errors = 'ignore').write(contents)
117	except UnicodeDecodeError as ude:
118	print('error: write: %s: %s' % (name, ude))
119	sys.exit(1)
120
121	#
122	# A builder error.
123	#
124	class error(Exception):
125	"""Base class for exceptions."""
126	def __init__(self, msg):
127	self.msg = 'error: %s' % (msg)
128	def set_output(self, msg):
129	self.msg = msg
130	def __str__(self):
131	return self.msg
132
133	#
134	# Diff Record
135	#
136	class diffRecord:
137	def __init__(self, src, dst, orig, diff, inserts, deletes):
138	self.src = src
139	self.dst = dst
140	self.orig = orig
141	self.diff = diff
142	self.lines = len(orig)
143	self.inserts = inserts
144	self.deletes = deletes
145	self.changes = inserts + deletes
146	self.opacity = (float(self.changes) / (self.lines + self.changes)) * 100.0
147
148	def __repr__(self):
149	return self.src
150
151	def status(self):
152	return 'opacity:%5.1f%% edits:%4d (+):%-4d (-):%-4d %s' % \
153	(self.opacity, self.changes, self.inserts, self.deletes, self.src)
154
155	#
156	# This stuff needs to move to libbsd.py.
157	#
158	def commonFlags():
159	return ['-O2',
160	'-g',
161	'-fno-strict-aliasing',
162	'-ffreestanding',
163	'-fno-common']
164
165	def commonWarnings():
166	return ['-Wall',
167	'-Wno-format',
168	'-Wno-pointer-sign']
169
170	def commonNoWarnings():
171	return ['-w']
172
173	def includes():
174	return ['-Irtemsbsd/include',
175	'-Ifreebsd/sys',
176	'-Ifreebsd/sys/contrib/pf',
177	'-Ifreebsd/sys/net',
178	'-Ifreebsd/include',
179	'-Ifreebsd/lib',
180	'-Ifreebsd/lib/libc/include',
181	'-Ifreebsd/lib/libc/isc/include',
182	'-Ifreebsd/lib/libc/resolv',
183	'-Ifreebsd/lib/libutil',
184	'-Ifreebsd/lib/libkvm',
185	'-Ifreebsd/lib/libmemstat',
186	'-Ifreebsd/lib/libipsec',
187	'-Ifreebsd/contrib/expat/lib',
188	'-Ifreebsd/contrib/libpcap',
189	'-Ifreebsd/contrib/libxo',
190	'-Irtemsbsd/sys',
191	'-ImDNSResponder/mDNSCore',
192	'-ImDNSResponder/mDNSShared',
193	'-ImDNSResponder/mDNSPosix',
194	'-Itestsuite/include']
195
196	def cpuIncludes():
197	return ['-Irtemsbsd/@CPU@/include',
198	'-Ifreebsd/sys/@CPU@/include']
199
200	def cflags():
201	return ['-std=gnu11']
202
203	def cxxflags():
204	return ['-std=gnu++11']
205
206	def headerPaths():
207	# local path wildcard dest path
208	return [('rtemsbsd/include', '*.h', ''),
209	('rtemsbsd/mghttpd', 'mongoose.h', 'mghttpd'),
210	('freebsd/include', '*.h', ''),
211	('freebsd/sys/bsm', '*.h', 'bsm'),
212	('freebsd/sys/cam', '*.h', 'cam'),
213	('freebsd/sys/net', '*.h', 'net'),
214	('freebsd/sys/net80211', '*.h', 'net80211'),
215	('freebsd/sys/netinet', '*.h', 'netinet'),
216	('freebsd/sys/netinet6', '*.h', 'netinet6'),
217	('freebsd/sys/netipsec', '*.h', 'netipsec'),
218	('freebsd/sys/rpc', '*.h', 'rpc'),
219	('freebsd/sys/sys', '*.h', 'sys'),
220	('freebsd/sys/vm', '*.h', 'vm'),
221	('freebsd/sys/dev/mii', '*.h', 'dev/mii'),
222	('mDNSResponder/mDNSCore', 'mDNSDebug.h', ''),
223	('mDNSResponder/mDNSCore', 'mDNSEmbeddedAPI.h', ''),
224	('mDNSResponder/mDNSShared', 'dns_sd.h', ''),
225	('mDNSResponder/mDNSPosix', 'mDNSPosix.h', '')]
226
227	# Move target dependent files under a machine directory
228	def mapCPUDependentPath(path):
229	return path.replace("include/", "include/machine/")
230
231	def fixIncludes(data):
232	data = re.sub('#include <sys/lock.h>', '#include <rtems/bsd/sys/lock.h>', data)
233	data = re.sub('#include <sys/cpuset.h>', '#include <rtems/bsd/sys/cpuset.h>', data)
234	data = re.sub('#include <sys/errno.h>', '#include <rtems/bsd/sys/errno.h>', data)
235	data = re.sub('#include <sys/param.h>', '#include <rtems/bsd/sys/param.h>', data)
236	data = re.sub('#include <sys/resource.h>', '#include <rtems/bsd/sys/resource.h>', data)
237	data = re.sub('#include <sys/unistd.h>', '#include <rtems/bsd/sys/unistd.h>', data)
238	return data
239
240	# revert fixing the include paths inside a C or .h file
241	def revertFixIncludes(data):
242	data = re.sub('#include <rtems/bsd/', '#include <', data)
243	data = re.sub('#include <util.h>', '#include <rtems/bsd/util.h>', data)
244	data = re.sub('#include <bsd.h>', '#include <rtems/bsd/bsd.h>', data)
245	data = re.sub('#include <zerocopy.h>', '#include <rtems/bsd/zerocopy.h>', data)
246	return data
247
248	# fix include paths inside a C or .h file
249	def fixLocalIncludes(data):
250	data = re.sub('#include "opt_([^"]*)"', '#include <rtems/bsd/local/opt_\\1>', data)
251	data = re.sub('#include "([^"]*)_if.h"', '#include <rtems/bsd/local/\\1_if.h>', data)
252	data = re.sub('#include "miidevs([^"]*)"', '#include <rtems/bsd/local/miidevs\\1>', data)
253	data = re.sub('#include "usbdevs([^"]*)"', '#include <rtems/bsd/local/usbdevs\\1>', data)
254	return data
255
256	# revert fixing the include paths inside a C or .h file
257	def revertFixLocalIncludes(data):
258	data = re.sub('#include <rtems/bsd/local/([^>]*)>', '#include "\\1"', data)
259	return data
260
261	def assertHeaderFile(path):
262	if path[-2] != '.' or path[-1] != 'h':
263	print("*** " + path + " does not end in .h")
264	print("*** Move it to a C source file list")
265	sys.exit(2)
266
267	def assertSourceFile(path):
268	if path[-2] != '.' or (path[-1] != 'c' and path[-1] != 'S'):
269	print("*** " + path + " does not end in .c")
270	print("*** Move it to a header file list")
271	sys.exit(2)
272
273	def diffSource(dstLines, srcLines, src, dst):
274	global filesTotal, filesTotalLines, filesTotalInserts, filesTotalDeletes
275	#
276	# Diff, note there is no line termination on each string. Expand the
277	# generator to list because the generator is not reusable.
278	#
279	diff = list(difflib.unified_diff(dstLines,
280	srcLines,
281	fromfile = src,
282	tofile = dst,
283	n = 5,
284	lineterm = ''))
285	inserts = 0
286	deletes = 0
287	if len(diff) > 0:
288	if src in diffDetails and \
289	diffDetails[src].dst != dst and diffDetails[src].diff != diff:
290	raise error('repeated diff of file different: src:%s dst:%s' % (src, dst))
291	for l in diff:
292	if l[0] == '-':
293	deletes += 1
294	elif l[0] == '+':
295	inserts += 1
296	diffDetails[src] = diffRecord(src, dst, srcLines, diff, inserts, deletes)
297
298	#
299	# Count the total files, lines and the level of changes.
300	#
301	filesTotal += 1
302	filesTotalLines += len(srcLines)
303	filesTotalInserts += inserts
304	filesTotalDeletes += deletes
305
306	return diff
307
308	#
309	# Converters provide a way to alter the various types of code. The conversion
310	# process filters a file as it is copies from the source path to the
311	# destination path. Specialised versions are provided for different types of
312	# source.
313	#
314	class Converter(object):
315
316	def convert(self, src, dst, hasSource = True, sourceFilter = None, srcContents = None):
317
318	global filesProcessed, filesProcessedCount
319
320	if verbose(verboseDebug):
321	print("convert: filter:%s: %s -> %s" % \
322	(['yes', 'no'][sourceFilter is None], src, dst))
323
324	#
325	# If there is no source raise an error if we expect source else print a
326	# warning and do not try and convert.
327	#
328	if srcContents is None:
329	if not os.path.exists(src):
330	if hasSource:
331	raise error('source not found: %s' % (src))
332	else:
333	print('warning: no source: %s' % (src))
334	return
335
336	#
337	# Files read as a single string if not passed in.
338	#
339	srcContents = readFile(src)
340
341	if os.path.exists(dst):
342	dstContents = readFile(dst)
343	else:
344	print('warning: no destination: %s' % (dst))
345	dstContents = ''
346
347	#
348	# Filter the source.
349	#
350	if sourceFilter is not None:
351	srcContents = sourceFilter(srcContents)
352
353	#
354	# Split into a list of lines.
355	#
356	srcLines = srcContents.split(os.linesep)
357	dstLines = dstContents.split(os.linesep)
358
359	if verbose(verboseDebug):
360	print('Unified diff: %s (lines:%d)' % (src, len(srcLines)))
361
362	#
363	# Diff, note there is no line termination on each string.
364	#
365	diff = diffSource(dstLines, srcLines, src, dst)
366
367	#
368	# The diff list is empty if the files are the same.
369	#
370	if len(diff) > 0:
371
372	if verbose(verboseDebug):
373	print('Unified diff length: %d' % len(diff))
374
375	filesProcessed += [dst]
376	filesProcessedCount += 1
377	if isDiffMode == False:
378	if verbose(verboseDetail):
379	print("UPDATE: %s -> %s" % (src, dst))
380	if isDryRun == False:
381	writeFile(dst, srcContents)
382	else:
383	print("diff -u %s %s" % (src, dst))
384	for l in diff:
385	print(l)
386
387	class NoConverter(Converter):
388	def convert(self, src, dst, hasSource = True, sourceFilter = None):
389	return '/* EMPTY */\n'
390
391	class FromFreeBSDToRTEMSHeaderConverter(Converter):
392	def sourceFilter(self, data):
393	data = fixLocalIncludes(data)
394	data = fixIncludes(data)
395	return data
396
397	def convert(self, src, dst):
398	sconverter = super(FromFreeBSDToRTEMSHeaderConverter, self)
399	sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
400
401	class FromFreeBSDToRTEMSUserSpaceHeaderConverter(Converter):
402	def sourceFilter(self, data):
403	data = fixIncludes(data)
404	return data
405
406	def convert(self, src, dst):
407	sconverter = super(FromFreeBSDToRTEMSUserSpaceHeaderConverter, self)
408	sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
409
410	class FromFreeBSDToRTEMSSourceConverter(Converter):
411	def sourceFilter(self, data):
412	data = fixLocalIncludes(data)
413	data = fixIncludes(data)
414	data = '#include <machine/rtems-bsd-kernel-space.h>\n\n' + data
415	return data
416
417	def convert(self, src, dst):
418	sconverter = super(FromFreeBSDToRTEMSSourceConverter, self)
419	sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
420
421	class FromFreeBSDToRTEMSUserSpaceSourceConverter(Converter):
422	def sourceFilter(self, data):
423	data = fixIncludes(data)
424	data = '#include <machine/rtems-bsd-user-space.h>\n\n' + data
425	return data
426
427	def convert(self, src, dst):
428	sconverter = super(FromFreeBSDToRTEMSUserSpaceSourceConverter, self)
429	sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
430
431	class FromRTEMSToFreeBSDHeaderConverter(Converter):
432	def sourceFilter(self, data):
433	data = revertFixLocalIncludes(data)
434	data = revertFixIncludes(data)
435	return data
436
437	def convert(self, src, dst):
438	sconverter = super(FromRTEMSToFreeBSDHeaderConverter, self)
439	sconverter.convert(src, dst, hasSource = False, sourceFilter = self.sourceFilter)
440
441	class FromRTEMSToFreeBSDSourceConverter(Converter):
442	def sourceFilter(self, data):
443	data = re.sub('#include <machine/rtems-bsd-kernel-space.h>\n\n', '', data)
444	data = re.sub('#include <machine/rtems-bsd-user-space.h>\n\n', '', data)
445	data = revertFixLocalIncludes(data)
446	data = revertFixIncludes(data)
447	return data
448
449	def convert(self, src, dst):
450	sconverter = super(FromRTEMSToFreeBSDSourceConverter, self)
451	sconverter.convert(src, dst, hasSource = False, sourceFilter = self.sourceFilter)
452
453	#
454	# Compose a path based for the various parts of the source tree.
455	#
456	class PathComposer(object):
457	def composeFreeBSDPath(self, path):
458	return path
459
460	def composeRTEMSPath(self, path, prefix):
461	return os.path.join(prefix, path)
462
463	class FreeBSDPathComposer(PathComposer):
464	def composeFreeBSDPath(self, path):
465	return os.path.join(FreeBSD_DIR, path)
466
467	def composeRTEMSPath(self, path, prefix):
468	return os.path.join(prefix, 'freebsd', path)
469
470	class RTEMSPathComposer(PathComposer):
471	def composeFreeBSDPath(self, path):
472	return path
473
474	def composeRTEMSPath(self, path, prefix):
475	return os.path.join(prefix, 'rtemsbsd', path)
476
477	class CPUDependentPathComposer(FreeBSDPathComposer):
478	def composeRTEMSPath(self, path, prefix):
479	path = super(CPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
480	path = mapCPUDependentPath(path)
481	return path
482
483	class TargetSourceCPUDependentPathComposer(CPUDependentPathComposer):
484	def __init__(self, targetCPU, sourceCPU):
485	self.targetCPU = targetCPU
486	self.sourceCPU = sourceCPU
487
488	def composeRTEMSPath(self, path, prefix):
489	path = super(TargetSourceCPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
490	path = path.replace(self.sourceCPU, self.targetCPU)
491	return path
492
493	class BuildSystemFragmentComposer(object):
494	def __init__(self, includes = None):
495	if type(includes) is not list:
496	self.includes = [includes]
497	else:
498	self.includes = includes
499
500	def compose(self, path):
501	return ''
502
503	#
504	# File - a file in the source we move backwards and forwards.
505	#
506	class File(object):
507	def __init__(self, path, pathComposer,
508	forwardConverter, reverseConverter, buildSystemComposer):
509	if verbose(verboseMoreDetail):
510	print("FILE: %-50s F:%-45s R:%-45s" % \
511	(path,
512	forwardConverter.__class__.__name__,
513	reverseConverter.__class__.__name__))
514	self.path = path
515	self.pathComposer = pathComposer
516	self.freebsdPath = self.pathComposer.composeFreeBSDPath(self.path)
517	self.rtemsPath = self.pathComposer.composeRTEMSPath(self.path, RTEMS_DIR)
518	self.forwardConverter = forwardConverter
519	self.reverseConverter = reverseConverter
520	self.buildSystemComposer = buildSystemComposer
521
522	def processSource(self, forward):
523	if forward:
524	if verbose(verboseDetail):
525	print("process source: %s => %s" % (self.freebsdPath, self.rtemsPath))
526	self.forwardConverter.convert(self.freebsdPath, self.rtemsPath)
527	else:
528	if verbose(verboseDetail):
529	print("process source: %s => %s converter:%s" % \
530	(self.rtemsPath, self.freebsdPath, self.reverseConverter.__class__.__name__))
531	self.reverseConverter.convert(self.rtemsPath, self.freebsdPath)
532
533	def getFragment(self):
534	return self.buildSystemComposer.compose(self.pathComposer.composeRTEMSPath(self.path, ''))
535
536	#
537	# Module - logical group of related files we can perform actions on
538	#
539	class Module:
540	def __init__(self, name):
541	self.name = name
542	self.conditionalOn = "none"
543	self.files = []
544	self.cpuDependentSourceFiles = {}
545	self.dependencies = []
546
547	def initCPUDependencies(self, cpu):
548	if cpu not in self.cpuDependentSourceFiles:
549	self.cpuDependentSourceFiles[cpu] = []
550
551	def processSource(self, direction):
552	if verbose(verboseDetail):
553	print("process module: %s" % (self.name))
554	for f in self.files:
555	f.processSource(direction)
556	for cpu, files in self.cpuDependentSourceFiles.items():
557	for f in files:
558	f.processSource(direction)
559
560	def addFiles(self, newFiles, buildSystemComposer = BuildSystemFragmentComposer()):
561	files = []
562	for newFile in newFiles:
563	assertFile(newFile)
564	files += [File(newFile, composers, buildSystemComposer)]
565	return files
566
567	def addFile(self, f):
568	self.files += [f]
569
570	def addFiles(self, newFiles,
571	pathComposer, fromFreeBSDToRTEMSConverter, fromRTEMSToFreeBSDConverter,
572	assertFile, buildSystemComposer = BuildSystemFragmentComposer()):
573	files = []
574	for newFile in newFiles:
575	assertFile(newFile)
576	files += [File(newFile, pathComposer, fromFreeBSDToRTEMSConverter,
577	fromRTEMSToFreeBSDConverter, buildSystemComposer)]
578	return files
579
580	def addKernelSpaceHeaderFiles(self, files):
581	self.files += self.addFiles(files,
582	FreeBSDPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
583	FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
584
585	def addUserSpaceHeaderFiles(self, files):
586	self.files += self.addFiles(files,
587	FreeBSDPathComposer(), FromFreeBSDToRTEMSUserSpaceHeaderConverter(),
588	FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
589
590	def addRTEMSHeaderFiles(self, files):
591	self.files += self.addFiles(files, RTEMSPathComposer(),
592	NoConverter(), NoConverter(), assertHeaderFile)
593
594	def addCPUDependentHeaderFiles(self, files):
595	self.files += self.addFiles(files,
596	CPUDependentPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
597	FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
598
599	def addTargetSourceCPUDependentHeaderFiles(self, targetCPUs, sourceCPU, files):
600	for cpu in targetCPUs:
601	self.files += self.addFiles(files,
602	TargetSourceCPUDependentPathComposer(cpu, sourceCPU),
603	FromFreeBSDToRTEMSHeaderConverter(),
604	NoConverter(), assertHeaderFile)
605
606	def addSourceFiles(self, files, sourceFileFragmentComposer):
607	self.files += self.addFiles(files,
608	PathComposer(), NoConverter(), NoConverter(), assertSourceFile,
609	sourceFileFragmentComposer)
610
611	def addKernelSpaceSourceFiles(self, files, sourceFileFragmentComposer):
612	self.files += self.addFiles(files,
613	FreeBSDPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
614	FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
615	sourceFileFragmentComposer)
616
617	def addUserSpaceSourceFiles(self, files, sourceFileFragmentComposer):
618	self.files += self.addFiles(files,
619	FreeBSDPathComposer(),
620	FromFreeBSDToRTEMSUserSpaceSourceConverter(),
621	FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
622	sourceFileFragmentComposer)
623
624	def addRTEMSSourceFiles(self, files, sourceFileFragmentComposer):
625	self.files += self.addFiles(files,
626	RTEMSPathComposer(), NoConverter(), NoConverter(),
627	assertSourceFile, sourceFileFragmentComposer)
628
629	def addCPUDependentSourceFiles(self, cpus, files, sourceFileFragmentComposer):
630	for cpu in cpus:
631	self.initCPUDependencies(cpu)
632	self.cpuDependentSourceFiles[cpu] += \
633	self.addFiles(files,
634	CPUDependentPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
635	FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
636	sourceFileFragmentComposer)
637
638	def addTest(self, testFragementComposer):
639	self.files += [File(testFragementComposer.testName,
640	PathComposer(), NoConverter(), NoConverter(),
641	testFragementComposer)]
642
643	def addDependency(self, dep):
644	self.dependencies += [dep]
645
646	#
647	# Manager - a collection of modules.
648	#
649	class ModuleManager:
650	def __init__(self):
651	self.modules = {}
652	self.generator = {}
653	self.setGenerators()
654
655	def __getitem__(self, key):
656	if key not in self.modules:
657	raise KeyError('module %s not found' % (key))
658	return self.modules[key]
659
660	def getModules(self):
661	return sorted(self.modules.keys())
662
663	def addModule(self, module):
664	self.modules[module.name] = module
665
666	def processSource(self, direction):
667	if verbose(verboseDetail):
668	print("process modules:")
669	for m in sorted(self.modules):
670	self.modules[m].processSource(direction)

Note: See TracBrowser for help on using the repository browser.

Download in other formats: