Changeset a35b458 in mainline for tools


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
tools
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • tools/autogen.py

    r3061bc1 ra35b458  
    8585                        code = code + ("\temit_constant(%s_%s_ITEM_SIZE, sizeof(%s));\n" %
    8686                            (struct['name'].upper(), member['name'].upper(), member['type']))
    87                        
     87
    8888        return code
    8989
     
    113113        """ % (generate_includes(struct), generate_struct(struct),
    114114            generate_probes(struct), name.upper(), typename)
    115        
     115
    116116        return code
    117117
     
    159159                pairs = pairs + [res.group(1, 3)]
    160160        return pairs
    161        
     161
    162162
    163163def run():
  • tools/autotool.py

    r3061bc1 ra35b458  
    9393def read_config(fname, config):
    9494        "Read HelenOS build configuration"
    95        
     95
    9696        inf = open(fname, 'r')
    97        
     97
    9898        for line in inf:
    9999                res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
    100100                if (res):
    101101                        config[res.group(1)] = res.group(2)
    102        
     102
    103103        inf.close()
    104104
    105105def print_error(msg):
    106106        "Print a bold error message"
    107        
     107
    108108        sys.stderr.write("\n")
    109109        sys.stderr.write("######################################################################\n")
     
    113113        sys.stderr.write("######################################################################\n")
    114114        sys.stderr.write("\n")
    115        
     115
    116116        sys.exit(1)
    117117
    118118def print_warning(msg):
    119119        "Print a bold error message"
    120        
     120
    121121        sys.stderr.write("\n")
    122122        sys.stderr.write("######################################################################\n")
     
    126126        sys.stderr.write("######################################################################\n")
    127127        sys.stderr.write("\n")
    128        
     128
    129129        time.sleep(5)
    130130
    131131def sandbox_enter():
    132132        "Create a temporal sandbox directory for running tests"
    133        
     133
    134134        if (os.path.exists(SANDBOX)):
    135135                if (os.path.isdir(SANDBOX)):
     
    141141                        print_error(["Please inspect and remove unexpected directory,",
    142142                                     "entry \"%s\"." % SANDBOX])
    143        
     143
    144144        try:
    145145                os.mkdir(SANDBOX)
    146146        except:
    147147                print_error(["Unable to create sandbox directory \"%s\"." % SANDBOX])
    148        
     148
    149149        owd = os.getcwd()
    150150        os.chdir(SANDBOX)
    151        
     151
    152152        return owd
    153153
    154154def sandbox_leave(owd):
    155155        "Leave the temporal sandbox directory"
    156        
     156
    157157        os.chdir(owd)
    158158
    159159def check_config(config, key):
    160160        "Check whether the configuration key exists"
    161        
     161
    162162        if (not key in config):
    163163                print_error(["Build configuration of HelenOS does not contain %s." % key,
     
    167167def check_common(common, key):
    168168        "Check whether the common key exists"
    169        
     169
    170170        if (not key in common):
    171171                print_error(["Failed to determine the value %s." % key,
     
    178178        target = None
    179179        cc_args = []
    180        
     180
    181181        if (config['PLATFORM'] == "abs32le"):
    182182                check_config(config, "CROSS_TARGET")
    183183                platform = config['CROSS_TARGET']
    184                
     184
    185185                if (config['CROSS_TARGET'] == "arm32"):
    186186                        gnu_target = "arm-linux-gnueabi"
    187187                        helenos_target = "arm-helenos-gnueabi"
    188                
     188
    189189                if (config['CROSS_TARGET'] == "ia32"):
    190190                        gnu_target = "i686-pc-linux-gnu"
    191191                        helenos_target = "i686-pc-helenos"
    192                
     192
    193193                if (config['CROSS_TARGET'] == "mips32"):
    194194                        cc_args.append("-mabi=32")
    195195                        gnu_target = "mipsel-linux-gnu"
    196196                        helenos_target = "mipsel-helenos"
    197        
     197
    198198        if (config['PLATFORM'] == "amd64"):
    199199                platform = config['PLATFORM']
    200200                gnu_target = "amd64-unknown-elf"
    201201                helenos_target = "amd64-helenos"
    202        
     202
    203203        if (config['PLATFORM'] == "arm32"):
    204204                platform = config['PLATFORM']
    205205                gnu_target = "arm-linux-gnueabi"
    206206                helenos_target = "arm-helenos-gnueabi"
    207        
     207
    208208        if (config['PLATFORM'] == "ia32"):
    209209                platform = config['PLATFORM']
    210210                gnu_target = "i686-pc-linux-gnu"
    211211                helenos_target = "i686-pc-helenos"
    212        
     212
    213213        if (config['PLATFORM'] == "ia64"):
    214214                platform = config['PLATFORM']
    215215                gnu_target = "ia64-pc-linux-gnu"
    216216                helenos_target = "ia64-pc-helenos"
    217        
     217
    218218        if (config['PLATFORM'] == "mips32"):
    219219                check_config(config, "MACHINE")
    220220                cc_args.append("-mabi=32")
    221                
     221
    222222                if ((config['MACHINE'] == "msim") or (config['MACHINE'] == "lmalta")):
    223223                        platform = config['PLATFORM']
    224224                        gnu_target = "mipsel-linux-gnu"
    225225                        helenos_target = "mipsel-helenos"
    226                
     226
    227227                if ((config['MACHINE'] == "bmalta")):
    228228                        platform = "mips32eb"
    229229                        gnu_target = "mips-linux-gnu"
    230230                        helenos_target = "mips-helenos"
    231        
     231
    232232        if (config['PLATFORM'] == "mips64"):
    233233                check_config(config, "MACHINE")
    234234                cc_args.append("-mabi=64")
    235                
     235
    236236                if (config['MACHINE'] == "msim"):
    237237                        platform = config['PLATFORM']
    238238                        gnu_target = "mips64el-linux-gnu"
    239239                        helenos_target = "mips64el-helenos"
    240        
     240
    241241        if (config['PLATFORM'] == "ppc32"):
    242242                platform = config['PLATFORM']
    243243                gnu_target = "ppc-linux-gnu"
    244244                helenos_target = "ppc-helenos"
    245        
     245
    246246        if (config['PLATFORM'] == "riscv64"):
    247247                platform = config['PLATFORM']
    248248                gnu_target = "riscv64-unknown-linux-gnu"
    249249                helenos_target = "riscv64-helenos"
    250        
     250
    251251        if (config['PLATFORM'] == "sparc64"):
    252252                platform = config['PLATFORM']
    253253                gnu_target = "sparc64-linux-gnu"
    254254                helenos_target = "sparc64-helenos"
    255        
     255
    256256        if (config['COMPILER'] == "gcc_helenos"):
    257257                target = helenos_target
    258258        else:
    259259                target = gnu_target
    260        
     260
    261261        return (platform, cc_args, target)
    262262
    263263def check_app(args, name, details):
    264264        "Check whether an application can be executed"
    265        
     265
    266266        try:
    267267                sys.stderr.write("Checking for %s ... " % args[0])
     
    273273                             "Execution of \"%s\" has failed. Please make sure that it" % " ".join(args),
    274274                             "is installed in your system (%s)." % details])
    275        
     275
    276276        sys.stderr.write("ok\n")
    277277
    278278def check_app_alternatives(alts, args, name, details):
    279279        "Check whether an application can be executed (use several alternatives)"
    280        
     280
    281281        tried = []
    282282        found = None
    283        
     283
    284284        for alt in alts:
    285285                working = True
    286286                cmdline = [alt] + args
    287287                tried.append(" ".join(cmdline))
    288                
     288
    289289                try:
    290290                        sys.stderr.write("Checking for %s ... " % alt)
     
    293293                        sys.stderr.write("failed\n")
    294294                        working = False
    295                
     295
    296296                if (working):
    297297                        sys.stderr.write("ok\n")
    298298                        found = alt
    299299                        break
    300        
     300
    301301        if (found is None):
    302302                print_error(["%s is missing." % name,
     
    306306                             "",
    307307                             "The following alternatives were tried:"] + tried)
    308        
     308
    309309        return found
    310310
    311311def check_clang(path, prefix, common, details):
    312312        "Check for clang"
    313        
     313
    314314        common['CLANG'] = "%sclang" % prefix
    315        
     315
    316316        if (not path is None):
    317317                common['CLANG'] = "%s/%s" % (path, common['CLANG'])
    318        
     318
    319319        check_app([common['CLANG'], "--version"], "clang", details)
    320320
    321321def check_gcc(path, prefix, common, details):
    322322        "Check for GCC"
    323        
     323
    324324        common['GCC'] = "%sgcc" % prefix
    325        
     325
    326326        if (not path is None):
    327327                common['GCC'] = "%s/%s" % (path, common['GCC'])
    328        
     328
    329329        check_app([common['GCC'], "--version"], "GNU GCC", details)
    330330
    331331def check_binutils(path, prefix, common, details):
    332332        "Check for binutils toolchain"
    333        
     333
    334334        common['AS'] = "%sas" % prefix
    335335        common['LD'] = "%sld" % prefix
     
    338338        common['OBJDUMP'] = "%sobjdump" % prefix
    339339        common['STRIP'] = "%sstrip" % prefix
    340        
     340
    341341        if (not path is None):
    342342                for key in ["AS", "LD", "AR", "OBJCOPY", "OBJDUMP", "STRIP"]:
    343343                        common[key] = "%s/%s" % (path, common[key])
    344        
     344
    345345        check_app([common['AS'], "--version"], "GNU Assembler", details)
    346346        check_app([common['LD'], "--version"], "GNU Linker", details)
     
    352352def check_python():
    353353        "Check for Python dependencies"
    354        
     354
    355355        try:
    356356                sys.stderr.write("Checking for PyYAML ... ")
     
    361361                             "Please make sure that it is installed in your",
    362362                             "system (usually part of PyYAML package)."])
    363        
     363
    364364        sys.stderr.write("ok\n")
    365365
    366366def decode_value(value):
    367367        "Decode integer value"
    368        
     368
    369369        base = 10
    370        
     370
    371371        if ((value.startswith('$')) or (value.startswith('#'))):
    372372                value = value[1:]
    373        
     373
    374374        if (value.startswith('0x')):
    375375                value = value[2:]
    376376                base = 16
    377        
     377
    378378        return int(value, base)
    379379
    380380def probe_compiler(common, typesizes):
    381381        "Generate, compile and parse probing source"
    382        
     382
    383383        check_common(common, "CC")
    384        
     384
    385385        outf = open(PROBE_SOURCE, 'w')
    386386        outf.write(PROBE_HEAD)
    387        
     387
    388388        for typedef in typesizes:
    389389                if 'def' in typedef:
     
    392392                if 'def' in typedef:
    393393                        outf.write("#endif\n")
    394        
     394
    395395        outf.write(PROBE_TAIL)
    396396        outf.close()
    397        
     397
    398398        args = common['CC_AUTOGEN'].split(' ')
    399399        args.extend(["-S", "-o", PROBE_OUTPUT, PROBE_SOURCE])
    400        
     400
    401401        try:
    402402                sys.stderr.write("Checking compiler properties ... ")
     
    406406                print_error(["Error executing \"%s\"." % " ".join(args),
    407407                             "Make sure that the compiler works properly."])
    408        
     408
    409409        if (not os.path.isfile(PROBE_OUTPUT)):
    410410                sys.stderr.write("failed\n")
     
    415415                             output[0],
    416416                             output[1]])
    417        
     417
    418418        sys.stderr.write("ok\n")
    419        
     419
    420420        inf = open(PROBE_OUTPUT, 'r')
    421421        lines = inf.readlines()
    422422        inf.close()
    423        
     423
    424424        builtins = {}
    425        
     425
    426426        for j in range(len(lines)):
    427427                tokens = lines[j].strip().split("\t")
    428                
     428
    429429                if (len(tokens) > 0):
    430430                        if (tokens[0] == "AUTOTOOL_DECLARE"):
    431431                                if (len(tokens) < 8):
    432432                                        print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    433                                
     433
    434434                                category = tokens[1]
    435435                                tag = tokens[2]
     
    439439                                size = tokens[6]
    440440                                compatible = tokens[7]
    441                                
     441
    442442                                try:
    443443                                        compatible_int = decode_value(compatible)
     
    445445                                except:
    446446                                        print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    447                                
     447
    448448                                if (compatible_int == 1):
    449449                                        builtins[tag] = {
     
    454454                                                'size': size_int,
    455455                                        }
    456        
     456
    457457        for typedef in typesizes:
    458458                if not typedef['tag'] in builtins:
     
    461461                if 'sname' in typedef:
    462462                        builtins[typedef['tag']]['sname'] = typedef['sname']
    463        
     463
    464464        return builtins
    465465
     
    490490def detect_sizes(probe):
    491491        "Detect properties of builtin types"
    492        
     492
    493493        macros = {}
    494        
     494
    495495        for type in probe.values():
    496496                macros['__SIZEOF_%s__' % type['tag']] = type['size']
    497                
     497
    498498                if ('sname' in type):
    499499                        macros['__%s_TYPE__'  % type['sname']] = type['name']
     
    502502                        macros['__%s_C_SUFFIX__' % type['sname']] = get_suffix(type)
    503503                        macros['__%s_MAX__' % type['sname']] = "%d%s" % (get_max(type), get_suffix(type))
    504        
     504
    505505        if (probe['SIZE_T']['sign'] != 'unsigned'):
    506506                print_error(['The type size_t is not unsigned.', COMPILER_FAIL])
    507        
     507
    508508        return macros
    509509
    510510def create_makefile(mkname, common):
    511511        "Create makefile output"
    512        
     512
    513513        outmk = open(mkname, 'w')
    514        
     514
    515515        outmk.write('#########################################\n')
    516516        outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
    517517        outmk.write('## Generated by: tools/autotool.py     ##\n')
    518518        outmk.write('#########################################\n\n')
    519        
     519
    520520        for key, value in common.items():
    521521                if (type(value) is list):
     
    523523                else:
    524524                        outmk.write('%s = %s\n' % (key, value))
    525        
     525
    526526        outmk.close()
    527527
    528528def create_header(hdname, macros):
    529529        "Create header output"
    530        
     530
    531531        outhd = open(hdname, 'w')
    532        
     532
    533533        outhd.write('/***************************************\n')
    534534        outhd.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')
    535535        outhd.write(' * Generated by: tools/autotool.py     *\n')
    536536        outhd.write(' ***************************************/\n\n')
    537        
     537
    538538        outhd.write('#ifndef %s\n' % GUARD)
    539539        outhd.write('#define %s\n\n' % GUARD)
    540        
     540
    541541        for macro in sorted(macros):
    542542                outhd.write('#ifndef %s\n' % macro)
    543543                outhd.write('#define %s  %s\n' % (macro, macros[macro]))
    544544                outhd.write('#endif\n\n')
    545        
     545
    546546        outhd.write('\n#endif\n')
    547547        outhd.close()
     
    550550        config = {}
    551551        common = {}
    552        
     552
    553553        # Read and check configuration
    554554        if os.path.exists(CONFIG):
     
    558558                             "configuration phase of HelenOS build went OK. Try running",
    559559                             "\"make config\" again."])
    560        
     560
    561561        check_config(config, "PLATFORM")
    562562        check_config(config, "COMPILER")
    563563        check_config(config, "BARCH")
    564        
     564
    565565        # Cross-compiler prefix
    566566        if ('CROSS_PREFIX' in os.environ):
     
    568568        else:
    569569                cross_prefix = "/usr/local/cross"
    570        
     570
    571571        # HelenOS cross-compiler prefix
    572572        if ('CROSS_HELENOS_PREFIX' in os.environ):
     
    574574        else:
    575575                cross_helenos_prefix = "/usr/local/cross-helenos"
    576        
     576
    577577        # Prefix binutils tools on Solaris
    578578        if (os.uname()[0] == "SunOS"):
     
    580580        else:
    581581                binutils_prefix = ""
    582        
     582
    583583        owd = sandbox_enter()
    584        
     584
    585585        try:
    586586                # Common utilities
     
    593593                check_app(["make", "--version"], "Make utility", "preferably GNU Make")
    594594                check_app(["unzip"], "unzip utility", "usually part of zip/unzip utilities")
    595                
     595
    596596                platform, cc_args, target = get_target(config)
    597                
     597
    598598                if (platform is None) or (target is None):
    599599                        print_error(["Unsupported compiler target.",
    600600                                     "Please contact the developers of HelenOS."])
    601                
     601
    602602                path = "%s/%s/bin" % (cross_prefix, target)
    603                
     603
    604604                # Compatibility with earlier toolchain paths.
    605605                if not os.path.exists(path):
     
    614614                                        print_error(["Toolchain for target is not installed, or CROSS_PREFIX is not set correctly."])
    615615                                path = "%s/%s/bin" % (cross_prefix, platform)
    616                
     616
    617617                common['TARGET'] = target
    618618                prefix = "%s-" % target
    619                
     619
    620620                # Compiler
    621621                if (config['COMPILER'] == "gcc_cross" or config['COMPILER'] == "gcc_helenos"):
    622622                        check_gcc(path, prefix, common, PACKAGE_CROSS)
    623623                        check_binutils(path, prefix, common, PACKAGE_CROSS)
    624                        
     624
    625625                        check_common(common, "GCC")
    626626                        common['CC'] = " ".join([common['GCC']] + cc_args)
    627627                        common['CC_AUTOGEN'] = common['CC']
    628                
     628
    629629                if (config['COMPILER'] == "gcc_native"):
    630630                        check_gcc(None, "", common, PACKAGE_GCC)
    631631                        check_binutils(None, binutils_prefix, common, PACKAGE_BINUTILS)
    632                        
     632
    633633                        check_common(common, "GCC")
    634634                        common['CC'] = common['GCC']
    635635                        common['CC_AUTOGEN'] = common['CC']
    636                
     636
    637637                if (config['COMPILER'] == "clang"):
    638638                        check_binutils(path, prefix, common, PACKAGE_CROSS)
    639639                        check_clang(path, prefix, common, PACKAGE_CLANG)
    640                        
     640
    641641                        check_common(common, "CLANG")
    642642                        common['CC'] = " ".join([common['CLANG']] + cc_args)
    643643                        common['CC_AUTOGEN'] = common['CC'] + " -no-integrated-as"
    644                        
     644
    645645                        if (config['INTEGRATED_AS'] == "yes"):
    646646                                common['CC'] += " -integrated-as"
    647                        
     647
    648648                        if (config['INTEGRATED_AS'] == "no"):
    649649                                common['CC'] += " -no-integrated-as"
    650                
     650
    651651                check_python()
    652                
     652
    653653                # Platform-specific utilities
    654654                if ((config['BARCH'] == "amd64") or (config['BARCH'] == "ia32") or (config['BARCH'] == "ppc32") or (config['BARCH'] == "sparc64")):
     
    656656                        if common['GENISOIMAGE'] == 'xorriso':
    657657                                common['GENISOIMAGE'] += ' -as genisoimage'
    658                
     658
    659659                probe = probe_compiler(common,
    660660                        [
     
    675675                        ]
    676676                )
    677                
     677
    678678                macros = detect_sizes(probe)
    679                
     679
    680680        finally:
    681681                sandbox_leave(owd)
    682        
     682
    683683        common['AUTOGEN'] = "%s/autogen.py" % os.path.dirname(os.path.abspath(sys.argv[0]))
    684        
     684
    685685        create_makefile(MAKEFILE, common)
    686686        create_header(HEADER, macros)
    687        
     687
    688688        return 0
    689689
  • tools/checkers/clang.py

    r3061bc1 ra35b458  
    4646def clang(root, job):
    4747        "Run Clang on a jobfile"
    48        
     48
    4949        inname = os.path.join(root, job)
    50        
     50
    5151        if (not os.path.isfile(inname)):
    5252                print("Unable to open %s" % inname)
    5353                print("Did you run \"make precheck\" on the source tree?")
    5454                return False
    55        
     55
    5656        inf = open(inname, "r")
    5757        records = inf.read().splitlines()
    5858        inf.close()
    59        
     59
    6060        for record in records:
    6161                arg = jobfile.parse_arg(record)
    6262                if (not arg):
    6363                        return False
    64                
     64
    6565                if (len(arg) < 6):
    6666                        print("Not enough jobfile record arguments")
    6767                        return False
    68                
     68
    6969                srcfname = arg[0]
    7070                tgtfname = arg[1]
     
    7373                base = arg[4]
    7474                options = arg[5].split()
    75                
     75
    7676                srcfqname = os.path.join(base, srcfname)
    7777                if (not os.path.isfile(srcfqname)):
    7878                        print("Source %s not found" % srcfqname)
    7979                        return False
    80                
     80
    8181                # Only C files are interesting for us
    8282                if (tool != "cc"):
    8383                        continue
    84                
     84
    8585                args = ['clang', '-Qunused-arguments', '--analyze',
    8686                        '-Xanalyzer', '-analyzer-opt-analyze-headers',
     
    8888                args.extend(options)
    8989                args.extend(['-o', tgtfname, srcfname])
    90                
     90
    9191                cwd = os.getcwd()
    9292                os.chdir(base)
    9393                retval = subprocess.Popen(args).wait()
    9494                os.chdir(cwd)
    95                
     95
    9696                if (retval != 0):
    9797                        return False
    98                
     98
    9999        return True
    100100
     
    103103                usage(sys.argv[0])
    104104                return
    105        
     105
    106106        rootdir = os.path.abspath(sys.argv[1])
    107107        config = os.path.join(rootdir, "HelenOS.config")
    108        
     108
    109109        if (not os.path.isfile(config)):
    110110                print("%s not found." % config)
    111111                print("Please specify the path to HelenOS build tree root as the first argument.")
    112112                return
    113        
     113
    114114        for job in jobs:
    115115                if (not clang(rootdir, job)):
     
    117117                        print("Failed job: %s" % job)
    118118                        return
    119        
     119
    120120        print
    121121        print("All jobs passed")
  • tools/checkers/jobfile.py

    r3061bc1 ra35b458  
    3232def parse_arg(record):
    3333        "Parse jobfile line arguments"
    34        
     34
    3535        arg = []
    3636        i = 0
     
    3838        nil = True
    3939        inside = False
    40        
     40
    4141        while (i < len(record)):
    4242                if (inside):
     
    5656                                print("Unexpected '%s'" % record[i])
    5757                                return False
    58                
     58
    5959                i += 1
    60        
     60
    6161        if (not nil):
    6262                arg.append(current)
    63        
     63
    6464        return arg
  • tools/checkers/stanse.py

    r3061bc1 ra35b458  
    4747def stanse(root, job):
    4848        "Run Stanse on a jobfile"
    49        
     49
    5050        # Convert generic jobfile to Stanse-specific jobfile format
    51        
     51
    5252        inname = os.path.join(root, job)
    5353        outname = os.path.join(root, "_%s" % os.path.basename(job))
    54        
     54
    5555        if (not os.path.isfile(inname)):
    5656                print("Unable to open %s" % inname)
    5757                print("Did you run \"make precheck\" on the source tree?")
    5858                return False
    59        
     59
    6060        inf = open(inname, "r")
    6161        records = inf.read().splitlines()
    6262        inf.close()
    63        
     63
    6464        output = []
    6565        for record in records:
     
    6767                if (not arg):
    6868                        return False
    69                
     69
    7070                if (len(arg) < 6):
    7171                        print("Not enough jobfile record arguments")
    7272                        return False
    73                
     73
    7474                srcfname = arg[0]
    7575                tgtfname = arg[1]
     
    7878                base = arg[4]
    7979                options = arg[5]
    80                
     80
    8181                srcfqname = os.path.join(base, srcfname)
    8282                if (not os.path.isfile(srcfqname)):
    8383                        print("Source %s not found" % srcfqname)
    8484                        return False
    85                
     85
    8686                # Only C files are interesting for us
    8787                if (tool != "cc"):
    8888                        continue
    89                
     89
    9090                output.append([srcfname, tgtfname, base, options])
    91        
     91
    9292        outf = open(outname, "w")
    9393        for record in output:
    9494                outf.write("{%s},{%s},{%s},{%s}\n" % (record[0], record[1], record[2], record[3]))
    9595        outf.close()
    96        
     96
    9797        # Run Stanse
    98        
     98
    9999        retval = subprocess.Popen(['stanse', '--checker', 'ReachabilityChecker', '--jobfile', outname]).wait()
    100        
     100
    101101        # Cleanup
    102        
     102
    103103        os.remove(outname)
    104104        for record in output:
     
    106106                if (os.path.isfile(tmpfile)):
    107107                        os.remove(tmpfile)
    108        
     108
    109109        if (retval == 0):
    110110                return True
    111        
     111
    112112        return False
    113113
     
    116116                usage(sys.argv[0])
    117117                return
    118        
     118
    119119        rootdir = os.path.abspath(sys.argv[1])
    120120        config = os.path.join(rootdir, "HelenOS.config")
    121        
     121
    122122        if (not os.path.isfile(config)):
    123123                print("%s not found." % config)
    124124                print("Please specify the path to HelenOS build tree root as the first argument.")
    125125                return
    126        
     126
    127127        for job in jobs:
    128128                if (not stanse(rootdir, job)):
     
    130130                        print("Failed job: %s" % job)
    131131                        return
    132        
     132
    133133        print
    134134        print("All jobs passed")
  • tools/checkers/vcc.py

    r3061bc1 ra35b458  
    5353def cygpath(upath):
    5454        "Convert Unix (Cygwin) path to Windows path"
    55        
     55
    5656        return subprocess.Popen(['cygpath', '--windows', '--absolute', upath], stdout = subprocess.PIPE).communicate()[0].strip()
    5757
    5858def preprocess(srcfname, tmpfname, base, options):
    5959        "Preprocess source using GCC preprocessor and compatibility tweaks"
    60        
     60
    6161        global specification
    62        
     62
    6363        args = ['gcc', '-E']
    6464        args.extend(options.split())
    6565        args.extend(['-DCONFIG_VERIFY_VCC=1', srcfname])
    66        
     66
    6767        # Change working directory
    68        
     68
    6969        cwd = os.getcwd()
    7070        os.chdir(base)
    71        
     71
    7272        preproc = subprocess.Popen(args, stdout = subprocess.PIPE).communicate()[0]
    73        
     73
    7474        tmpf = open(tmpfname, "w")
    7575        tmpf.write(specification)
    76        
     76
    7777        for line in preproc.splitlines():
    78                
     78
    7979                # Ignore preprocessor directives
    80                
     80
    8181                if (line.startswith('#')):
    8282                        continue
    83                
     83
    8484                # Remove __attribute__((.*)) GCC extension
    85                
     85
    8686                line = re.sub(re_attribute, "", line)
    87                
     87
    8888                # Ignore unsupported __builtin_va_list type
    8989                # (a better solution replacing __builrin_va_list with
    9090                # an emulated implementation is needed)
    91                
     91
    9292                line = re.sub(re_va_list, "void *", line)
    93                
     93
    9494                tmpf.write("%s\n" % line)
    95        
     95
    9696        tmpf.close()
    97        
     97
    9898        os.chdir(cwd)
    99        
     99
    100100        return True
    101101
    102102def vcc(vcc_path, root, job):
    103103        "Run Vcc on a jobfile"
    104        
     104
    105105        # Parse jobfile
    106        
     106
    107107        inname = os.path.join(root, job)
    108        
     108
    109109        if (not os.path.isfile(inname)):
    110110                print("Unable to open %s" % inname)
    111111                print("Did you run \"make precheck\" on the source tree?")
    112112                return False
    113        
     113
    114114        inf = open(inname, "r")
    115115        records = inf.read().splitlines()
    116116        inf.close()
    117        
     117
    118118        for record in records:
    119119                arg = jobfile.parse_arg(record)
    120120                if (not arg):
    121121                        return False
    122                
     122
    123123                if (len(arg) < 6):
    124124                        print("Not enough jobfile record arguments")
    125125                        return False
    126                
     126
    127127                srcfname = arg[0]
    128128                tgtfname = arg[1]
     
    131131                base = arg[4]
    132132                options = arg[5]
    133                
     133
    134134                srcfqname = os.path.join(base, srcfname)
    135135                if (not os.path.isfile(srcfqname)):
    136136                        print("Source %s not found" % srcfqname)
    137137                        return False
    138                
     138
    139139                tmpfname = "%s.preproc" % srcfname
    140140                tmpfqname = os.path.join(base, tmpfname)
    141                
     141
    142142                vccfname = "%s.i" % srcfname
    143143                vccfqname = os.path.join(base, vccfname);
    144                
     144
    145145                # Only C files are interesting for us
    146146                if (tool != "cc"):
    147147                        continue
    148                
     148
    149149                # Preprocess sources
    150                
     150
    151151                if (not preprocess(srcfname, tmpfname, base, options)):
    152152                        return False
    153                
     153
    154154                # Run Vcc
    155155                print(" -- %s --" % srcfname)
    156156                retval = subprocess.Popen([vcc_path, '/pointersize:32', '/newsyntax', cygpath(tmpfqname)]).wait()
    157                
     157
    158158                if (retval != 0):
    159159                        return False
    160                
     160
    161161                # Cleanup, but only if verification was successful
    162162                # (to be able to examine the preprocessed file)
    163                
     163
    164164                if (os.path.isfile(tmpfqname)):
    165165                        os.remove(tmpfqname)
    166166                        os.remove(vccfqname)
    167        
     167
    168168        return True
    169169
    170170def main():
    171171        global specification
    172        
     172
    173173        if (len(sys.argv) < 2):
    174174                usage(sys.argv[0])
    175175                return
    176        
     176
    177177        rootdir = os.path.abspath(sys.argv[1])
    178178        if (len(sys.argv) > 2):
     
    180180        else:
    181181                vcc_path = "/cygdrive/c/Program Files (x86)/Microsoft Research/Vcc/Binaries/vcc"
    182        
     182
    183183        if (not os.path.isfile(vcc_path)):
    184184                print("%s is not a binary." % vcc_path)
    185185                print("Please supply the full Cygwin path to Vcc as the second argument.")
    186186                return
    187        
     187
    188188        config = os.path.join(rootdir, "HelenOS.config")
    189        
     189
    190190        if (not os.path.isfile(config)):
    191191                print("%s not found." % config)
    192192                print("Please specify the path to HelenOS build tree root as the first argument.")
    193193                return
    194        
     194
    195195        specpath = os.path.join(rootdir, "tools/checkers/vcc.h")
    196196        if (not os.path.isfile(specpath)):
    197197                print("%s not found." % config)
    198198                return
    199        
     199
    200200        specfile = file(specpath, "r")
    201201        specification = specfile.read()
    202202        specfile.close()
    203        
     203
    204204        for job in jobs:
    205205                if (not vcc(vcc_path, rootdir, job)):
     
    207207                        print("Failed job: %s" % job)
    208208                        return
    209        
     209
    210210        print()
    211211        print("All jobs passed")
  • tools/config.py

    r3061bc1 ra35b458  
    4949def read_config(fname, config):
    5050        "Read saved values from last configuration run or a preset file"
    51        
     51
    5252        inf = open(fname, 'r')
    53        
     53
    5454        for line in inf:
    5555                res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
    5656                if res:
    5757                        config[res.group(1)] = res.group(2)
    58        
     58
    5959        inf.close()
    6060
    6161def check_condition(text, config, rules):
    6262        "Check that the condition specified on input line is True (only CNF and DNF is supported)"
    63        
     63
    6464        ctype = 'cnf'
    65        
     65
    6666        if (')|' in text) or ('|(' in text):
    6767                ctype = 'dnf'
    68        
     68
    6969        if ctype == 'cnf':
    7070                conds = text.split('&')
    7171        else:
    7272                conds = text.split('|')
    73        
     73
    7474        for cond in conds:
    7575                if cond.startswith('(') and cond.endswith(')'):
    7676                        cond = cond[1:-1]
    77                
     77
    7878                inside = check_inside(cond, config, ctype)
    79                
     79
    8080                if (ctype == 'cnf') and (not inside):
    8181                        return False
    82                
     82
    8383                if (ctype == 'dnf') and inside:
    8484                        return True
    85        
     85
    8686        if ctype == 'cnf':
    8787                return True
    88        
     88
    8989        return False
    9090
    9191def check_inside(text, config, ctype):
    9292        "Check for condition"
    93        
     93
    9494        if ctype == 'cnf':
    9595                conds = text.split('|')
    9696        else:
    9797                conds = text.split('&')
    98        
     98
    9999        for cond in conds:
    100100                res = re.match(r'^(.*?)(!?=)(.*)$', cond)
    101101                if not res:
    102102                        raise RuntimeError("Invalid condition: %s" % cond)
    103                
     103
    104104                condname = res.group(1)
    105105                oper = res.group(2)
    106106                condval = res.group(3)
    107                
     107
    108108                if not condname in config:
    109109                        varval = ''
     
    112112                        if (varval == '*'):
    113113                                varval = 'y'
    114                
     114
    115115                if ctype == 'cnf':
    116116                        if (oper == '=') and (condval == varval):
    117117                                return True
    118                
     118
    119119                        if (oper == '!=') and (condval != varval):
    120120                                return True
     
    122122                        if (oper == '=') and (condval != varval):
    123123                                return False
    124                        
     124
    125125                        if (oper == '!=') and (condval == varval):
    126126                                return False
    127        
     127
    128128        if ctype == 'cnf':
    129129                return False
    130        
     130
    131131        return True
    132132
    133133def parse_rules(fname, rules):
    134134        "Parse rules file"
    135        
     135
    136136        inf = open(fname, 'r')
    137        
     137
    138138        name = ''
    139139        choices = []
    140        
     140
    141141        for line in inf:
    142                
     142
    143143                if line.startswith('!'):
    144144                        # Ask a question
    145145                        res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)
    146                        
     146
    147147                        if not res:
    148148                                raise RuntimeError("Weird line: %s" % line)
    149                        
     149
    150150                        cond = res.group(1)
    151151                        varname = res.group(2)
    152152                        vartype = res.group(3)
    153                        
     153
    154154                        rules.append((varname, vartype, name, choices, cond))
    155155                        name = ''
    156156                        choices = []
    157157                        continue
    158                
     158
    159159                if line.startswith('@'):
    160160                        # Add new line into the 'choices' array
    161161                        res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)
    162                        
     162
    163163                        if not res:
    164164                                raise RuntimeError("Bad line: %s" % line)
    165                        
     165
    166166                        choices.append((res.group(2), res.group(3)))
    167167                        continue
    168                
     168
    169169                if line.startswith('%'):
    170170                        # Name of the option
    171171                        name = line[1:].strip()
    172172                        continue
    173                
     173
    174174                if line.startswith('#') or (line == '\n'):
    175175                        # Comment or empty line
    176176                        continue
    177                
    178                
     177
     178
    179179                raise RuntimeError("Unknown syntax: %s" % line)
    180        
     180
    181181        inf.close()
    182182
    183183def yes_no(default):
    184184        "Return '*' if yes, ' ' if no"
    185        
     185
    186186        if default == 'y':
    187187                return '*'
    188        
     188
    189189        return ' '
    190190
    191191def subchoice(screen, name, choices, default):
    192192        "Return choice of choices"
    193        
     193
    194194        maxkey = 0
    195195        for key, val in choices:
     
    197197                if (length > maxkey):
    198198                        maxkey = length
    199        
     199
    200200        options = []
    201201        position = None
     
    204204                if (default) and (key == default):
    205205                        position = cnt
    206                
     206
    207207                options.append(" %-*s  %s " % (maxkey, key, val))
    208208                cnt += 1
    209        
     209
    210210        (button, value) = xtui.choice_window(screen, name, 'Choose value', options, position)
    211        
     211
    212212        if button == 'cancel':
    213213                return None
    214        
     214
    215215        return choices[value][0]
    216216
     
    228228def infer_verify_choices(config, rules):
    229229        "Infer and verify configuration values."
    230        
     230
    231231        for rule in rules:
    232232                varname, vartype, name, choices, cond = rule
    233                
     233
    234234                if cond and (not check_condition(cond, config, rules)):
    235235                        continue
    236                
     236
    237237                if not varname in config:
    238238                        value = None
    239239                else:
    240240                        value = config[varname]
    241                
     241
    242242                if not validate_rule_value(rule, value):
    243243                        value = None
    244                
     244
    245245                default = get_default_rule(rule)
    246                
     246
    247247                #
    248248                # If we don't have a value but we do have
     
    252252                        value = default
    253253                        config[varname] = default
    254                
     254
    255255                if not varname in config:
    256256                        return False
    257        
     257
    258258        return True
    259259
     
    275275        if start_index >= len(rules):
    276276                return True
    277        
     277
    278278        varname, vartype, name, choices, cond = rules[start_index]
    279279
     
    282282                if not check_condition(cond, config, rules):
    283283                        return random_choices(config, rules, start_index + 1)
    284        
     284
    285285        # Remember previous choices for backtracking
    286286        yes_no = 0
    287287        choices_indexes = range(0, len(choices))
    288288        random.shuffle(choices_indexes)
    289        
     289
    290290        # Remember current configuration value
    291291        old_value = None
     
    294294        except KeyError:
    295295                old_value = None
    296        
     296
    297297        # For yes/no choices, we ran the loop at most 2 times, for select
    298298        # choices as many times as there are options.
     
    320320                else:
    321321                        raise RuntimeError("Unknown variable type: %s" % vartype)
    322        
     322
    323323                config[varname] = value
    324                
     324
    325325                ok = random_choices(config, rules, start_index + 1)
    326326                if ok:
    327327                        return True
    328                
     328
    329329                try_counter = try_counter + 1
    330        
     330
    331331        # Restore the old value and backtrack
    332332        # (need to delete to prevent "ghost" variables that do not exist under
     
    335335        if old_value is None:
    336336                del config[varname]
    337        
     337
    338338        return random_choices(config, rules, start_index + 1)
    339        
     339
    340340
    341341## Get default value from a rule.
    342342def get_default_rule(rule):
    343343        varname, vartype, name, choices, cond = rule
    344        
     344
    345345        default = None
    346        
     346
    347347        if vartype == 'choice':
    348348                # If there is just one option, use it
     
    359359        else:
    360360                raise RuntimeError("Unknown variable type: %s" % vartype)
    361        
     361
    362362        return default
    363363
     
    371371def get_rule_option(rule, value):
    372372        varname, vartype, name, choices, cond = rule
    373        
     373
    374374        option = None
    375        
     375
    376376        if vartype == 'choice':
    377377                # If there is just one option, don't ask
     
    391391        else:
    392392                raise RuntimeError("Unknown variable type: %s" % vartype)
    393        
     393
    394394        return option
    395395
     
    403403def validate_rule_value(rule, value):
    404404        varname, vartype, name, choices, cond = rule
    405        
     405
    406406        if value == None:
    407407                return True
    408        
     408
    409409        if vartype == 'choice':
    410410                if not value in [choice[0] for choice in choices]:
     
    424424        else:
    425425                raise RuntimeError("Unknown variable type: %s" % vartype)
    426        
     426
    427427        return True
    428428
    429429def preprocess_config(config, rules):
    430430        "Preprocess configuration"
    431        
     431
    432432        varname_mode = 'CONFIG_BFB_MODE'
    433433        varname_width = 'CONFIG_BFB_WIDTH'
    434434        varname_height = 'CONFIG_BFB_HEIGHT'
    435        
     435
    436436        if varname_mode in config:
    437437                mode = config[varname_mode].partition('x')
    438                
     438
    439439                config[varname_width] = mode[0]
    440440                rules.append((varname_width, 'choice', 'Default framebuffer width', None, None))
    441                
     441
    442442                config[varname_height] = mode[2]
    443443                rules.append((varname_height, 'choice', 'Default framebuffer height', None, None))
     
    445445def create_output(mkname, mcname, config, rules):
    446446        "Create output configuration"
    447        
     447
    448448        varname_strip = 'CONFIG_STRIP_REVISION_INFO'
    449449        strip_rev_info = (varname_strip in config) and (config[varname_strip] == 'y')
    450        
     450
    451451        if strip_rev_info:
    452452                timestamp_unix = int(0)
     
    454454                # TODO: Use commit timestamp instead of build time.
    455455                timestamp_unix = int(time.time())
    456        
     456
    457457        timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp_unix))
    458        
     458
    459459        sys.stderr.write("Fetching current revision identifier ... ")
    460        
     460
    461461        try:
    462462                version = subprocess.Popen(['git', 'log', '-1', '--pretty=%h'], stdout = subprocess.PIPE).communicate()[0].decode().strip()
     
    465465                version = None
    466466                sys.stderr.write("failed\n")
    467        
     467
    468468        if (not strip_rev_info) and (version is not None):
    469469                revision = version
    470470        else:
    471471                revision = None
    472        
     472
    473473        outmk = open(mkname, 'w')
    474474        outmc = open(mcname, 'w')
    475        
     475
    476476        outmk.write('#########################################\n')
    477477        outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
    478478        outmk.write('## Generated by: tools/config.py       ##\n')
    479479        outmk.write('#########################################\n\n')
    480        
     480
    481481        outmc.write('/***************************************\n')
    482482        outmc.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')
    483483        outmc.write(' * Generated by: tools/config.py       *\n')
    484484        outmc.write(' ***************************************/\n\n')
    485        
     485
    486486        defs = 'CONFIG_DEFS ='
    487        
     487
    488488        for varname, vartype, name, choices, cond in rules:
    489489                if cond and (not check_condition(cond, config, rules)):
    490490                        continue
    491                
     491
    492492                if not varname in config:
    493493                        value = ''
     
    496496                        if (value == '*'):
    497497                                value = 'y'
    498                
     498
    499499                outmk.write('# %s\n%s = %s\n\n' % (name, varname, value))
    500                
     500
    501501                if vartype in ["y", "n", "y/n", "n/y"]:
    502502                        if value == "y":
     
    506506                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, value, varname, value))
    507507                        defs += ' -D%s=%s -D%s_%s' % (varname, value, varname, value)
    508        
     508
    509509        if revision is not None:
    510510                outmk.write('REVISION = %s\n' % revision)
    511511                outmc.write('#define REVISION %s\n' % revision)
    512512                defs += ' "-DREVISION=%s"' % revision
    513        
     513
    514514        outmk.write('TIMESTAMP_UNIX = %d\n' % timestamp_unix)
    515515        outmc.write('#define TIMESTAMP_UNIX %d\n' % timestamp_unix)
    516516        defs += ' "-DTIMESTAMP_UNIX=%d"\n' % timestamp_unix
    517        
     517
    518518        outmk.write('TIMESTAMP = %s\n' % timestamp)
    519519        outmc.write('#define TIMESTAMP %s\n' % timestamp)
    520520        defs += ' "-DTIMESTAMP=%s"\n' % timestamp
    521        
     521
    522522        outmk.write(defs)
    523        
     523
    524524        outmk.close()
    525525        outmc.close()
     
    536536        opt2path = {}
    537537        cnt = 0
    538        
     538
    539539        # Look for profiles
    540540        for name in sorted_dir(root):
    541541                path = os.path.join(root, name)
    542542                canon = os.path.join(path, fname)
    543                
     543
    544544                if os.path.isdir(path) and os.path.exists(canon) and os.path.isfile(canon):
    545545                        subprofile = False
    546                        
     546
    547547                        # Look for subprofiles
    548548                        for subname in sorted_dir(path):
    549549                                subpath = os.path.join(path, subname)
    550550                                subcanon = os.path.join(subpath, fname)
    551                                
     551
    552552                                if os.path.isdir(subpath) and os.path.exists(subcanon) and os.path.isfile(subcanon):
    553553                                        subprofile = True
     
    555555                                        opt2path[cnt] = [name, subname]
    556556                                        cnt += 1
    557                        
     557
    558558                        if not subprofile:
    559559                                options.append(name)
    560560                                opt2path[cnt] = [name]
    561561                                cnt += 1
    562        
     562
    563563        (button, value) = xtui.choice_window(screen, 'Load preconfigured defaults', 'Choose configuration profile', options, None)
    564        
     564
    565565        if button == 'cancel':
    566566                return None
    567        
     567
    568568        return opt2path[value]
    569569
     
    576576        path = os.path.join(PRESETS_DIR, profile[0], MAKEFILE)
    577577        read_config(path, config)
    578        
     578
    579579        if len(profile) > 1:
    580580                path = os.path.join(PRESETS_DIR, profile[0], profile[1], MAKEFILE)
     
    588588def parse_profile_name(profile_name):
    589589        profile = []
    590        
     590
    591591        head, tail = os.path.split(profile_name)
    592592        if head != '':
    593593                profile.append(head)
    594        
     594
    595595        profile.append(tail)
    596596        return profile
     
    600600        config = {}
    601601        rules = []
    602        
     602
    603603        # Parse rules file
    604604        parse_rules(RULES_FILE, rules)
    605        
     605
    606606        # Input configuration file can be specified on command line
    607607        # otherwise configuration from previous run is used.
     
    611611        elif os.path.exists(MAKEFILE):
    612612                read_config(MAKEFILE, config)
    613        
     613
    614614        # Default mode: check values and regenerate configuration files
    615615        if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
     
    618618                        create_output(MAKEFILE, MACROS, config, rules)
    619619                        return 0
    620        
     620
    621621        # Hands-off mode: check values and regenerate configuration files,
    622622        # but no interactive fallback
     
    627627                        sys.stderr.write("Configuration error: No presets specified\n")
    628628                        return 2
    629                
     629
    630630                if (infer_verify_choices(config, rules)):
    631631                        preprocess_config(config, rules)
    632632                        create_output(MAKEFILE, MACROS, config, rules)
    633633                        return 0
    634                
     634
    635635                sys.stderr.write("Configuration error: The presets are ambiguous\n")
    636636                return 1
    637        
     637
    638638        # Check mode: only check configuration
    639639        if (len(sys.argv) >= 3) and (sys.argv[2] == 'check'):
     
    641641                        return 0
    642642                return 1
    643        
     643
    644644        # Random mode
    645645        if (len(sys.argv) == 3) and (sys.argv[2] == 'random'):
     
    653653                preprocess_config(config, rules)
    654654                create_output(MAKEFILE, MACROS, config, rules)
    655                
     655
    656656                return 0
    657        
     657
    658658        screen = xtui.screen_init()
    659659        try:
     
    661661                position = None
    662662                while True:
    663                        
     663
    664664                        # Cancel out all values which have to be deduced
    665665                        for varname, vartype, name, choices, cond in rules:
    666666                                if (vartype == 'y') and (varname in config) and (config[varname] == '*'):
    667667                                        config[varname] = None
    668                        
     668
    669669                        options = []
    670670                        opt2row = {}
    671671                        cnt = 1
    672                        
     672
    673673                        options.append("  --- Load preconfigured defaults ... ")
    674                        
     674
    675675                        for rule in rules:
    676676                                varname, vartype, name, choices, cond = rule
    677                                
     677
    678678                                if cond and (not check_condition(cond, config, rules)):
    679679                                        continue
    680                                
     680
    681681                                if varname == selname:
    682682                                        position = cnt
    683                                
     683
    684684                                if not varname in config:
    685685                                        value = None
    686686                                else:
    687687                                        value = config[varname]
    688                                
     688
    689689                                if not validate_rule_value(rule, value):
    690690                                        value = None
    691                                
     691
    692692                                default = get_default_rule(rule)
    693                                
     693
    694694                                #
    695695                                # If we don't have a value but we do have
     
    699699                                        value = default
    700700                                        config[varname] = default
    701                                
     701
    702702                                option = get_rule_option(rule, value)
    703703                                if option != None:
     
    705705                                else:
    706706                                        continue
    707                                
     707
    708708                                opt2row[cnt] = (varname, vartype, name, choices)
    709                                
     709
    710710                                cnt += 1
    711                        
     711
    712712                        if (position != None) and (position >= len(options)):
    713713                                position = None
    714                        
     714
    715715                        (button, value) = xtui.choice_window(screen, 'HelenOS configuration', 'Choose configuration option', options, position)
    716                        
     716
    717717                        if button == 'cancel':
    718718                                return 'Configuration canceled'
    719                        
     719
    720720                        if button == 'done':
    721721                                if (infer_verify_choices(config, rules)):
     
    724724                                        xtui.error_dialog(screen, 'Error', 'Some options have still undefined values. These options are marked with the "?" sign.')
    725725                                        continue
    726                        
     726
    727727                        if value == 0:
    728728                                profile = choose_profile(PRESETS_DIR, MAKEFILE, screen, config)
     
    731731                                position = 1
    732732                                continue
    733                        
     733
    734734                        position = None
    735735                        if not value in opt2row:
    736736                                raise RuntimeError("Error selecting value: %s" % value)
    737                        
     737
    738738                        (selname, seltype, name, choices) = opt2row[value]
    739                        
     739
    740740                        if not selname in config:
    741741                                value = None
    742742                        else:
    743743                                value = config[selname]
    744                        
     744
    745745                        if seltype == 'choice':
    746746                                config[selname] = subchoice(screen, name, choices, value)
     
    752752        finally:
    753753                xtui.screen_done(screen)
    754        
     754
    755755        preprocess_config(config, rules)
    756756        create_output(MAKEFILE, MACROS, config, rules)
  • tools/dest_build.py

    r3061bc1 ra35b458  
    4242def duplicate_tree(src_path, dest_path, current):
    4343        "Duplicate source directory tree in the destination path"
    44        
     44
    4545        for name in os.listdir(os.path.join(src_path, current)):
    4646                if name in exclude_names:
    4747                        next
    48                
     48
    4949                following = os.path.join(current, name)
    5050                src = os.path.join(src_path, following)
     
    5252                dest_parent = os.path.join(dest_path, current)
    5353                dest_stat = os.stat(src)
    54                
     54
    5555                # Create shadow directories
    5656                if stat.S_ISDIR(dest_stat.st_mode):
    5757                        if not os.path.exists(dest):
    5858                                os.mkdir(dest)
    59                        
     59
    6060                        if not os.path.isdir(dest):
    6161                                raise IOError(errno.ENOTDIR, "Destination path exists, but is not a directory", dest)
    62                        
     62
    6363                        duplicate_tree(src_path, dest_path, following)
    6464                else:
    6565                        # Compute the relative path from destination to source
    6666                        relative = os.path.relpath(src, dest_parent)
    67                        
     67
    6868                        # Create symlink
    6969                        if not os.path.exists(dest):
     
    7878                usage(sys.argv[0])
    7979                return 1
    80        
     80
    8181        # Source tree path
    8282        src_path = os.path.abspath(sys.argv[1])
     
    8484                print("<SRC_PATH> must be a directory")
    8585                return 2
    86        
     86
    8787        # Destination tree path
    8888        dest_path = os.path.abspath(sys.argv[2])
    8989        if not os.path.exists(dest_path):
    9090                os.mkdir(dest_path)
    91        
     91
    9292        if not os.path.isdir(dest_path):
    9393                print("<DEST_PATH> must be a directory")
    9494                return 3
    95        
     95
    9696        # Duplicate source directory tree
    9797        duplicate_tree(src_path, dest_path, "")
    98        
     98
    9999        # Run the build from the destination tree
    100100        os.chdir(dest_path)
    101101        args = ["make"]
    102102        args.extend(sys.argv[3:])
    103        
     103
    104104        return subprocess.Popen(args).wait()
    105105
  • tools/ew.py

    r3061bc1 ra35b458  
    7676def pc_options(guest_width):
    7777        opts = ''
    78        
     78
    7979        # Do not enable KVM if running 64 bits HelenOS
    8080        # on 32 bits host
     
    8282        if guest_width <= host_width and not is_override('nokvm'):
    8383                opts = opts + ' -enable-kvm'
    84        
     84
    8585        # Remove the leading space
    8686        return opts[1:]
     
    132132        if is_override('nohdd'):
    133133                return ''
    134        
     134
    135135        hdisk_mk()
    136        
     136
    137137        return ' -drive file=hdisk.img,index=0,media=disk,format=raw'
    138138
     
    208208        if (not 'audio' in cfg.keys()) or cfg['audio']:
    209209                cmdline += qemu_audio_options()
    210        
     210
    211211        if cfg['image'] == 'image.iso':
    212212                cmdline += ' -boot d -cdrom image.iso'
     
    328328def fail(platform, machine):
    329329        print("Cannot start emulation for the chosen configuration. (%s/%s)" % (platform, machine))
    330        
     330
    331331
    332332def run():
  • tools/imgutil.py

    r3061bc1 ra35b458  
    4040def align_up(size, alignment):
    4141        "Return size aligned up to alignment"
    42        
     42
    4343        if (size % alignment == 0):
    4444                return size
    45        
     45
    4646        return ((size // alignment) + 1) * alignment
    4747
    4848def count_up(size, alignment):
    4949        "Return units necessary to fit the size"
    50        
     50
    5151        if (size % alignment == 0):
    5252                return (size // alignment)
    53        
     53
    5454        return ((size // alignment) + 1)
    5555
    5656def num_of_trailing_bin_zeros(num):
    5757        "Return number of trailing zeros in binary representation"
    58        
     58
    5959        i = 0
    6060        if (num == 0): raise ValueError()
     
    6666def get_bit(number, n):
    6767        "Return True if n-th least-significant bit is set in the given number"
    68        
     68
    6969        return bool((number >> n) & 1)
    7070
    7171def set_bit(number, n):
    7272        "Return the number with n-th least-significant bit set"
    73        
     73
    7474        return number | (1 << n)
    7575
    7676class ItemToPack:
    7777        "Stores information about one directory item to be added to the image"
    78        
     78
    7979        def __init__(self, parent, name):
    8080                self.parent = parent
     
    8888def listdir_items(path):
    8989        "Return a list of items to be packed inside a fs image"
    90        
     90
    9191        for name in os.listdir(path):
    9292                if name in exclude_names:
    9393                        continue
    94                
     94
    9595                item = ItemToPack(path, name)
    96                
     96
    9797                if not (item.is_dir or item.is_file):
    9898                        continue
    99                
     99
    100100                yield item
    101101
    102102def chunks(item, chunk_size):
    103103        "Iterate contents of a file in chunks of a given size"
    104        
     104
    105105        inf = open(item.path, 'rb')
    106106        rd = 0
    107        
     107
    108108        while (rd < item.size):
    109109                data = bytes(inf.read(chunk_size))
    110110                yield data
    111111                rd += len(data)
    112        
     112
    113113        inf.close()
  • tools/jobfile.py

    r3061bc1 ra35b458  
    4444                usage(sys.argv[0])
    4545                return
    46        
     46
    4747        jobfname = sys.argv[1]
    4848        ccname = sys.argv[2]
     
    5353        options = " ".join(sys.argv[6:])
    5454        cwd = os.getcwd()
    55        
     55
    5656        if srcfname.endswith(".c"):
    5757                toolname = "cc"
    5858                category = "core"
    59        
     59
    6060        if srcfname.endswith(".s"):
    6161                toolname = "as"
    6262                category = "asm"
    63        
     63
    6464        if srcfname.endswith(".S"):
    6565                toolname = "as"
    6666                category = "asm/preproc"
    67        
     67
    6868        jobfile = open(jobfname, "a")
    6969        fcntl.lockf(jobfile, fcntl.LOCK_EX)
     
    7171        fcntl.lockf(jobfile, fcntl.LOCK_UN)
    7272        jobfile.close()
    73        
     73
    7474        # Run the compiler proper.
    7575        os.execvp(ccname, sys.argv[2:])
  • tools/mkarray.py

    r3061bc1 ra35b458  
    5757def main():
    5858        arg_check()
    59        
     59
    6060        if sys.argv[1] == "--deflate":
    6161                sys.argv.pop(1)
     
    6464        else:
    6565                compress = False
    66        
     66
    6767        dest = sys.argv[1]
    6868        label = sys.argv[2]
    6969        as_prolog = sys.argv[3]
    7070        section = sys.argv[4]
    71        
     71
    7272        timestamp = (1980, 1, 1, 0, 0, 0)
    73        
     73
    7474        header_ctx = []
    7575        desc_ctx = []
    7676        size_ctx = []
    7777        data_ctx = []
    78        
     78
    7979        src_cnt = 0
    80        
     80
    8181        archive = zipfile.ZipFile("%s.zip" % dest, "w", zipfile.ZIP_STORED)
    82        
     82
    8383        for src in sys.argv[5:]:
    8484                basename = os.path.basename(src)
    8585                plainname = os.path.splitext(basename)[0]
    8686                symbol = basename.replace(".", "_")
    87                
     87
    8888                print("%s -> %s" % (src, symbol))
    89                
     89
    9090                src_in = open(src, "rb")
    9191                src_data = src_in.read()
    9292                src_in.close()
    93                
     93
    9494                length = len(src_data)
    95                
     95
    9696                if compress:
    9797                        src_data = deflate(src_data)
     
    101101                else:
    102102                        src_fname = src
    103                
     103
    104104                if sys.version_info < (3,):
    105105                        src_data = bytearray(src_data)
    106                
     106
    107107                length_out = len(src_data)
    108                
     108
    109109                header_ctx.append("extern uint8_t %s[];" % symbol)
    110110                header_ctx.append("extern size_t %s_size;" % symbol)
    111                
     111
    112112                data_ctx.append(".globl %s" % symbol)
    113113                data_ctx.append(".balign 8")
     
    115115                data_ctx.append("%s:" % symbol)
    116116                data_ctx.append("\t.incbin \"%s\"\n" % src_fname)
    117                
     117
    118118                desc_field = []
    119119                desc_field.append("\t{")
     
    122122                desc_field.append("\t\t.size = %u," % length_out)
    123123                desc_field.append("\t\t.inflated = %u," % length)
    124                
     124
    125125                if compress:
    126126                        desc_field.append("\t\t.compressed = true")
    127127                else:
    128128                        desc_field.append("\t\t.compressed = false")
    129                
     129
    130130                desc_field.append("\t}")
    131                
     131
    132132                desc_ctx.append("\n".join(desc_field))
    133                
     133
    134134                size_ctx.append("size_t %s_size = %u;" % (symbol, length_out))
    135                
     135
    136136                src_cnt += 1
    137        
     137
    138138        data = ''
    139139        data += '/***************************************\n'
     
    160160        zipinfo = zipfile.ZipInfo("%s.h" % dest, timestamp)
    161161        archive.writestr(zipinfo, data)
    162        
     162
    163163        data = ''
    164164        data += '/***************************************\n'
     
    172172        zipinfo = zipfile.ZipInfo("%s.s" % dest, timestamp)
    173173        archive.writestr(zipinfo, data)
    174        
     174
    175175        data = ''
    176176        data += '/***************************************\n'
     
    187187        zipinfo = zipfile.ZipInfo("%s_desc.c" % dest, timestamp)
    188188        archive.writestr(zipinfo, data)
    189        
     189
    190190        archive.close()
    191191
  • tools/mkext2.py

    r3061bc1 ra35b458  
    7777        uint32_t rev_major            /* Major revision level */
    7878        padding[4] /* default reserved uid and gid */
    79        
     79
    8080        /* Following is for ext2 revision 1 only */
    8181        uint32_t first_inode
     
    130130        def __init__(self, filename, block_groups, blocks_per_group, inodes_per_group, block_size, inode_size, reserved_inode_count):
    131131                "Initialize the filesystem writer"
    132                
     132
    133133                outf = open(filename, "w+b")
    134134                # Set the correct size of the image, so that we can read arbitrary position
     
    172172                lpf_dir.add(self.root_inode.as_dirent('..'))
    173173                lpf_dir.finish()
    174        
     174
    175175        def init_gdt(self):
    176176                "Initialize block group descriptor table"
    177                
     177
    178178                self.superblock_positions = []
    179179                self.gdt = []
     
    202202                        gde.directory_inode_count = 0
    203203                        self.gdt.append(gde)
    204        
     204
    205205        def mark_block_cb(self, block):
    206206                "Called after a block has been allocated"
    207                
     207
    208208                self.gdt[block // self.blocks_per_group].free_block_count -= 1
    209        
     209
    210210        def mark_inode_cb(self, index, directory=False):
    211211                "Called after an inode has been allocated"
    212                
     212
    213213                index -= 1
    214214                gde = self.gdt[index // self.inodes_per_group]
     
    216216                if directory:
    217217                        gde.directory_inode_count += 1
    218        
     218
    219219        def seek_to_block(self, block, offset=0):
    220220                "Seek to offset bytes after the start of the given block"
    221                
     221
    222222                if offset < 0 or offset > self.block_size:
    223223                        raise Exception("Invalid in-block offset")
    224224                self.outf.seek(block * self.block_size + offset)
    225        
     225
    226226        def seek_to_inode(self, index):
    227227                "Seek to the start of the inode structure for the inode number index"
    228                
     228
    229229                index -= 1
    230230                if index < 0:
     
    235235                block = base_block + (offset // self.block_size)
    236236                self.seek_to_block(block, offset % self.block_size)
    237        
     237
    238238        def subtree_add(self, inode, parent_inode, dirpath, is_root=False):
    239239                "Recursively add files to the filesystem"
    240                
     240
    241241                dir_writer = DirWriter(inode)
    242242                dir_writer.add(inode.as_dirent('.'))
    243243                dir_writer.add(parent_inode.as_dirent('..'))
    244                
     244
    245245                if is_root:
    246246                        dir_writer.add(self.lost_plus_found.as_dirent('lost+found'))
     
    255255                                child_inode = Inode(self, newidx, Inode.TYPE_DIR)
    256256                                self.subtree_add(child_inode, inode, item.path)
    257                
     257
    258258                        dir_writer.add(child_inode.as_dirent(item.name))
    259259                        self.write_inode(child_inode)
    260260
    261261                dir_writer.finish()
    262        
     262
    263263        def write_inode(self, inode):
    264264                "Write inode information into the inode table"
    265                
     265
    266266                self.seek_to_inode(inode.index)
    267267                self.outf.write(inode.pack())
     
    269269        def write_gdt(self):
    270270                "Write group descriptor table at the current file position"
    271                
     271
    272272                for gde in self.gdt:
    273273                        data = bytes(gde.pack())
    274274                        self.outf.write(data)
    275275                        self.outf.seek(GDE_SIZE-len(data), os.SEEK_CUR)
    276        
     276
    277277        def write_superblock(self, block_group):
    278278                "Write superblock at the current position"
    279                
     279
    280280                sb = xstruct.create(STRUCT_SUPERBLOCK)
    281281                sb.total_inode_count = self.total_inode_count
     
    312312                sb.volume_name = 'HelenOS rdimage\0'
    313313                self.outf.write(bytes(sb.pack()))
    314        
     314
    315315        def write_all_metadata(self):
    316316                "Write superblocks, block group tables, block and inode bitmaps"
    317                
     317
    318318                bbpg = self.blocks_per_group // 8
    319319                bipg = self.inodes_per_group // 8
    320320                def window(arr, index, size):
    321321                        return arr[index * size:(index + 1) * size]
    322                
     322
    323323                for bg_index in xrange(len(self.gdt)):
    324324                        sbpos = self.superblock_positions[bg_index]
    325325                        sbblock = (sbpos + 1023) // self.block_size
    326326                        gde = self.gdt[bg_index]
    327                        
     327
    328328                        self.outf.seek(sbpos)
    329329                        self.write_superblock(bg_index)
    330                        
     330
    331331                        self.seek_to_block(sbblock+1)
    332332                        self.write_gdt()
    333                        
     333
    334334                        self.seek_to_block(gde.block_bitmap_block)
    335335                        self.outf.write(window(self.block_allocator.bitmap, bg_index, bbpg))
    336                        
     336
    337337                        self.seek_to_block(gde.inode_bitmap_block)
    338338                        self.outf.write(window(self.inode_allocator.bitmap, bg_index, bipg))
    339        
     339
    340340        def close(self):
    341341                "Write all remaining data to the filesystem and close the file"
    342                
     342
    343343                self.write_inode(self.root_inode)
    344344                self.write_inode(self.lost_plus_found)
     
    354354                self.bitmap = array.array('B', [0] * (count // 8))
    355355                self.mark_cb = None
    356        
     356
    357357        def __contains__(self, item):
    358358                "Check if the item is already used"
    359                
     359
    360360                bitidx = item - self.base
    361361                return get_bit(self.bitmap[bitidx // 8], bitidx % 8)
    362        
     362
    363363        def alloc(self, **options):
    364364                "Allocate a new item"
    365                
     365
    366366                while self.nextidx < self.count and (self.base + self.nextidx) in self:
    367367                        self.nextidx += 1
     
    372372                self.mark_used(item, **options)
    373373                return item
    374        
     374
    375375        def mark_used(self, item, **options):
    376376                "Mark the specified item as used"
    377                
     377
    378378                bitidx = item - self.base
    379379                if item in self:
     
    384384                if self.mark_cb:
    385385                        self.mark_cb(item, **options)
    386        
     386
    387387        def mark_used_all(self, items, **options):
    388388                "Mark all specified items as used"
    389                
     389
    390390                for item in items:
    391391                        self.mark_used(item, **options)
     
    395395        TYPE_DIR = 2
    396396        TYPE2MODE = {TYPE_FILE: 8, TYPE_DIR: 4}
    397        
     397
    398398        def __init__(self, fs, index, typ):
    399399                self.fs = fs
     
    406406                self.type = typ
    407407                self.refcount = 0
    408        
     408
    409409        def as_dirent(self, name):
    410410                "Return a DirEntry corresponding to this inode"
    411411                self.refcount += 1
    412412                return DirEntry(name, self.index, self.type)
    413        
     413
    414414        def new_block(self, data=True):
    415415                "Get a new block index from allocator and count it here as belonging to the file"
    416                
     416
    417417                block = self.fs.block_allocator.alloc()
    418418                self.blocks += 1
    419419                return block
    420        
     420
    421421        def get_or_add_block(self, block):
    422422                "Get or add a real block to the file"
    423                
     423
    424424                if block < 12:
    425425                        return self.get_or_add_block_direct(block)
    426426                return self.get_or_add_block_indirect(block)
    427        
     427
    428428        def get_or_add_block_direct(self, block):
    429429                "Get or add a real block to the file (direct blocks)"
    430                
     430
    431431                if self.direct[block] == None:
    432432                        self.direct[block] = self.new_block()
    433433                return self.direct[block]
    434        
     434
    435435        def get_or_add_block_indirect(self, block):
    436436                "Get or add a real block to the file (indirect blocks)"
    437                
     437
    438438                # Determine the indirection level for the desired block
    439439                level = None
     
    444444
    445445                assert level != None
    446        
     446
    447447                # Compute offsets for the topmost level
    448448                block_offset_in_level = block - self.fs.indirect_limits[level-1];
     
    452452                current_block.block_id = self.indirect[level-1]
    453453                offset_in_block = block_offset_in_level // self.fs.indirect_blocks_per_level[level-1]
    454        
     454
    455455                # Navigate through other levels
    456456                while level > 0:
    457457                        assert offset_in_block < self.fs.block_ids_per_block
    458                        
     458
    459459                        level -= 1
    460                        
     460
    461461                        self.fs.seek_to_block(current_block.block_id, offset_in_block*4)
    462462                        current_block.unpack(self.fs.outf.read(4))
    463                        
     463
    464464                        if current_block.block_id == 0:
    465465                                # The block does not exist, so alloc one and write it there
     
    467467                                current_block.block_id = self.new_block(data=(level==0))
    468468                                self.fs.outf.write(current_block.pack())
    469                
     469
    470470                        # If we are on the last level, break here as
    471471                        # there is no next level to visit
    472472                        if level == 0:
    473473                                break
    474                
     474
    475475                        # Visit the next level
    476476                        block_offset_in_level %= self.fs.indirect_blocks_per_level[level];
     
    478478
    479479                return current_block.block_id
    480        
     480
    481481        def do_seek(self):
    482482                "Perform a seek to the position indicated by self.pos"
    483                
     483
    484484                block = self.pos // self.fs.block_size
    485485                real_block = self.get_or_add_block(block)
    486486                offset = self.pos % self.fs.block_size
    487487                self.fs.seek_to_block(real_block, offset)
    488                
     488
    489489        def write(self, data):
    490490                "Write a piece of data (arbitrarily long) as the contents of the inode"
    491                
     491
    492492                data_pos = 0
    493493                while data_pos < len(data):
     
    499499                        data_pos += bytes_to_write
    500500                        self.size = max(self.pos, self.size)
    501        
     501
    502502        def align_size_to_block(self):
    503503                "Align the size of the inode up to block size"
    504                
     504
    505505                self.size = align_up(self.size, self.fs.block_size)
    506        
     506
    507507        def align_pos(self, bytes):
    508508                "Align the current position up to bytes boundary"
    509                
     509
    510510                self.pos = align_up(self.pos, bytes)
    511        
     511
    512512        def set_pos(self, pos):
    513513                "Set the current position"
    514                
     514
    515515                self.pos = pos
    516        
     516
    517517        def pack(self):
    518518                "Pack the inode structure and return the result"
    519                
     519
    520520                data = xstruct.create(STRUCT_INODE)
    521521                data.mode = (Inode.TYPE2MODE[self.type] << 12)
     
    546546                data.group_id_high = 0
    547547                return data.pack()
    548                
     548
    549549class DirEntry:
    550550        "Represents a linked list directory entry"
    551        
     551
    552552        def __init__(self, name, inode, typ):
    553553                self.name = name.encode('UTF-8')
     
    555555                self.skip = None
    556556                self.type = typ
    557        
     557
    558558        def size(self):
    559559                "Return size of the entry in bytes"
    560                
     560
    561561                return align_up(8 + len(self.name)+1, 4)
    562        
     562
    563563        def write(self, inode):
    564564                "Write the directory entry into the inode"
    565                
     565
    566566                head = xstruct.create(STRUCT_DIR_ENTRY_HEAD)
    567567                head.inode = self.inode
     
    575575class DirWriter:
    576576        "Manages writing directory entries into an inode (alignment, etc.)"
    577        
     577
    578578        def __init__(self, inode):
    579579                self.pos = 0
     
    581581                self.prev_entry = None
    582582                self.prev_pos = None
    583        
     583
    584584        def prev_write(self):
    585585                "Write a previously remembered entry"
    586                
     586
    587587                if self.prev_entry:
    588588                        self.prev_entry.skip = self.pos - self.prev_pos
     
    590590                                self.prev_entry.write(self.inode)
    591591                                self.inode.set_pos(self.pos)
    592        
     592
    593593        def add(self, entry):
    594594                "Add a directory entry to the directory"
    595                
     595
    596596                size = entry.size()
    597597                block_size = self.inode.fs.block_size
     
    602602                self.prev_pos = self.pos
    603603                self.pos += size
    604        
     604
    605605        def finish(self):
    606606                "Write the last entry and finish writing the directory contents"
    607                
     607
    608608                if not self.inode:
    609609                        return
     
    614614def subtree_stats(root, block_size):
    615615        "Recursively calculate statistics"
    616        
     616
    617617        blocks = 0
    618618        inodes = 1
    619619        dir_writer = DirWriter(None)
    620        
     620
    621621        for item in listdir_items(root):
    622622                inodes += 1
     
    627627                        blocks += subtree_blocks
    628628                        inodes += subtree_inodes
    629        
     629
    630630        dir_writer.finish()
    631631        blocks += count_up(dir_writer.pos, block_size)
     
    640640                usage(sys.argv[0])
    641641                return
    642        
     642
    643643        if (not sys.argv[1].isdigit()):
    644644                print("<EXTRA_BYTES> must be a number")
    645645                return
    646        
     646
    647647        extra_bytes = int(sys.argv[1])
    648        
     648
    649649        path = os.path.abspath(sys.argv[2])
    650650        if (not os.path.isdir(path)):
    651651                print("<PATH> must be a directory")
    652652                return
    653        
     653
    654654        block_size = 4096
    655655        inode_size = 128
     
    657657        blocks_per_group = 1024
    658658        inodes_per_group = 512
    659        
     659
    660660        blocks, inodes = subtree_stats(path, block_size)
    661661        blocks += count_up(extra_bytes, block_size)
    662662        inodes += reserved_inode_count
    663        
     663
    664664        inodes_per_group = align_up(inodes_per_group, 8)
    665665        blocks_per_group = align_up(blocks_per_group, 8)
    666        
     666
    667667        inode_table_blocks_per_group = (inodes_per_group * inode_size) // block_size
    668668        inode_bitmap_blocks_per_group = count_up(inodes_per_group // 8, block_size)
     
    673673        free_blocks_per_group -= block_bitmap_blocks_per_group
    674674        free_blocks_per_group -= 10 # one for SB and some reserve for GDT
    675        
     675
    676676        block_groups = max(count_up(inodes, inodes_per_group), count_up(blocks, free_blocks_per_group))
    677        
     677
    678678        fs = Filesystem(sys.argv[3], block_groups, blocks_per_group, inodes_per_group,
    679679                                block_size, inode_size, reserved_inode_count)
    680        
     680
    681681        fs.subtree_add(fs.root_inode, fs.root_inode, path, is_root=True)
    682682        fs.close()
    683        
     683
    684684if __name__ == '__main__':
    685685        main()
  • tools/mkfat.py

    r3061bc1 ra35b458  
    4141def subtree_size(root, cluster_size, dirent_size):
    4242        "Recursive directory walk and calculate size"
    43        
     43
    4444        size = 0
    4545        files = 2
    46        
     46
    4747        for item in listdir_items(root):
    4848                if item.is_file:
     
    5252                        size += subtree_size(item.path, cluster_size, dirent_size)
    5353                        files += 1
    54        
     54
    5555        return size + align_up(files * dirent_size, cluster_size)
    5656
    5757def root_entries(root):
    5858        "Return number of root directory entries"
    59        
     59
    6060        return len(os.listdir(root))
    6161
    6262def write_file(item, outf, cluster_size, data_start, fat, reserved_clusters):
    6363        "Store the contents of a file"
    64        
     64
    6565        prev = -1
    6666        first = 0
    67        
     67
    6868        for data in chunks(item, cluster_size):
    6969                empty_cluster = fat.index(0)
    7070                fat[empty_cluster] = 0xffff
    71                
     71
    7272                if (prev != -1):
    7373                        fat[prev] = empty_cluster
    7474                else:
    7575                        first = empty_cluster
    76                
     76
    7777                prev = empty_cluster
    78                
     78
    7979                outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
    8080                outf.write(data)
    81        
     81
    8282        return first, item.size
    8383
    8484def write_directory(directory, outf, cluster_size, data_start, fat, reserved_clusters, dirent_size, empty_cluster):
    8585        "Store the contents of a directory"
    86        
     86
    8787        length = len(directory)
    8888        size = length * dirent_size
    8989        prev = -1
    9090        first = 0
    91        
     91
    9292        i = 0
    9393        rd = 0;
     
    9999                else:
    100100                        first = empty_cluster
    101                
     101
    102102                prev = empty_cluster
    103                
     103
    104104                data = bytes()
    105105                data_len = 0
     
    107107                        if (i == 0):
    108108                                directory[i].cluster = empty_cluster
    109                        
     109
    110110                        data += directory[i].pack()
    111111                        data_len += dirent_size
    112112                        i += 1
    113                
     113
    114114                outf.seek(data_start + (empty_cluster - reserved_clusters) * cluster_size)
    115115                outf.write(data)
    116116                rd += len(data)
    117        
     117
    118118        return first, size
    119119
     
    188188def fat_lchars(name):
    189189        "Filter FAT legal characters"
    190        
     190
    191191        filtered_name = b''
    192192        filtered = False
    193        
     193
    194194        for char in name.encode('ascii', 'replace').upper():
    195195                if char in lchars:
     
    198198                        filtered_name += b'_'
    199199                        filtered = True
    200        
     200
    201201        return (filtered_name, filtered)
    202202
    203203def fat_name83(name, name83_list):
    204204        "Create a 8.3 name for the given name"
    205        
     205
    206206        ascii_name, lfn = fat_lchars(name)
    207207        # Splitting works only on strings, not on bytes
    208208        ascii_parts = ascii_name.decode('utf8').split('.')
    209        
     209
    210210        short_name = ''
    211211        short_ext = ''
    212        
     212
    213213        if len(ascii_name) > 11:
    214214                lfn = True
    215        
     215
    216216        if len(ascii_parts) > 0:
    217217                short_name = ascii_parts[0]
    218218                if len(short_name) > 8:
    219219                        lfn = True
    220        
     220
    221221        if len(ascii_parts) > 1:
    222222                short_ext = ascii_parts[-1]
    223223                if len(short_ext) > 3:
    224224                        lfn = True
    225        
     225
    226226        if len(ascii_parts) > 2:
    227227                lfn = True
    228        
     228
    229229        if lfn == False:
    230230                name83_list.append(short_name + '.' + short_ext)
    231231                return (short_name.ljust(8)[0:8], short_ext.ljust(3)[0:3], False)
    232        
     232
    233233        # For filenames with multiple extensions, we treat the last one
    234234        # as the actual extension. The rest of the filename is stripped
     
    236236        for part in ascii_parts[1:-1]:
    237237                short_name += part
    238        
     238
    239239        for number in range(1, 999999):
    240240                number_str = ('~' + str(number)).upper()
    241                
     241
    242242                if len(short_name) + len(number_str) > 8:
    243243                        short_name = short_name[0:8 - len(number_str)]
    244                
     244
    245245                short_name += number_str;
    246                
     246
    247247                if not (short_name + '.' + short_ext) in name83_list:
    248248                        break
    249        
     249
    250250        name83_list.append(short_name + '.' + short_ext)
    251251        return (short_name.ljust(8)[0:8], short_ext.ljust(3)[0:3], True)
     
    253253def create_lfn_dirent(name, seq, checksum):
    254254        "Create LFN directory entry"
    255        
     255
    256256        entry = xstruct.create(LFN_DIR_ENTRY)
    257257        name_rest = name[26:]
    258        
     258
    259259        if len(name_rest) > 0:
    260260                entry.seq = seq
    261261        else:
    262262                entry.seq = seq | 0x40
    263        
     263
    264264        entry.name1 = name[0:10]
    265265        entry.name2 = name[10:22]
    266266        entry.name3 = name[22:26]
    267        
     267
    268268        entry.attr = 0x0F
    269269        entry.rec_type = 0
    270270        entry.checksum = checksum
    271271        entry.cluster = 0
    272        
     272
    273273        return (entry, name_rest)
    274274
    275275def lfn_checksum(name):
    276276        "Calculate LFN checksum"
    277        
     277
    278278        checksum = 0
    279279        for i in range(0, 11):
    280280                checksum = (((checksum & 1) << 7) + (checksum >> 1) + ord(name[i])) & 0xFF
    281        
     281
    282282        return checksum
    283283
    284284def create_dirent(name, name83_list, directory, cluster, size):
    285285        short_name, short_ext, lfn = fat_name83(name, name83_list)
    286        
     286
    287287        dir_entry = xstruct.create(DIR_ENTRY)
    288        
     288
    289289        dir_entry.name = short_name
    290290        dir_entry.ext = short_ext
    291        
     291
    292292        if (directory):
    293293                dir_entry.attr = 0x30
    294294        else:
    295295                dir_entry.attr = 0x20
    296        
     296
    297297        dir_entry.lcase = 0x18
    298298        dir_entry.ctime_fine = 0 # FIXME
     
    303303        dir_entry.mdate = 0 # FIXME
    304304        dir_entry.cluster = cluster
    305        
     305
    306306        if (directory):
    307307                dir_entry.size = 0
    308308        else:
    309309                dir_entry.size = size
    310        
     310
    311311        if not lfn:
    312312                return [dir_entry]
    313        
     313
    314314        long_name = name.encode('utf_16_le')
    315315        entries = [dir_entry]
    316        
     316
    317317        seq = 1
    318318        checksum = lfn_checksum(dir_entry.name + dir_entry.ext)
    319        
     319
    320320        while len(long_name) > 0:
    321321                long_entry, long_name = create_lfn_dirent(long_name, seq, checksum)
    322322                entries.append(long_entry)
    323323                seq += 1
    324        
     324
    325325        entries.reverse()
    326326        return entries
     
    328328def create_dot_dirent(empty_cluster):
    329329        dir_entry = xstruct.create(DOT_DIR_ENTRY)
    330        
     330
    331331        dir_entry.signature = 0x2e
    332332        dir_entry.name = b'       '
    333333        dir_entry.ext = b'   '
    334334        dir_entry.attr = 0x10
    335        
     335
    336336        dir_entry.ctime_fine = 0 # FIXME
    337337        dir_entry.ctime = 0 # FIXME
     
    342342        dir_entry.cluster = empty_cluster
    343343        dir_entry.size = 0
    344        
     344
    345345        return dir_entry
    346346
    347347def create_dotdot_dirent(parent_cluster):
    348348        dir_entry = xstruct.create(DOTDOT_DIR_ENTRY)
    349        
     349
    350350        dir_entry.signature = [0x2e, 0x2e]
    351351        dir_entry.name = b'      '
    352352        dir_entry.ext = b'   '
    353353        dir_entry.attr = 0x10
    354        
     354
    355355        dir_entry.ctime_fine = 0 # FIXME
    356356        dir_entry.ctime = 0 # FIXME
     
    361361        dir_entry.cluster = parent_cluster
    362362        dir_entry.size = 0
    363        
     363
    364364        return dir_entry
    365365
    366366def recursion(head, root, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, parent_cluster):
    367367        "Recursive directory walk"
    368        
     368
    369369        directory = []
    370370        name83_list = []
    371        
     371
    372372        if not head:
    373373                # Directory cluster preallocation
    374374                empty_cluster = fat.index(0)
    375375                fat[empty_cluster] = 0xFFFF
    376                
     376
    377377                directory.append(create_dot_dirent(empty_cluster))
    378378                directory.append(create_dotdot_dirent(parent_cluster))
    379379        else:
    380380                empty_cluster = 0
    381        
     381
    382382        for item in listdir_items(root):
    383383                if item.is_file:
     
    387387                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    388388                        directory.extend(create_dirent(item.name, name83_list, True, rv[0], rv[1]))
    389        
     389
    390390        if head:
    391391                outf.seek(root_start)
     
    410410        uint32_t hidden            /* hidden sectors */
    411411        uint32_t sectors_big       /* total number of sectors (if sectors == 0) */
    412        
     412
    413413        /* Extended BIOS Parameter Block */
    414414        uint8_t drive              /* physical drive number */
     
    438438                usage(sys.argv[0])
    439439                return
    440        
     440
    441441        if (not sys.argv[1].isdigit()):
    442442                print("<EXTRA_BYTES> must be a number")
    443443                return
    444        
     444
    445445        extra_bytes = int(sys.argv[1])
    446        
     446
    447447        path = os.path.abspath(sys.argv[2])
    448448        if (not os.path.isdir(path)):
    449449                print("<PATH> must be a directory")
    450450                return
    451        
     451
    452452        fat16_clusters = 4096
    453        
     453
    454454        sector_size = 512
    455455        cluster_size = 4096
     
    458458        fat_count = 2
    459459        reserved_clusters = 2
    460        
     460
    461461        # Make sure the filesystem is large enough for FAT16
    462462        size = subtree_size(path, cluster_size, dirent_size) + reserved_clusters * cluster_size + extra_bytes
     
    467467                else:
    468468                        size = fat16_clusters * cluster_size + reserved_clusters * cluster_size
    469        
     469
    470470        root_size = align_up(root_entries(path) * dirent_size, cluster_size)
    471        
     471
    472472        fat_size = align_up(align_up(size, cluster_size) // cluster_size * fatent_size, sector_size)
    473        
     473
    474474        sectors = (cluster_size + fat_count * fat_size + root_size + size) // sector_size
    475475        root_start = cluster_size + fat_count * fat_size
    476476        data_start = root_start + root_size
    477        
     477
    478478        outf = open(sys.argv[3], "wb")
    479        
     479
    480480        boot_sector = xstruct.create(BOOT_SECTOR)
    481481        boot_sector.jmp = [0xEB, 0x3C, 0x90]
     
    499499        else:
    500500                boot_sector.sectors_big = 0
    501        
     501
    502502        boot_sector.drive = 0x80
    503503        boot_sector.extboot_signature = 0x29
     
    506506        boot_sector.fstype = b'FAT16   '
    507507        boot_sector.boot_signature = [0x55, 0xAA]
    508        
     508
    509509        outf.write(boot_sector.pack())
    510        
     510
    511511        empty_sector = xstruct.create(EMPTY_SECTOR)
    512        
     512
    513513        # Reserved sectors
    514514        for i in range(1, cluster_size // sector_size):
    515515                outf.write(empty_sector.pack())
    516        
     516
    517517        # FAT tables
    518518        for i in range(0, fat_count):
    519519                for j in range(0, fat_size // sector_size):
    520520                        outf.write(empty_sector.pack())
    521        
     521
    522522        # Root directory
    523523        for i in range(0, root_size // sector_size):
    524524                outf.write(empty_sector.pack())
    525        
     525
    526526        # Data
    527527        for i in range(0, size // sector_size):
    528528                outf.write(empty_sector.pack())
    529        
     529
    530530        fat = array.array('L', [0] * (fat_size // fatent_size))
    531531        fat[0] = 0xfff8
    532532        fat[1] = 0xffff
    533        
     533
    534534        recursion(True, path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, 0)
    535        
     535
    536536        # Store FAT
    537537        fat_entry = xstruct.create(FAT_ENTRY)
     
    541541                        fat_entry.next = fat[j]
    542542                        outf.write(fat_entry.pack())
    543        
     543
    544544        outf.close()
    545545
  • tools/mktmpfs.py

    r3061bc1 ra35b458  
    6969def recursion(root, outf):
    7070        "Recursive directory walk"
    71        
     71
    7272        for item in listdir_items(root):
    7373                if item.is_file:
     
    7777                        dentry.fname = item.name.encode('ascii')
    7878                        dentry.flen = item.size
    79                        
     79
    8080                        outf.write(dentry.pack())
    81                        
     81
    8282                        for data in chunks(item, 4096):
    8383                                outf.write(data)
    84                
     84
    8585                elif item.is_dir:
    8686                        dentry = xstruct.create(DENTRY_DIRECTORY % len(item.name))
     
    8888                        dentry.fname_len = len(item.name)
    8989                        dentry.fname = item.name.encode('ascii')
    90                        
     90
    9191                        outf.write(dentry.pack())
    92                        
     92
    9393                        recursion(item.path, outf)
    94                        
     94
    9595                        dentry = xstruct.create(DENTRY_NONE)
    9696                        dentry.kind = TMPFS_NONE
    9797                        dentry.fname_len = 0
    98                        
     98
    9999                        outf.write(dentry.pack())
    100100
     
    103103                usage(sys.argv[0])
    104104                return
    105        
     105
    106106        path = os.path.abspath(sys.argv[1])
    107107        if (not os.path.isdir(path)):
    108108                print("<PATH> must be a directory")
    109109                return
    110        
     110
    111111        outf = open(sys.argv[2], "wb")
    112        
     112
    113113        header = xstruct.create(HEADER)
    114114        header.tag = b"TMPFS"
    115        
     115
    116116        outf.write(header.pack())
    117        
     117
    118118        recursion(path, outf)
    119        
     119
    120120        dentry = xstruct.create(DENTRY_NONE)
    121121        dentry.kind = TMPFS_NONE
    122122        dentry.fname_len = 0
    123        
     123
    124124        outf.write(dentry.pack())
    125        
     125
    126126        outf.close()
    127        
     127
    128128if __name__ == '__main__':
    129129        main()
  • tools/toolchain.sh

    r3061bc1 ra35b458  
    8585        HEADER="$2"
    8686        BODY="$3"
    87        
     87
    8888        FNAME="/tmp/conftest-$$"
    89        
     89
    9090        echo "#include ${HEADER}" > "${FNAME}.c"
    9191        echo >> "${FNAME}.c"
     
    9595        echo "  return 0;" >> "${FNAME}.c"
    9696        echo "}" >> "${FNAME}.c"
    97        
     97
    9898        cc $CFLAGS -c -o "${FNAME}.o" "${FNAME}.c" 2> "${FNAME}.log"
    9999        RC="$?"
    100        
     100
    101101        if [ "$RC" -ne "0" ] ; then
    102102                if [ "${DEPENDENCY}" == "isl" ]; then
    103103                        BUILD_ISL=true
    104                        
     104
    105105                        echo " isl not found. Will be downloaded and built with GCC."
    106106                else
     
    134134                echo
    135135                echo "Script failed: $2"
    136                
     136
    137137                exit 1
    138138        fi
     
    142142        FILE="$1"
    143143        SUM="$2"
    144        
     144
    145145        COMPUTED="`md5sum "${FILE}" | cut -d' ' -f1`"
    146146        if [ "${SUM}" != "${COMPUTED}" ] ; then
    147147                echo
    148148                echo "Checksum of ${FILE} does not match."
    149                
     149
    150150                exit 2
    151151        fi
     
    193193        echo "feature that is not fully supported."
    194194        echo
    195        
     195
    196196        exit 3
    197197}
     
    203203show_countdown() {
    204204        TM="$1"
    205        
     205
    206206        if [ "${TM}" -eq 0 ] ; then
    207207                echo
    208208                return 0
    209209        fi
    210        
     210
    211211        echo -n "${TM} "
    212212        change_title "${TM}"
    213213        sleep 1
    214        
     214
    215215        TM="`expr "${TM}" - 1`"
    216216        show_countdown "${TM}"
     
    243243        FILE="$2"
    244244        CHECKSUM="$3"
    245        
     245
    246246        if [ ! -f "${FILE}" ] ; then
    247247                change_title "Downloading ${FILE}"
    248248                wget -c "${SOURCE}${FILE}" -O "${FILE}".part
    249249                check_error $? "Error downloading ${FILE}."
    250                
     250
    251251                mv "${FILE}".part "${FILE}"
    252252        fi
    253        
     253
    254254        check_md5 "${FILE}" "${CHECKSUM}"
    255255}
     
    257257source_check() {
    258258        FILE="$1"
    259        
     259
    260260        if [ ! -f "${FILE}" ] ; then
    261261                echo
    262262                echo "File ${FILE} not found."
    263                
     263
    264264                exit 4
    265265        fi
     
    268268cleanup_dir() {
    269269        DIR="$1"
    270        
     270
    271271        if [ -d "${DIR}" ] ; then
    272272                change_title "Removing ${DIR}"
     
    279279        DIR="$1"
    280280        DESC="$2"
    281        
     281
    282282        change_title "Creating ${DESC}"
    283283        echo ">>> Creating ${DESC}"
    284        
     284
    285285        mkdir -p "${DIR}"
    286286        test -d "${DIR}"
     
    292292        BASE="$2"
    293293        ORIGINAL="`pwd`"
    294        
     294
    295295        mkdir -p "${OUTSIDE}"
    296        
     296
    297297        cd "${OUTSIDE}"
    298298        check_error $? "Unable to change directory to ${OUTSIDE}."
    299299        ABS_OUTSIDE="`pwd`"
    300        
     300
    301301        cd "${BASE}"
    302302        check_error $? "Unable to change directory to ${BASE}."
    303303        ABS_BASE="`pwd`"
    304        
     304
    305305        cd "${ORIGINAL}"
    306306        check_error $? "Unable to change directory to ${ORIGINAL}."
    307        
     307
    308308        BASE_LEN="${#ABS_BASE}"
    309309        OUTSIDE_TRIM="${ABS_OUTSIDE:0:${BASE_LEN}}"
    310        
     310
    311311        if [ "${OUTSIDE_TRIM}" == "${ABS_BASE}" ] ; then
    312312                echo
    313313                echo "CROSS_PREFIX cannot reside within the working directory."
    314                
     314
    315315                exit 5
    316316        fi
     
    320320        FILE="$1"
    321321        DESC="$2"
    322        
     322
    323323        change_title "Unpacking ${DESC}"
    324324        echo " >>> Unpacking ${DESC}"
    325        
     325
    326326        case "${FILE}" in
    327327                *.gz)
     
    345345        PATCH_STRIP="$2"
    346346        DESC="$3"
    347        
     347
    348348        change_title "Patching ${DESC}"
    349349        echo " >>> Patching ${DESC} with ${PATCH_FILE}"
    350        
     350
    351351        patch -t "-p${PATCH_STRIP}" <"$PATCH_FILE"
    352352        check_error $? "Error patching ${DESC}."
     
    357357        check_dependecies
    358358        show_countdown 10
    359        
     359
    360360        BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
    361361        GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
    362362        GDB_SOURCE="ftp://ftp.gnu.org/gnu/gdb/"
    363363        ISL_SOURCE="http://isl.gforge.inria.fr/"
    364        
     364
    365365        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "9e8340c96626b469a603c15c9d843727"
    366366        download_fetch "${GCC_SOURCE}" "${GCC}" "6bf56a2bca9dac9dbbf8e8d1036964a8"
    367367        download_fetch "${GDB_SOURCE}" "${GDB}" "06c8f40521ed65fe36ebc2be29b56942"
    368        
     368
    369369        if $BUILD_ISL ; then
    370370                download_fetch "${ISL_SOURCE}" "${ISL}" "11436d6b205e516635b666090b94ab32"
     
    426426build_target() {
    427427        PLATFORM="$1"
    428        
     428
    429429        # This sets the *_TARGET variables
    430430        set_target_from_platform "$PLATFORM"
     
    434434                TARGET="$LINUX_TARGET"
    435435        fi
    436        
     436
    437437        WORKDIR="${BASEDIR}/${TARGET}"
    438438        INSTALL_DIR="${WORKDIR}/PKG"
     
    442442        OBJDIR="${WORKDIR}/gcc-obj"
    443443        GDBDIR="${WORKDIR}/gdb-${GDB_VERSION}"
    444        
     444
    445445        if [ -z "${CROSS_PREFIX}" ] ; then
    446446                CROSS_PREFIX="/usr/local/cross"
    447447        fi
    448        
     448
    449449        PREFIX="${CROSS_PREFIX}/${TARGET}"
    450        
     450
    451451        echo ">>> Downloading tarballs"
    452452        source_check "${BASEDIR}/${BINUTILS}"
     
    456456                source_check "${BASEDIR}/${ISL}"
    457457        fi
    458        
     458
    459459        echo ">>> Removing previous content"
    460460        cleanup_dir "${WORKDIR}"
    461        
     461
    462462        create_dir "${OBJDIR}" "GCC object directory"
    463        
     463
    464464        check_dirs "${PREFIX}" "${WORKDIR}"
    465        
     465
    466466        echo ">>> Unpacking tarballs"
    467467        cd "${WORKDIR}"
    468468        check_error $? "Change directory failed."
    469        
     469
    470470        unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
    471471        unpack_tarball "${BASEDIR}/${GCC}" "GCC"
     
    475475                mv "${ISLDIR}" "${GCCDIR}"/isl
    476476        fi
    477        
     477
    478478        echo ">>> Applying patches"
    479479        for p in $BINUTILS_PATCHES ; do
     
    486486                patch_sources "${SRCDIR}/${p}" 0 "GDB"
    487487        done
    488        
     488
    489489        echo ">>> Processing binutils (${PLATFORM})"
    490490        cd "${BINUTILSDIR}"
    491491        check_error $? "Change directory failed."
    492        
     492
    493493        change_title "binutils: configure (${PLATFORM})"
    494494        CFLAGS=-Wno-error ./configure \
     
    498498                --enable-deterministic-archives
    499499        check_error $? "Error configuring binutils."
    500        
     500
    501501        change_title "binutils: make (${PLATFORM})"
    502502        make all
    503503        check_error $? "Error compiling binutils."
    504        
     504
    505505        change_title "binutils: install (${PLATFORM})"
    506506        make install "DESTDIR=${INSTALL_DIR}"
    507507        check_error $? "Error installing binutils."
    508        
    509        
     508
     509
    510510        echo ">>> Processing GCC (${PLATFORM})"
    511511        cd "${OBJDIR}"
    512512        check_error $? "Change directory failed."
    513        
     513
    514514        change_title "GCC: configure (${PLATFORM})"
    515515        PATH="$PATH:${INSTALL_DIR}/${PREFIX}/bin" "${GCCDIR}/configure" \
     
    521521                --disable-shared --enable-lto --disable-werror
    522522        check_error $? "Error configuring GCC."
    523        
     523
    524524        change_title "GCC: make (${PLATFORM})"
    525525        PATH="${PATH}:${PREFIX}/bin:${INSTALL_DIR}/${PREFIX}/bin" make all-gcc
    526526        check_error $? "Error compiling GCC."
    527        
     527
    528528        change_title "GCC: install (${PLATFORM})"
    529529        PATH="${PATH}:${INSTALL_DIR}/${PREFIX}/bin" make install-gcc "DESTDIR=${INSTALL_DIR}"
    530530        check_error $? "Error installing GCC."
    531        
    532        
     531
     532
    533533        # No GDB support for RISC-V so far
    534534        if [ "$PLATFORM" != "riscv64" ] ; then
     
    536536                cd "${GDBDIR}"
    537537                check_error $? "Change directory failed."
    538                
     538
    539539                change_title "GDB: configure (${PLATFORM})"
    540540                PATH="$PATH:${INSTALL_DIR}/${PREFIX}/bin" ./configure \
     
    543543                        --enable-werror=no --without-guile
    544544                check_error $? "Error configuring GDB."
    545                
     545
    546546                change_title "GDB: make (${PLATFORM})"
    547547                PATH="${PATH}:${PREFIX}/bin:${INSTALL_DIR}/${PREFIX}/bin" make all
    548548                check_error $? "Error compiling GDB."
    549                
     549
    550550                change_title "GDB: make (${PLATFORM})"
    551551                PATH="${PATH}:${INSTALL_DIR}/${PREFIX}/bin" make install "DESTDIR=${INSTALL_DIR}"
    552552                check_error $? "Error installing GDB."
    553553        fi
    554        
     554
    555555        # Symlink clang and lld to the install path.
    556556        CLANG="`which clang 2> /dev/null || echo "/usr/bin/clang"`"
    557557        LLD="`which ld.lld 2> /dev/null || echo "/usr/bin/ld.lld"`"
    558        
     558
    559559        ln -s $CLANG "${INSTALL_DIR}/${PREFIX}/bin/${TARGET}-clang"
    560560        ln -s $LLD "${INSTALL_DIR}/${PREFIX}/bin/${TARGET}-ld.lld"
    561        
     561
    562562        if $REAL_INSTALL ; then
    563563                echo ">>> Moving to the destination directory."
     
    566566                mv "${INSTALL_DIR}/${PREFIX}" "${PREFIX}"
    567567        fi
    568        
     568
    569569        cd "${BASEDIR}"
    570570        check_error $? "Change directory failed."
    571        
     571
    572572        echo ">>> Cleaning up"
    573573        cleanup_dir "${WORKDIR}"
    574        
     574
    575575        echo
    576576        echo ">>> Cross-compiler for ${TARGET} installed."
     
    647647                build_target "arm32" &
    648648                wait
    649                
     649
    650650                build_target "ia32" &
    651651                build_target "ia64" &
    652652                wait
    653                
     653
    654654                build_target "mips32" &
    655655                build_target "mips32eb" &
    656656                wait
    657                
     657
    658658                build_target "mips64" &
    659659                build_target "ppc32" &
    660660                wait
    661                
     661
    662662                build_target "riscv64" &
    663663                build_target "ppc64" &
    664664                wait
    665                
     665
    666666                build_target "sparc64" &
    667667                wait
  • tools/travis.sh

    r3061bc1 ra35b458  
    119119elif [ "$1" = "install" ]; then
    120120    set -x
    121    
     121
    122122    # Install dependencies
    123123    sudo apt-get -qq update || exit 1
     
    133133elif [ "$1" = "run" ]; then
    134134    set -x
    135    
     135
    136136    # Expected output filename (bootable image)
    137137    H_OUTPUT_FILENAME=`h_get_arch_config $H_ARCH_CONFIG_OUTPUT_FILENAME`
     
    150150    fi
    151151
    152        
     152
    153153    # Build it
    154154    make "PROFILE=$H_ARCH" HANDS_OFF=y || exit 1
    155155    test -s "$H_OUTPUT_FILENAME" || exit 1
    156    
     156
    157157    echo
    158158    echo "HelenOS for $H_ARCH built okay."
     
    165165        echo "Repository used is $H_HARBOURS_REPOSITORY."
    166166        echo
    167        
     167
    168168        H_HELENOS_HOME=`pwd`
    169169        cd "$HOME" || exit 1
     
    181181                echo "machine =" `echo "$H_ARCH" | cut -d/ -f 2`
    182182            ) >hsct.conf || exit 1
    183            
     183
    184184            # "$HOME/helenos-harbours/hsct.sh" init "$H_HELENOS_HOME" "$H_ARCH" build >/dev/null 2>/dev/null || exit 1
    185            
     185
    186186            "$HOME/helenos-harbours/hsct.sh" update || exit 1
    187187
     
    196196                    tail -n 100 "run-$HARBOUR.log"
    197197                fi
    198                
     198
    199199            done
    200            
     200
    201201            if [ -n "$FAILED_HARBOURS" ]; then
    202202                echo
  • tools/xstruct.py

    r3061bc1 ra35b458  
    7272        def size(self):
    7373                return struct.calcsize(self._format_)
    74        
     74
    7575        def pack(self):
    7676                args = []
     
    9090                                args.append(value)
    9191                return struct.pack(self._format_, *args)
    92        
     92
    9393        def unpack(self, data):
    9494                values = struct.unpack(self._format_, data)
     
    100100def create(definition):
    101101        "Create structure object"
    102        
     102
    103103        tokens = definition.split(None)
    104        
     104
    105105        # Initial byte order tag
    106106        format = {
     
    111111        inst = Struct()
    112112        args = []
    113        
     113
    114114        # Member tags
    115115        comment = False
     
    120120                                comment = False
    121121                        continue
    122                
     122
    123123                if (token == "/*"):
    124124                        comment = True
    125125                        continue
    126                
     126
    127127                if (variable != None):
    128128                        subtokens = token.split("[")
    129                        
     129
    130130                        length = None
    131131                        if (len(subtokens) > 1):
    132132                                length = int(subtokens[1].split("]")[0])
    133133                                format += "%d" % length
    134                        
     134
    135135                        format += variable
    136                        
     136
    137137                        inst.__dict__[subtokens[0]] = None
    138138                        args.append((subtokens[0], variable, length))
    139                        
     139
    140140                        variable = None
    141141                        continue
    142                
     142
    143143                if (token[0:8] == "padding["):
    144144                        size = token[8:].split("]")[0]
    145145                        format += "%dx" % int(size)
    146146                        continue
    147                
     147
    148148                variable = {
    149149                        "char":     lambda: "s",
     
    152152                        "uint32_t": lambda: "L",
    153153                        "uint64_t": lambda: "Q",
    154                        
     154
    155155                        "int8_t":   lambda: "b",
    156156                        "int16_t":  lambda: "h",
     
    158158                        "int64_t":  lambda: "q"
    159159                }[token]()
    160        
     160
    161161        inst.__dict__['_format_'] = format
    162162        inst.__dict__['_args_'] = args
  • tools/xtui.py

    r3061bc1 ra35b458  
    3535def call_dlg(dlgcmd, *args, **kw):
    3636        "Wrapper for calling 'dialog' program"
    37        
     37
    3838        indesc, outdesc = os.pipe()
    3939        pid = os.fork()
     
    4141                os.dup2(outdesc, 2)
    4242                os.close(indesc)
    43                
     43
    4444                dlgargs = [dlgcmd]
    4545                for key, val in kw.items():
    4646                        dlgargs.append('--' + key)
    4747                        dlgargs.append(val)
    48                
     48
    4949                dlgargs += args
    5050                os.execlp(dlgcmd, *dlgargs)
    51        
     51
    5252        os.close(outdesc)
    53        
     53
    5454        try:
    5555                errout = os.fdopen(indesc, 'r')
     
    6161                os.system('reset')
    6262                raise
    63        
     63
    6464        if (not os.WIFEXITED(status)):
    6565                # Reset terminal
    6666                os.system('reset')
    6767                raise EOFError
    68        
     68
    6969        status = os.WEXITSTATUS(status)
    7070        if (status == 255):
    7171                raise EOFError
    72        
     72
    7373        return (status, data)
    7474
     
    7979except ImportError:
    8080        newt = False
    81        
     81
    8282        dlgcmd = os.environ.get('DIALOG', 'dialog')
    8383        if (call_dlg(dlgcmd, '--print-maxsize')[0] != 0):
     
    9191def width_fix(screen, width):
    9292        "Correct width to screen size"
    93        
     93
    9494        if (width + width_extra > screen.width):
    9595                width = screen.width - width_extra
    96        
     96
    9797        if (width <= 0):
    9898                width = screen.width
    99        
     99
    100100        return width
    101101
    102102def height_fix(screen, height):
    103103        "Correct height to screen size"
    104        
     104
    105105        if (height + height_extra > screen.height):
    106106                height = screen.height - height_extra
    107        
     107
    108108        if (height <= 0):
    109109                height = screen.height
    110        
     110
    111111        return height
    112112
    113113def screen_init():
    114114        "Initialize the screen"
    115        
     115
    116116        if (newt):
    117117                return snack.SnackScreen()
    118        
     118
    119119        return None
    120120
    121121def screen_done(screen):
    122122        "Cleanup the screen"
    123        
     123
    124124        if (newt):
    125125                screen.finish()
     
    127127def choice_window(screen, title, text, options, position):
    128128        "Create options menu"
    129        
     129
    130130        maxopt = 0
    131131        for option in options:
     
    133133                if (length > maxopt):
    134134                        maxopt = length
    135        
     135
    136136        width = maxopt
    137137        height = len(options)
    138        
     138
    139139        if (newt):
    140140                width = width_fix(screen, width + width_extra)
    141141                height = height_fix(screen, height)
    142                
     142
    143143                if (height > 3):
    144144                        large = True
    145145                else:
    146146                        large = False
    147                
     147
    148148                buttonbar = snack.ButtonBar(screen, ('Done', 'Cancel'))
    149149                textbox = snack.TextboxReflowed(width, text)
    150150                listbox = snack.Listbox(height, scroll = large, returnExit = 1)
    151                
     151
    152152                cnt = 0
    153153                for option in options:
    154154                        listbox.append(option, cnt)
    155155                        cnt += 1
    156                
     156
    157157                if (position != None):
    158158                        listbox.setCurrent(position)
    159                
     159
    160160                grid = snack.GridForm(screen, title, 1, 3)
    161161                grid.add(textbox, 0, 0)
    162162                grid.add(listbox, 0, 1, padding = (0, 1, 0, 1))
    163163                grid.add(buttonbar, 0, 2, growx = 1)
    164                
     164
    165165                retval = grid.runOnce()
    166                
     166
    167167                return (buttonbar.buttonPressed(retval), listbox.current())
    168168        elif (dialog):
    169169                if (width < 35):
    170170                        width = 35
    171                
     171
    172172                args = []
    173173                cnt = 0
     
    175175                        args.append(str(cnt + 1))
    176176                        args.append(option)
    177                        
     177
    178178                        cnt += 1
    179                
     179
    180180                kw = {}
    181181                if (position != None):
    182182                        kw['default-item'] = str(position + 1)
    183                
     183
    184184                status, data = call_dlg(dlgcmd, '--title', title, '--extra-button', '--extra-label', 'Done', '--menu', text, str(height + height_extra), str(width + width_extra), str(cnt), *args, **kw)
    185                
     185
    186186                if (status == 1):
    187187                        return ('cancel', None)
    188                
     188
    189189                try:
    190190                        choice = int(data) - 1
    191191                except ValueError:
    192192                        return ('cancel', None)
    193                
     193
    194194                if (status == 0):
    195195                        return (None, choice)
    196                
     196
    197197                return ('done', choice)
    198        
     198
    199199        sys.stdout.write("\n *** %s *** \n%s\n\n" % (title, text))
    200        
     200
    201201        maxcnt = len(str(len(options)))
    202202        cnt = 0
     
    204204                sys.stdout.write("%*s. %s\n" % (maxcnt, cnt + 1, option))
    205205                cnt += 1
    206        
     206
    207207        sys.stdout.write("\n%*s. Done\n" % (maxcnt, '0'))
    208208        sys.stdout.write("%*s. Quit\n\n" % (maxcnt, 'q'))
    209        
     209
    210210        while True:
    211211                if (position != None):
     
    217217                                sys.stdout.write("Selection[0]: ")
    218218                inp = sys.stdin.readline()
    219                
     219
    220220                if (not inp):
    221221                        raise EOFError
    222                
     222
    223223                if (not inp.strip()):
    224224                        if (position != None):
     
    229229                                else:
    230230                                        inp = '0'
    231                
     231
    232232                if (inp.strip() == 'q'):
    233233                        return ('cancel', None)
    234                
     234
    235235                try:
    236236                        choice = int(inp.strip())
    237237                except ValueError:
    238238                        continue
    239                
     239
    240240                if (choice == 0):
    241241                        return ('done', 0)
    242                
     242
    243243                if (choice < 1) or (choice > len(options)):
    244244                        continue
    245                
     245
    246246                return (None, choice - 1)
    247247
    248248def error_dialog(screen, title, msg):
    249249        "Print error dialog"
    250        
     250
    251251        width = len(msg)
    252        
     252
    253253        if (newt):
    254254                width = width_fix(screen, width)
    255                
     255
    256256                buttonbar = snack.ButtonBar(screen, ['Ok'])
    257257                textbox = snack.TextboxReflowed(width, msg)
    258                
     258
    259259                grid = snack.GridForm(screen, title, 1, 2)
    260260                grid.add(textbox, 0, 0, padding = (0, 0, 0, 1))
Note: See TracChangeset for help on using the changeset viewer.