source: rtems-libbsd/builder.py @ ecda181

5-freebsd-12
Last change on this file since ecda181 was ecda181, checked in by Christian Mauderer <Christian.Mauderer@…>, on Dec 9, 2016 at 10:51:50 AM

freebsd/wlanstats: Port to FreeBSD.

  • Property mode set to 100755
File size: 24.7 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
37from __future__ import print_function
38
39import shutil
40import os
41import re
42import sys
43import getopt
44import filecmp
45import difflib
46import codecs
47
48#
49# Global controls.
50#
51RTEMS_DIR = "."
52FreeBSD_DIR = "freebsd-org"
53verboseLevel = 0
54isDryRun = False
55isDiffMode = False
56filesProcessedCount = 0
57filesProcessed = []
58filesTotal = 0
59filesTotalLines = 0
60filesTotalInserts = 0
61filesTotalDeletes = 0
62diffDetails = { }
63
64verboseInfo = 1
65verboseDetail = 2
66verboseMoreDetail = 3
67verboseDebug = 4
68
69def verbose(level = verboseInfo):
70    return verboseLevel >= level
71
72def 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
99def 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
107def 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#
124class 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#
136class 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#
158def commonFlags():
159    return ['-O2',
160            '-g',
161            '-fno-strict-aliasing',
162            '-ffreestanding',
163            '-fno-common']
164
165def commonWarnings():
166    return ['-Wall',
167            '-Wno-format',
168            '-Wno-pointer-sign']
169
170def commonNoWarnings():
171    return ['-w']
172
173def 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/libbsdstat',
181            '-Ifreebsd/lib/libc/include',
182            '-Ifreebsd/lib/libc/isc/include',
183            '-Ifreebsd/lib/libc/resolv',
184            '-Ifreebsd/lib/libutil',
185            '-Ifreebsd/lib/libkvm',
186            '-Ifreebsd/lib/libmemstat',
187            '-Ifreebsd/lib/libipsec',
188            '-Ifreebsd/contrib/expat/lib',
189            '-Ifreebsd/contrib/libpcap',
190            '-Ifreebsd/contrib/libxo',
191            '-Irtemsbsd/sys',
192            '-ImDNSResponder/mDNSCore',
193            '-ImDNSResponder/mDNSShared',
194            '-ImDNSResponder/mDNSPosix',
195            '-Itestsuite/include']
196
197def cpuIncludes():
198    return ['-Irtemsbsd/@CPU@/include',
199            '-Ifreebsd/sys/@CPU@/include']
200
201def cflags():
202    return ['-std=gnu11']
203
204def cxxflags():
205    return ['-std=gnu++11']
206
207def headerPaths():
208    #         local path                      wildcard             dest path
209    return [('rtemsbsd/include',              '*.h',               ''),
210            ('rtemsbsd/mghttpd',              'mongoose.h',        'mghttpd'),
211            ('freebsd/include',               '*.h',               ''),
212            ('freebsd/sys/bsm',               '*.h',               'bsm'),
213            ('freebsd/sys/cam',               '*.h',               'cam'),
214            ('freebsd/sys/net',               '*.h',               'net'),
215            ('freebsd/sys/net80211',          '*.h',               'net80211'),
216            ('freebsd/sys/netinet',           '*.h',               'netinet'),
217            ('freebsd/sys/netinet6',          '*.h',               'netinet6'),
218            ('freebsd/sys/netipsec',          '*.h',               'netipsec'),
219            ('freebsd/sys/rpc',               '*.h',               'rpc'),
220            ('freebsd/sys/sys',               '*.h',               'sys'),
221            ('freebsd/sys/vm',                '*.h',               'vm'),
222            ('freebsd/sys/dev/mii',           '*.h',               'dev/mii'),
223            ('mDNSResponder/mDNSCore',        'mDNSDebug.h',       ''),
224            ('mDNSResponder/mDNSCore',        'mDNSEmbeddedAPI.h', ''),
225            ('mDNSResponder/mDNSShared',      'dns_sd.h',          ''),
226            ('mDNSResponder/mDNSPosix',       'mDNSPosix.h',       '')]
227
228# Move target dependent files under a machine directory
229def mapCPUDependentPath(path):
230  return path.replace("include/", "include/machine/")
231
232def fixIncludes(data):
233    data = re.sub('#include <sys/lock.h>',     '#include <rtems/bsd/sys/lock.h>', data)
234    data = re.sub('#include <sys/cpuset.h>',   '#include <rtems/bsd/sys/cpuset.h>', data)
235    data = re.sub('#include <sys/errno.h>',    '#include <rtems/bsd/sys/errno.h>', data)
236    data = re.sub('#include <sys/param.h>',    '#include <rtems/bsd/sys/param.h>', data)
237    data = re.sub('#include <sys/resource.h>', '#include <rtems/bsd/sys/resource.h>', data)
238    data = re.sub('#include <sys/unistd.h>',   '#include <rtems/bsd/sys/unistd.h>', data)
239    return data
240
241# revert fixing the include paths inside a C or .h file
242def revertFixIncludes(data):
243    data = re.sub('#include <rtems/bsd/',  '#include <', data)
244    data = re.sub('#include <util.h>',     '#include <rtems/bsd/util.h>', data)
245    data = re.sub('#include <bsd.h>',      '#include <rtems/bsd/bsd.h>', data)
246    data = re.sub('#include <zerocopy.h>', '#include <rtems/bsd/zerocopy.h>', data)
247    return data
248
249# fix include paths inside a C or .h file
250def fixLocalIncludes(data):
251    data = re.sub('#include "opt_([^"]*)"',    '#include <rtems/bsd/local/opt_\\1>', data)
252    data = re.sub('#include "([^"]*)_if.h"',   '#include <rtems/bsd/local/\\1_if.h>', data)
253    data = re.sub('#include "miidevs([^"]*)"', '#include <rtems/bsd/local/miidevs\\1>', data)
254    data = re.sub('#include "usbdevs([^"]*)"', '#include <rtems/bsd/local/usbdevs\\1>', data)
255    return data
256
257# revert fixing the include paths inside a C or .h file
258def revertFixLocalIncludes(data):
259    data = re.sub('#include <rtems/bsd/local/([^>]*)>', '#include "\\1"', data)
260    return data
261
262def assertHeaderFile(path):
263    if path[-2] != '.' or path[-1] != 'h':
264        print("*** " + path + " does not end in .h")
265        print("*** Move it to a C source file list")
266        sys.exit(2)
267
268def assertSourceFile(path):
269    if path[-2] != '.' or (path[-1] != 'c' and path[-1] != 'S'):
270        print("*** " + path + " does not end in .c")
271        print("*** Move it to a header file list")
272        sys.exit(2)
273
274def diffSource(dstLines, srcLines, src, dst):
275    global filesTotal, filesTotalLines, filesTotalInserts, filesTotalDeletes
276    #
277    # Diff, note there is no line termination on each string.  Expand the
278    # generator to list because the generator is not reusable.
279    #
280    diff = list(difflib.unified_diff(dstLines,
281                                     srcLines,
282                                     fromfile = src,
283                                     tofile = dst,
284                                     n = 5,
285                                     lineterm = ''))
286    inserts = 0
287    deletes = 0
288    if len(diff) > 0:
289        if src in diffDetails and \
290           diffDetails[src].dst != dst and diffDetails[src].diff != diff:
291            raise error('repeated diff of file different: src:%s dst:%s' % (src, dst))
292        for l in diff:
293            if l[0] == '-':
294                deletes += 1
295            elif l[0] == '+':
296                inserts += 1
297        diffDetails[src] = diffRecord(src, dst, srcLines, diff, inserts, deletes)
298
299    #
300    # Count the total files, lines and the level of changes.
301    #
302    filesTotal += 1
303    filesTotalLines += len(srcLines)
304    filesTotalInserts += inserts
305    filesTotalDeletes += deletes
306
307    return diff
308
309#
310# Converters provide a way to alter the various types of code. The conversion
311# process filters a file as it is copies from the source path to the
312# destination path. Specialised versions are provided for different types of
313# source.
314#
315class Converter(object):
316
317    def convert(self, src, dst, hasSource = True, sourceFilter = None, srcContents = None):
318
319        global filesProcessed, filesProcessedCount
320
321        if verbose(verboseDebug):
322            print("convert: filter:%s: %s -> %s" % \
323                  (['yes', 'no'][sourceFilter is None], src, dst))
324
325        #
326        # If there is no source raise an error if we expect source else print a
327        # warning and do not try and convert.
328        #
329        if srcContents is None:
330            if not os.path.exists(src):
331                if hasSource:
332                    raise error('source not found: %s' % (src))
333                else:
334                    print('warning: no source: %s' % (src))
335                    return
336
337            #
338            # Files read as a single string if not passed in.
339            #
340            srcContents = readFile(src)
341
342        if os.path.exists(dst):
343            dstContents = readFile(dst)
344        else:
345            print('warning: no destination: %s' % (dst))
346            dstContents = ''
347
348        #
349        # Filter the source.
350        #
351        if sourceFilter is not None:
352            srcContents = sourceFilter(srcContents)
353
354        #
355        # Split into a list of lines.
356        #
357        srcLines = srcContents.split(os.linesep)
358        dstLines = dstContents.split(os.linesep)
359
360        if verbose(verboseDebug):
361            print('Unified diff: %s (lines:%d)' % (src, len(srcLines)))
362
363        #
364        # Diff, note there is no line termination on each string.
365        #
366        diff = diffSource(dstLines, srcLines, src, dst)
367
368        #
369        # The diff list is empty if the files are the same.
370        #
371        if len(diff) > 0:
372
373            if verbose(verboseDebug):
374                print('Unified diff length: %d' % len(diff))
375
376            filesProcessed += [dst]
377            filesProcessedCount += 1
378            if isDiffMode == False:
379                if verbose(verboseDetail):
380                    print("UPDATE: %s -> %s" % (src, dst))
381                if isDryRun == False:
382                    writeFile(dst, srcContents)
383            else:
384                print("diff -u %s %s" % (src, dst))
385                for l in diff:
386                    print(l)
387
388class NoConverter(Converter):
389    def convert(self, src, dst, hasSource = True, sourceFilter = None):
390        return '/* EMPTY */\n'
391
392class FromFreeBSDToRTEMSHeaderConverter(Converter):
393    def sourceFilter(self, data):
394        data = fixLocalIncludes(data)
395        data = fixIncludes(data)
396        return data
397
398    def convert(self, src, dst):
399        sconverter = super(FromFreeBSDToRTEMSHeaderConverter, self)
400        sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
401
402class FromFreeBSDToRTEMSUserSpaceHeaderConverter(Converter):
403    def sourceFilter(self, data):
404        data = fixIncludes(data)
405        return data
406
407    def convert(self, src, dst):
408        sconverter = super(FromFreeBSDToRTEMSUserSpaceHeaderConverter, self)
409        sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
410
411class FromFreeBSDToRTEMSSourceConverter(Converter):
412    def sourceFilter(self, data):
413        data = fixLocalIncludes(data)
414        data = fixIncludes(data)
415        data = '#include <machine/rtems-bsd-kernel-space.h>\n\n' + data
416        return data
417
418    def convert(self, src, dst):
419        sconverter = super(FromFreeBSDToRTEMSSourceConverter, self)
420        sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
421
422class FromFreeBSDToRTEMSUserSpaceSourceConverter(Converter):
423    def sourceFilter(self, data):
424        data = fixIncludes(data)
425        data = '#include <machine/rtems-bsd-user-space.h>\n\n' + data
426        return data
427
428    def convert(self, src, dst):
429        sconverter = super(FromFreeBSDToRTEMSUserSpaceSourceConverter, self)
430        sconverter.convert(src, dst, sourceFilter = self.sourceFilter)
431
432class FromRTEMSToFreeBSDHeaderConverter(Converter):
433    def sourceFilter(self, data):
434        data = revertFixLocalIncludes(data)
435        data = revertFixIncludes(data)
436        return data
437
438    def convert(self, src, dst):
439        sconverter = super(FromRTEMSToFreeBSDHeaderConverter, self)
440        sconverter.convert(src, dst, hasSource = False,  sourceFilter = self.sourceFilter)
441
442class FromRTEMSToFreeBSDSourceConverter(Converter):
443    def sourceFilter(self, data):
444        data = re.sub('#include <machine/rtems-bsd-kernel-space.h>\n\n', '', data)
445        data = re.sub('#include <machine/rtems-bsd-user-space.h>\n\n', '', data)
446        data = revertFixLocalIncludes(data)
447        data = revertFixIncludes(data)
448        return data
449
450    def convert(self, src, dst):
451        sconverter = super(FromRTEMSToFreeBSDSourceConverter, self)
452        sconverter.convert(src, dst, hasSource = False, sourceFilter = self.sourceFilter)
453
454#
455# Compose a path based for the various parts of the source tree.
456#
457class PathComposer(object):
458    def composeFreeBSDPath(self, path):
459        return path
460
461    def composeRTEMSPath(self, path, prefix):
462        return os.path.join(prefix, path)
463
464class FreeBSDPathComposer(PathComposer):
465    def composeFreeBSDPath(self, path):
466        return os.path.join(FreeBSD_DIR, path)
467
468    def composeRTEMSPath(self, path, prefix):
469        return os.path.join(prefix, 'freebsd', path)
470
471class RTEMSPathComposer(PathComposer):
472    def composeFreeBSDPath(self, path):
473        return path
474
475    def composeRTEMSPath(self, path, prefix):
476        return os.path.join(prefix, 'rtemsbsd', path)
477
478class CPUDependentPathComposer(FreeBSDPathComposer):
479    def composeRTEMSPath(self, path, prefix):
480        path = super(CPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
481        path = mapCPUDependentPath(path)
482        return path
483
484class TargetSourceCPUDependentPathComposer(CPUDependentPathComposer):
485    def __init__(self, targetCPU, sourceCPU):
486        self.targetCPU = targetCPU
487        self.sourceCPU = sourceCPU
488
489    def composeRTEMSPath(self, path, prefix):
490        path = super(TargetSourceCPUDependentPathComposer, self).composeRTEMSPath(path, prefix)
491        path = path.replace(self.sourceCPU, self.targetCPU)
492        return path
493
494class BuildSystemFragmentComposer(object):
495    def __init__(self, includes = None):
496        if type(includes) is not list:
497            self.includes = [includes]
498        else:
499            self.includes = includes
500
501    def compose(self, path):
502        return ''
503
504#
505# File - a file in the source we move backwards and forwards.
506#
507class File(object):
508    def __init__(self, path, pathComposer,
509                 forwardConverter, reverseConverter, buildSystemComposer):
510        if verbose(verboseMoreDetail):
511            print("FILE: %-50s F:%-45s R:%-45s" % \
512                  (path,
513                   forwardConverter.__class__.__name__,
514                   reverseConverter.__class__.__name__))
515        self.path = path
516        self.pathComposer = pathComposer
517        self.freebsdPath = self.pathComposer.composeFreeBSDPath(self.path)
518        self.rtemsPath = self.pathComposer.composeRTEMSPath(self.path, RTEMS_DIR)
519        self.forwardConverter = forwardConverter
520        self.reverseConverter = reverseConverter
521        self.buildSystemComposer = buildSystemComposer
522
523    def processSource(self, forward):
524        if forward:
525            if verbose(verboseDetail):
526                print("process source: %s => %s" % (self.freebsdPath, self.rtemsPath))
527            self.forwardConverter.convert(self.freebsdPath, self.rtemsPath)
528        else:
529            if verbose(verboseDetail):
530                print("process source: %s => %s converter:%s" % \
531                      (self.rtemsPath, self.freebsdPath, self.reverseConverter.__class__.__name__))
532            self.reverseConverter.convert(self.rtemsPath, self.freebsdPath)
533
534    def getFragment(self):
535        return self.buildSystemComposer.compose(self.pathComposer.composeRTEMSPath(self.path, ''))
536
537#
538# Module - logical group of related files we can perform actions on
539#
540class Module:
541    def __init__(self, name):
542        self.name = name
543        self.conditionalOn = "none"
544        self.files = []
545        self.cpuDependentSourceFiles = {}
546        self.dependencies = []
547
548    def initCPUDependencies(self, cpu):
549        if cpu not in self.cpuDependentSourceFiles:
550            self.cpuDependentSourceFiles[cpu] = []
551
552    def processSource(self, direction):
553        if verbose(verboseDetail):
554            print("process module: %s" % (self.name))
555        for f in self.files:
556            f.processSource(direction)
557        for cpu, files in self.cpuDependentSourceFiles.items():
558            for f in files:
559                f.processSource(direction)
560
561    def addFiles(self, newFiles, buildSystemComposer = BuildSystemFragmentComposer()):
562        files = []
563        for newFile in newFiles:
564            assertFile(newFile)
565            files += [File(newFile, composers, buildSystemComposer)]
566        return files
567
568    def addFile(self, f):
569        self.files += [f]
570
571    def addFiles(self, newFiles,
572                 pathComposer, fromFreeBSDToRTEMSConverter, fromRTEMSToFreeBSDConverter,
573                 assertFile, buildSystemComposer = BuildSystemFragmentComposer()):
574        files = []
575        for newFile in newFiles:
576            assertFile(newFile)
577            files += [File(newFile, pathComposer, fromFreeBSDToRTEMSConverter,
578                           fromRTEMSToFreeBSDConverter, buildSystemComposer)]
579        return files
580
581    def addKernelSpaceHeaderFiles(self, files):
582        self.files += self.addFiles(files,
583                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
584                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
585
586    def addUserSpaceHeaderFiles(self, files):
587        self.files += self.addFiles(files,
588                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSUserSpaceHeaderConverter(),
589                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
590
591    def addRTEMSHeaderFiles(self, files):
592        self.files += self.addFiles(files, RTEMSPathComposer(),
593                                    NoConverter(), NoConverter(), assertHeaderFile)
594
595    def addCPUDependentHeaderFiles(self, files):
596        self.files += self.addFiles(files,
597                                    CPUDependentPathComposer(), FromFreeBSDToRTEMSHeaderConverter(),
598                                    FromRTEMSToFreeBSDHeaderConverter(), assertHeaderFile)
599
600    def addTargetSourceCPUDependentHeaderFiles(self, targetCPUs, sourceCPU, files):
601        for cpu in targetCPUs:
602            self.files += self.addFiles(files,
603                                        TargetSourceCPUDependentPathComposer(cpu, sourceCPU),
604                                        FromFreeBSDToRTEMSHeaderConverter(),
605                                        NoConverter(), assertHeaderFile)
606
607    def addSourceFiles(self, files, sourceFileFragmentComposer):
608        self.files += self.addFiles(files,
609                                    PathComposer(), NoConverter(), NoConverter(), assertSourceFile,
610                                    sourceFileFragmentComposer)
611
612    def addKernelSpaceSourceFiles(self, files, sourceFileFragmentComposer):
613        self.files += self.addFiles(files,
614                                    FreeBSDPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
615                                    FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
616                                    sourceFileFragmentComposer)
617
618    def addUserSpaceSourceFiles(self, files, sourceFileFragmentComposer):
619        self.files += self.addFiles(files,
620                                    FreeBSDPathComposer(),
621                                    FromFreeBSDToRTEMSUserSpaceSourceConverter(),
622                                    FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
623                                    sourceFileFragmentComposer)
624
625    def addRTEMSSourceFiles(self, files, sourceFileFragmentComposer):
626        self.files += self.addFiles(files,
627                                    RTEMSPathComposer(), NoConverter(), NoConverter(),
628                                    assertSourceFile, sourceFileFragmentComposer)
629
630    def addCPUDependentSourceFiles(self, cpus, files, sourceFileFragmentComposer):
631        for cpu in cpus:
632            self.initCPUDependencies(cpu)
633            self.cpuDependentSourceFiles[cpu] += \
634                self.addFiles(files,
635                              CPUDependentPathComposer(), FromFreeBSDToRTEMSSourceConverter(),
636                              FromRTEMSToFreeBSDSourceConverter(), assertSourceFile,
637                              sourceFileFragmentComposer)
638
639    def addTest(self, testFragementComposer):
640        self.files += [File(testFragementComposer.testName,
641                            PathComposer(), NoConverter(), NoConverter(),
642                            testFragementComposer)]
643
644    def addDependency(self, dep):
645        self.dependencies += [dep]
646
647#
648# Manager - a collection of modules.
649#
650class ModuleManager:
651    def __init__(self):
652        self.modules = {}
653        self.generator = {}
654        self.setGenerators()
655
656    def __getitem__(self, key):
657        if key not in self.modules:
658            raise KeyError('module %s not found' % (key))
659        return self.modules[key]
660
661    def getModules(self):
662        return sorted(self.modules.keys())
663
664    def addModule(self, module):
665        self.modules[module.name] = module
666
667    def processSource(self, direction):
668        if verbose(verboseDetail):
669            print("process modules:")
670        for m in sorted(self.modules):
671            self.modules[m].processSource(direction)
Note: See TracBrowser for help on using the repository browser.