Changes in tools/autotool.py [96b89acb:85369b1] in mainline


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • tools/autotool.py

    r96b89acb r85369b1  
    5353
    5454COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
    55 COMPILER_WARNING = "The compilation of HelenOS might fail."
    5655
    5756PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, strc, conc, value) \\
     
    6261        )
    6362
    64 #define STRING(arg)      STRING_ARG(arg)
    65 #define STRING_ARG(arg)  #arg
    66 
    67 #define DECLARE_BUILTIN_TYPE(tag, type) \\
    68         AUTOTOOL_DECLARE("builtin", "", tag, STRING(type), "", "", sizeof(type));
    69 
    7063#define DECLARE_INTSIZE(tag, type, strc, conc) \\
    7164        AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
     
    7467int main(int argc, char *argv[])
    7568{
    76 #ifdef __SIZE_TYPE__
    77         DECLARE_BUILTIN_TYPE("size", __SIZE_TYPE__);
    78 #endif
    79 #ifdef __WCHAR_TYPE__
    80         DECLARE_BUILTIN_TYPE("wchar", __WCHAR_TYPE__);
    81 #endif
    82 #ifdef __WINT_TYPE__
    83         DECLARE_BUILTIN_TYPE("wint", __WINT_TYPE__);
    84 #endif
    8569"""
    8670
     
    11296       
    11397        sys.exit(1)
    114 
    115 def print_warning(msg):
    116         "Print a bold error message"
    117        
    118         sys.stderr.write("\n")
    119         sys.stderr.write("######################################################################\n")
    120         sys.stderr.write("HelenOS build sanity check warning:\n")
    121         sys.stderr.write("\n")
    122         sys.stderr.write("%s\n" % "\n".join(msg))
    123         sys.stderr.write("######################################################################\n")
    124         sys.stderr.write("\n")
    125        
    126         time.sleep(5)
    12798
    12899def sandbox_enter():
     
    215186        check_app([common['STRIP'], "--version"], "GNU strip", details)
    216187
    217 def decode_value(value):
    218         "Decode integer value"
    219        
    220         base = 10
    221        
    222         if ((value.startswith('$')) or (value.startswith('#'))):
    223                 value = value[1:]
    224        
    225         if (value.startswith('0x')):
    226                 value = value[2:]
    227                 base = 16
    228        
    229         return int(value, base)
    230 
    231188def probe_compiler(common, sizes):
    232189        "Generate, compile and parse probing source"
     
    280237        signed_concs = {}
    281238       
    282         builtins = {}
    283        
    284239        for j in range(len(lines)):
    285240                tokens = lines[j].strip().split("\t")
     
    299254                               
    300255                                if (category == "intsize"):
     256                                        base = 10
     257                                       
     258                                        if ((value.startswith('$')) or (value.startswith('#'))):
     259                                                value = value[1:]
     260                                       
     261                                        if (value.startswith('0x')):
     262                                                value = value[2:]
     263                                                base = 16
     264                                       
    301265                                        try:
    302                                                 value_int = decode_value(value)
     266                                                value_int = int(value, base)
    303267                                        except:
    304268                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    305269                                       
    306270                                        if (subcategory == "unsigned"):
    307                                                 unsigned_sizes[value_int] = name
     271                                                unsigned_sizes[name] = value_int
    308272                                                unsigned_tags[tag] = value_int
    309                                                 unsigned_strcs[value_int] = strc
    310                                                 unsigned_concs[value_int] = conc
     273                                                unsigned_strcs[strc] = value_int
     274                                                unsigned_concs[conc] = value_int
    311275                                        elif (subcategory == "signed"):
    312                                                 signed_sizes[value_int] = name
     276                                                signed_sizes[name] = value_int
    313277                                                signed_tags[tag] = value_int
    314                                                 signed_strcs[value_int] = strc
    315                                                 signed_concs[value_int] = conc
     278                                                signed_strcs[strc] = value_int
     279                                                signed_concs[conc] = value_int
    316280                                        else:
    317281                                                print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
    318                                
    319                                 if (category == "builtin"):
    320                                         try:
    321                                                 value_int = decode_value(value)
    322                                         except:
    323                                                 print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
    324                                        
    325                                         builtins[tag] = {'name': name, 'value': value_int}
    326        
    327         return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'builtins': builtins}
    328 
    329 def detect_uints(probe, bytes, tags):
     282       
     283        return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs}
     284
     285def detect_uints(probe, bytes):
    330286        "Detect correct types for fixed-size integer types"
    331287       
     
    334290       
    335291        for b in bytes:
    336                 if (not b in probe['unsigned_sizes']):
     292                fnd = False
     293                for name, value in probe['unsigned_sizes'].items():
     294                        if (value == b):
     295                                typedefs.append({'oldtype': "unsigned %s" % name, 'newtype': "uint%u_t" % (b * 8)})
     296                                fnd = True
     297                                break
     298               
     299                if (not fnd):
    337300                        print_error(['Unable to find appropriate unsigned integer type for %u bytes' % b,
    338301                                     COMPILER_FAIL])
    339302               
    340                 if (not b in probe['signed_sizes']):
     303               
     304                fnd = False
     305                for name, value in probe['signed_sizes'].items():
     306                        if (value == b):
     307                                typedefs.append({'oldtype': "signed %s" % name, 'newtype': "int%u_t" % (b * 8)})
     308                                fnd = True
     309                                break
     310               
     311                if (not fnd):
    341312                        print_error(['Unable to find appropriate signed integer type for %u bytes' % b,
    342313                                     COMPILER_FAIL])
    343314               
    344                 if (not b in probe['unsigned_strcs']):
     315               
     316                fnd = False
     317                for name, value in probe['unsigned_strcs'].items():
     318                        if (value == b):
     319                                macros.append({'oldmacro': "\"%so\"" % name, 'newmacro': "PRIo%u" % (b * 8)})
     320                                macros.append({'oldmacro': "\"%su\"" % name, 'newmacro': "PRIu%u" % (b * 8)})
     321                                macros.append({'oldmacro': "\"%sx\"" % name, 'newmacro': "PRIx%u" % (b * 8)})
     322                                macros.append({'oldmacro': "\"%sX\"" % name, 'newmacro': "PRIX%u" % (b * 8)})
     323                                fnd = True
     324                                break
     325               
     326                if (not fnd):
    345327                        print_error(['Unable to find appropriate unsigned printf formatter for %u bytes' % b,
    346328                                     COMPILER_FAIL])
    347329               
    348                 if (not b in probe['signed_strcs']):
     330               
     331                fnd = False
     332                for name, value in probe['signed_strcs'].items():
     333                        if (value == b):
     334                                macros.append({'oldmacro': "\"%sd\"" % name, 'newmacro': "PRId%u" % (b * 8)})
     335                                fnd = True
     336                                break
     337               
     338                if (not fnd):
    349339                        print_error(['Unable to find appropriate signed printf formatter for %u bytes' % b,
    350340                                     COMPILER_FAIL])
    351341               
    352                 if (not b in probe['unsigned_concs']):
     342               
     343                fnd = False
     344                for name, value in probe['unsigned_concs'].items():
     345                        if (value == b):
     346                                if ((name.startswith('@')) or (name == "")):
     347                                        macros.append({'oldmacro': "c ## U", 'newmacro': "UINT%u_C(c)" % (b * 8)})
     348                                else:
     349                                        macros.append({'oldmacro': "c ## U%s" % name, 'newmacro': "UINT%u_C(c)" % (b * 8)})
     350                                fnd = True
     351                                break
     352               
     353                if (not fnd):
    353354                        print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
    354355                                     COMPILER_FAIL])
    355356               
    356                 if (not b in probe['signed_concs']):
    357                         print_error(['Unable to find appropriate signed literal macro for %u bytes' % b,
    358                                      COMPILER_FAIL])
    359                
    360                 typedefs.append({'oldtype': "unsigned %s" % probe['unsigned_sizes'][b], 'newtype': "uint%u_t" % (b * 8)})
    361                 typedefs.append({'oldtype': "signed %s" % probe['signed_sizes'][b], 'newtype': "int%u_t" % (b * 8)})
    362                
    363                 macros.append({'oldmacro': "\"%so\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIo%u" % (b * 8)})
    364                 macros.append({'oldmacro': "\"%su\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIu%u" % (b * 8)})
    365                 macros.append({'oldmacro': "\"%sx\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIx%u" % (b * 8)})
    366                 macros.append({'oldmacro': "\"%sX\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIX%u" % (b * 8)})
    367                 macros.append({'oldmacro': "\"%sd\"" % probe['signed_strcs'][b], 'newmacro': "PRId%u" % (b * 8)})
    368                
    369                 name = probe['unsigned_concs'][b]
    370                 if ((name.startswith('@')) or (name == "")):
    371                         macros.append({'oldmacro': "c ## U", 'newmacro': "UINT%u_C(c)" % (b * 8)})
    372                 else:
    373                         macros.append({'oldmacro': "c ## U%s" % name, 'newmacro': "UINT%u_C(c)" % (b * 8)})
    374                
    375                 name = probe['unsigned_concs'][b]
    376                 if ((name.startswith('@')) or (name == "")):
    377                         macros.append({'oldmacro': "c", 'newmacro': "INT%u_C(c)" % (b * 8)})
    378                 else:
    379                         macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
    380        
    381         for tag in tags:
     357               
     358                fnd = False
     359                for name, value in probe['signed_concs'].items():
     360                        if (value == b):
     361                                if ((name.startswith('@')) or (name == "")):
     362                                        macros.append({'oldmacro': "c", 'newmacro': "INT%u_C(c)" % (b * 8)})
     363                                else:
     364                                        macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
     365                                fnd = True
     366                                break
     367               
     368                if (not fnd):
     369                        print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
     370                                     COMPILER_FAIL])
     371       
     372        for tag in ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG']:
     373                fnd = False;
    382374                newmacro = "U%s" % tag
    383                 if (not tag in probe['unsigned_tags']):
     375               
     376                for name, value in probe['unsigned_tags'].items():
     377                        if (name == tag):
     378                                oldmacro = "UINT%s" % (value * 8)
     379                                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
     380                                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
     381                                fnd = True
     382                                break
     383               
     384                if (not fnd):
    384385                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
    385386                                     COMPILER_FAIL])
    386387               
    387                 oldmacro = "UINT%s" % (probe['unsigned_tags'][tag] * 8)
    388                 macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    389                 macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
    390                
     388                fnd = False;
    391389                newmacro = tag
    392                 if (not tag in probe['unsigned_tags']):
     390               
     391                for name, value in probe['signed_tags'].items():
     392                        if (name == tag):
     393                                oldmacro = "INT%s" % (value * 8)
     394                                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
     395                                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
     396                                fnd = True
     397                                break
     398               
     399                if (not fnd):
    393400                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
    394401                                     COMPILER_FAIL])
    395                
    396                 oldmacro = "INT%s" % (probe['signed_tags'][tag] * 8)
    397                 macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
    398                 macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
    399        
    400         fnd = True
    401        
    402         if (not 'wchar' in probe['builtins']):
    403                 print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
    404                                'for defining the compiler-native type wchar_t. We are',
    405                                'forced to define wchar_t as a hardwired type int32_t.',
    406                                COMPILER_WARNING])
    407                 fnd = False
    408        
    409         if (probe['builtins']['wchar']['value'] != 4):
    410                 print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
    411                                'the compiler-native type wchar_t is not compliant with',
    412                                'HelenOS. We are forced to define wchar_t as a hardwired',
    413                                'type int32_t.',
    414                                COMPILER_WARNING])
    415                 fnd = False
    416        
    417         if (not fnd):
    418                 macros.append({'oldmacro': "int32_t", 'newmacro': "wchar_t"})
    419         else:
    420                 macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
    421        
    422         fnd = True
    423        
    424         if (not 'wint' in probe['builtins']):
    425                 print_warning(['The compiler does not provide the macro __WINT_TYPE__',
    426                                'for defining the compiler-native type wint_t. We are',
    427                                'forced to define wint_t as a hardwired type int32_t.',
    428                                COMPILER_WARNING])
    429                 fnd = False
    430        
    431         if (probe['builtins']['wint']['value'] != 4):
    432                 print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
    433                                'the compiler-native type wint_t is not compliant with',
    434                                'HelenOS. We are forced to define wint_t as a hardwired',
    435                                'type int32_t.',
    436                                COMPILER_WARNING])
    437                 fnd = False
    438        
    439         if (not fnd):
    440                 macros.append({'oldmacro': "int32_t", 'newmacro': "wint_t"})
    441         else:
    442                 macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
    443402       
    444403        return {'macros': macros, 'typedefs': typedefs}
     
    612571                probe = probe_compiler(common,
    613572                        [
    614                                 {'type': 'long long int', 'tag': 'LLONG', 'strc': '"ll"', 'conc': '"LL"'},
     573                                {'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'},
     574                                {'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
     575                                {'type': 'int', 'tag': 'INT', 'strc': '""', 'conc': '""'},
    615576                                {'type': 'long int', 'tag': 'LONG', 'strc': '"l"', 'conc': '"L"'},
    616                                 {'type': 'int', 'tag': 'INT', 'strc': '""', 'conc': '""'},
    617                                 {'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
    618                                 {'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
     577                                {'type': 'long long int', 'tag': 'LLONG', 'strc': '"ll"', 'conc': '"LL"'}
    619578                        ]
    620579                )
    621580               
    622                 maps = detect_uints(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'])
     581                maps = detect_uints(probe, [1, 2, 4, 8])
    623582               
    624583        finally:
Note: See TracChangeset for help on using the changeset viewer.