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