buildtools/wafsamba/samba_autoconf.py

   1 # a waf tool to add autoconf-like macros to the configure section
   2
   3 import Build, os, Options, preproc, Logs
   4 import string
   5 from Configure import conf
   6 from samba_utils import *
   7 import samba_cross
   8
   9 missing_headers = set()
  10
  11 ####################################################
  12 # some autoconf like helpers, to make the transition
  13 # to waf a bit easier for those used to autoconf
  14 # m4 files
  15
  16 @runonce
  17 @conf
  18 def DEFINE(conf, d, v, add_to_cflags=False, quote=False):
  19     '''define a config option'''
  20     conf.define(d, v, quote=quote)
  21     if add_to_cflags:
  22         conf.env.append_value('CCDEFINES', d + '=' + str(v))
  23
  24 def hlist_to_string(conf, headers=None):
  25     '''convert a headers list to a set of #include lines'''
  26     hdrs=''
  27     hlist = conf.env.hlist
  28     if headers:
  29         hlist = hlist[:]
  30         hlist.extend(TO_LIST(headers))
  31     for h in hlist:
  32         hdrs += '#include <%s>\n' % h
  33     return hdrs
  34
  35
  36 @conf
  37 def COMPOUND_START(conf, msg):
  38     '''start a compound test'''
  39     def null_check_message_1(self,*k,**kw):
  40         return
  41     def null_check_message_2(self,*k,**kw):
  42         return
  43
  44     v = getattr(conf.env, 'in_compound', [])
  45     if v != [] and v != 0:
  46         conf.env.in_compound = v + 1
  47         return
  48     conf.check_message_1(msg)
  49     conf.saved_check_message_1 = conf.check_message_1
  50     conf.check_message_1 = null_check_message_1
  51     conf.saved_check_message_2 = conf.check_message_2
  52     conf.check_message_2 = null_check_message_2
  53     conf.env.in_compound = 1
  54
  55
  56 @conf
  57 def COMPOUND_END(conf, result):
  58     '''start a compound test'''
  59     conf.env.in_compound -= 1
  60     if conf.env.in_compound != 0:
  61         return
  62     conf.check_message_1 = conf.saved_check_message_1
  63     conf.check_message_2 = conf.saved_check_message_2
  64     p = conf.check_message_2
  65     if result == True:
  66         p('ok ')
  67     elif result == False:
  68         p('not found', 'YELLOW')
  69     else:
  70         p(result)
  71
  72
  73 @feature('nolink')
  74 def nolink(self):
  75     '''using the nolink type in conf.check() allows us to avoid
  76        the link stage of a test, thus speeding it up for tests
  77        that where linking is not needed'''
  78     pass
  79
  80
  81 def CHECK_HEADER(conf, h, add_headers=False, lib=None):
  82     '''check for a header'''
  83     if h in missing_headers:
  84         return False
  85     d = h.upper().replace('/', '_')
  86     d = d.replace('.', '_')
  87     d = d.replace('-', '_')
  88     d = 'HAVE_%s' % d
  89     if CONFIG_SET(conf, d):
  90         if add_headers:
  91             if not h in conf.env.hlist:
  92                 conf.env.hlist.append(h)
  93         return True
  94
  95     (ccflags, ldflags) = library_flags(conf, lib)
  96
  97     hdrs = hlist_to_string(conf, headers=h)
  98     ret = conf.check(fragment='%s\nint main(void) { return 0; }' % hdrs,
  99                      type='nolink',
 100                      execute=0,
 101                      ccflags=ccflags,
 102                      msg="Checking for header %s" % h)
 103     if not ret:
 104         missing_headers.add(h)
 105         return False
 106
 107     conf.DEFINE(d, 1)
 108     if add_headers and not h in conf.env.hlist:
 109         conf.env.hlist.append(h)
 110     return ret
 111
 112
 113 @conf
 114 def CHECK_HEADERS(conf, headers, add_headers=False, together=False, lib=None):
 115     '''check for a list of headers
 116
 117     when together==True, then the headers accumulate within this test.
 118     This is useful for interdependent headers
 119     '''
 120     ret = True
 121     if not add_headers and together:
 122         saved_hlist = conf.env.hlist[:]
 123         set_add_headers = True
 124     else:
 125         set_add_headers = add_headers
 126     for hdr in TO_LIST(headers):
 127         if not CHECK_HEADER(conf, hdr, set_add_headers, lib=lib):
 128             ret = False
 129     if not add_headers and together:
 130         conf.env.hlist = saved_hlist
 131     return ret
 132
 133
 134 def header_list(conf, headers=None, lib=None):
 135     '''form a list of headers which exist, as a string'''
 136     hlist=[]
 137     if headers is not None:
 138         for h in TO_LIST(headers):
 139             if CHECK_HEADER(conf, h, add_headers=False, lib=lib):
 140                 hlist.append(h)
 141     return hlist_to_string(conf, headers=hlist)
 142
 143
 144 @conf
 145 def CHECK_TYPE(conf, t, alternate=None, headers=None, define=None, lib=None, msg=None):
 146     '''check for a single type'''
 147     if define is None:
 148         define = 'HAVE_' + t.upper().replace(' ', '_')
 149     if msg is None:
 150         msg='Checking for %s' % t
 151     ret = CHECK_CODE(conf, '%s _x' % t,
 152                      define,
 153                      execute=False,
 154                      headers=headers,
 155                      local_include=False,
 156                      msg=msg,
 157                      lib=lib,
 158                      link=False)
 159     if not ret and alternate:
 160         conf.DEFINE(t, alternate)
 161     return ret
 162
 163
 164 @conf
 165 def CHECK_TYPES(conf, list, headers=None, define=None, alternate=None, lib=None):
 166     '''check for a list of types'''
 167     ret = True
 168     for t in TO_LIST(list):
 169         if not CHECK_TYPE(conf, t, headers=headers,
 170                           define=define, alternate=alternate, lib=lib):
 171             ret = False
 172     return ret
 173
 174
 175 @conf
 176 def CHECK_TYPE_IN(conf, t, headers=None, alternate=None, define=None):
 177     '''check for a single type with a header'''
 178     return CHECK_TYPE(conf, t, headers=headers, alternate=alternate, define=define)
 179
 180
 181 @conf
 182 def CHECK_VARIABLE(conf, v, define=None, always=False,
 183                    headers=None, msg=None, lib=None):
 184     '''check for a variable declaration (or define)'''
 185     if define is None:
 186         define = 'HAVE_%s' % v.upper()
 187
 188     if msg is None:
 189         msg="Checking for variable %s" % v
 190
 191     return CHECK_CODE(conf,
 192                       # we need to make sure the compiler doesn't
 193                       # optimize it out...
 194                       '''
 195                       #ifndef %s
 196                       void *_x; _x=(void *)&%s; return (int)_x;
 197                       #endif
 198                       return 0
 199                       ''' % (v, v),
 200                       execute=False,
 201                       link=False,
 202                       msg=msg,
 203                       local_include=False,
 204                       lib=lib,
 205                       headers=headers,
 206                       define=define,
 207                       always=always)
 208
 209
 210 @conf
 211 def CHECK_DECLS(conf, vars, reverse=False, headers=None, always=False):
 212     '''check a list of variable declarations, using the HAVE_DECL_xxx form
 213        of define
 214
 215        When reverse==True then use HAVE_xxx_DECL instead of HAVE_DECL_xxx
 216        '''
 217     ret = True
 218     for v in TO_LIST(vars):
 219         if not reverse:
 220             define='HAVE_DECL_%s' % v.upper()
 221         else:
 222             define='HAVE_%s_DECL' % v.upper()
 223         if not CHECK_VARIABLE(conf, v,
 224                               define=define,
 225                               headers=headers,
 226                               msg='Checking for declaration of %s' % v,
 227                               always=always):
 228             ret = False
 229     return ret
 230
 231
 232 def CHECK_FUNC(conf, f, link=True, lib=None, headers=None):
 233     '''check for a function'''
 234     define='HAVE_%s' % f.upper()
 235
 236     ret = False
 237
 238     conf.COMPOUND_START('Checking for %s' % f)
 239
 240     if link is None or link == True:
 241         ret = CHECK_CODE(conf,
 242                          # this is based on the autoconf strategy
 243                          '''
 244                          #define %s __fake__%s
 245                          #ifdef HAVE_LIMITS_H
 246                          # include <limits.h>
 247                          #else
 248                          # include <assert.h>
 249                          #endif
 250                          #undef %s
 251                          #if defined __stub_%s || defined __stub___%s
 252                          #error "bad glibc stub"
 253                          #endif
 254                          extern char %s();
 255                          int main() { return %s(); }
 256                          ''' % (f, f, f, f, f, f, f),
 257                          execute=False,
 258                          link=True,
 259                          addmain=False,
 260                          add_headers=False,
 261                          define=define,
 262                          local_include=False,
 263                          lib=lib,
 264                          headers=headers,
 265                          msg='Checking for %s' % f)
 266
 267         if not ret:
 268             ret = CHECK_CODE(conf,
 269                              # it might be a macro
 270                              # we need to make sure the compiler doesn't
 271                              # optimize it out...
 272                              'void *__x = (void *)%s; return (int)__x' % f,
 273                              execute=False,
 274                              link=True,
 275                              addmain=True,
 276                              add_headers=True,
 277                              define=define,
 278                              local_include=False,
 279                              lib=lib,
 280                              headers=headers,
 281                              msg='Checking for macro %s' % f)
 282
 283     if not ret and (link is None or link == False):
 284         ret = CHECK_VARIABLE(conf, f,
 285                              define=define,
 286                              headers=headers,
 287                              msg='Checking for declaration of %s' % f)
 288     conf.COMPOUND_END(ret)
 289     return ret
 290
 291
 292 @conf
 293 def CHECK_FUNCS(conf, list, link=True, lib=None, headers=None):
 294     '''check for a list of functions'''
 295     ret = True
 296     for f in TO_LIST(list):
 297         if not CHECK_FUNC(conf, f, link=link, lib=lib, headers=headers):
 298             ret = False
 299     return ret
 300
 301
 302 @conf
 303 def CHECK_SIZEOF(conf, vars, headers=None, define=None):
 304     '''check the size of a type'''
 305     ret = True
 306     for v in TO_LIST(vars):
 307         v_define = define
 308         if v_define is None:
 309             v_define = 'SIZEOF_%s' % v.upper().replace(' ', '_')
 310         if not CHECK_CODE(conf,
 311                           'printf("%%u", (unsigned)sizeof(%s))' % v,
 312                           define=v_define,
 313                           execute=True,
 314                           define_ret=True,
 315                           quote=False,
 316                           headers=headers,
 317                           local_include=False,
 318                           msg="Checking size of %s" % v):
 319             ret = False
 320     return ret
 321
 322
 323
 324 @conf
 325 def CHECK_CODE(conf, code, define,
 326                always=False, execute=False, addmain=True,
 327                add_headers=True, mandatory=False,
 328                headers=None, msg=None, cflags='', includes='# .',
 329                local_include=True, lib=None, link=True,
 330                define_ret=False, quote=False,
 331                on_target=True):
 332     '''check if some code compiles and/or runs'''
 333
 334     if CONFIG_SET(conf, define):
 335         return True
 336
 337     if headers is not None:
 338         CHECK_HEADERS(conf, headers=headers, lib=lib)
 339
 340     if add_headers:
 341         hdrs = header_list(conf, headers=headers, lib=lib)
 342     else:
 343         hdrs = ''
 344     if execute:
 345         execute = 1
 346     else:
 347         execute = 0
 348
 349     defs = conf.get_config_header()
 350
 351     if addmain:
 352         fragment='%s\n%s\n int main(void) { %s; return 0; }\n' % (defs, hdrs, code)
 353     else:
 354         fragment='%s\n%s\n%s\n' % (defs, hdrs, code)
 355
 356     if msg is None:
 357         msg="Checking for %s" % define
 358
 359     cflags = TO_LIST(cflags)
 360
 361     if local_include:
 362         cflags.append('-I%s' % conf.curdir)
 363
 364     if not link:
 365         type='nolink'
 366     else:
 367         type='cprogram'
 368
 369     uselib = TO_LIST(lib)
 370
 371     (ccflags, ldflags) = library_flags(conf, uselib)
 372
 373     cflags.extend(ccflags)
 374
 375     if on_target:
 376         exec_args = conf.SAMBA_CROSS_ARGS(msg=msg)
 377     else:
 378         exec_args = []
 379
 380     conf.COMPOUND_START(msg)
 381
 382     ret = conf.check(fragment=fragment,
 383                      execute=execute,
 384                      define_name = define,
 385                      mandatory = mandatory,
 386                      ccflags=cflags,
 387                      ldflags=ldflags,
 388                      includes=includes,
 389                      uselib=uselib,
 390                      type=type,
 391                      msg=msg,
 392                      quote=quote,
 393                      exec_args=exec_args,
 394                      define_ret=define_ret)
 395     if not ret and CONFIG_SET(conf, define):
 396         # sometimes conf.check() returns false, but it
 397         # sets the define. Maybe a waf bug?
 398         ret = True
 399     if ret:
 400         if not define_ret:
 401             conf.DEFINE(define, 1)
 402             conf.COMPOUND_END(True)
 403         else:
 404             conf.COMPOUND_END(conf.env[define])
 405         return True
 406     if always:
 407         conf.DEFINE(define, 0)
 408     conf.COMPOUND_END(False)
 409     return False
 410
 411
 412
 413 @conf
 414 def CHECK_STRUCTURE_MEMBER(conf, structname, member,
 415                            always=False, define=None, headers=None):
 416     '''check for a structure member'''
 417     if define is None:
 418         define = 'HAVE_%s' % member.upper()
 419     return CHECK_CODE(conf,
 420                       '%s s; void *_x; _x=(void *)&s.%s' % (structname, member),
 421                       define,
 422                       execute=False,
 423                       link=False,
 424                       always=always,
 425                       headers=headers,
 426                       local_include=False,
 427                       msg="Checking for member %s in %s" % (member, structname))
 428
 429
 430 @conf
 431 def CHECK_CFLAGS(conf, cflags):
 432     '''check if the given cflags are accepted by the compiler
 433     '''
 434     return conf.check(fragment='int main(void) { return 0; }\n',
 435                       execute=0,
 436                       type='nolink',
 437                       ccflags=cflags,
 438                       msg="Checking compiler accepts %s" % cflags)
 439
 440 @conf
 441 def CHECK_LDFLAGS(conf, ldflags):
 442     '''check if the given ldflags are accepted by the linker
 443     '''
 444     return conf.check(fragment='int main(void) { return 0; }\n',
 445                       execute=0,
 446                       ldflags=ldflags,
 447                       msg="Checking linker accepts %s" % ldflags)
 448
 449
 450 @conf
 451 def CONFIG_SET(conf, option):
 452     '''return True if a configuration option was found'''
 453     return (option in conf.env) and (conf.env[option] != ())
 454 Build.BuildContext.CONFIG_SET = CONFIG_SET
 455
 456
 457 def library_flags(conf, libs):
 458     '''work out flags from pkg_config'''
 459     ccflags = []
 460     ldflags = []
 461     for lib in TO_LIST(libs):
 462         inc_path = getattr(conf.env, 'CPPPATH_%s' % lib.upper(), [])
 463         lib_path = getattr(conf.env, 'LIBPATH_%s' % lib.upper(), [])
 464         ccflags.extend(['-I%s' % i for i in inc_path])
 465         ldflags.extend(['-L%s' % l for l in lib_path])
 466         extra_ccflags = TO_LIST(getattr(conf.env, 'CCFLAGS_%s' % lib.upper(), []))
 467         extra_ldflags = TO_LIST(getattr(conf.env, 'LDFLAGS_%s' % lib.upper(), []))
 468         ccflags.extend(extra_ccflags)
 469         ldflags.extend(extra_ldflags)
 470     if 'EXTRA_LDFLAGS' in conf.env:
 471         ldflags.extend(conf.env['EXTRA_LDFLAGS'])
 472     ccflags = unique_list(ccflags)
 473     ldflags = unique_list(ldflags)
 474     return (ccflags, ldflags)
 475
 476
 477 @conf
 478 def CHECK_LIB(conf, libs, mandatory=False, empty_decl=True, set_target=True, shlib=False):
 479     '''check if a set of libraries exist as system libraries
 480
 481     returns the sublist of libs that do exist as a syslib or []
 482     '''
 483
 484     fragment= '''
 485 int foo()
 486 {
 487     int v = 2;
 488     return v*2;
 489 }
 490 '''
 491     ret = []
 492     liblist  = TO_LIST(libs)
 493     for lib in liblist[:]:
 494         if GET_TARGET_TYPE(conf, lib) == 'SYSLIB':
 495             ret.append(lib)
 496             continue
 497
 498         (ccflags, ldflags) = library_flags(conf, lib)
 499         if shlib:
 500             res = conf.check(features='cc cshlib', fragment=fragment, lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags)
 501         else:
 502             res = conf.check(lib=lib, uselib_store=lib, ccflags=ccflags, ldflags=ldflags)
 503
 504         if not res:
 505             if mandatory:
 506                 Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 507                 sys.exit(1)
 508             if empty_decl:
 509                 # if it isn't a mandatory library, then remove it from dependency lists
 510                 if set_target:
 511                     SET_TARGET_TYPE(conf, lib, 'EMPTY')
 512         else:
 513             conf.define('HAVE_LIB%s' % lib.upper().replace('-','_'), 1)
 514             conf.env['LIB_' + lib.upper()] = lib
 515             if set_target:
 516                 conf.SET_TARGET_TYPE(lib, 'SYSLIB')
 517             ret.append(lib)
 518
 519     return ret
 520
 521
 522
 523 @conf
 524 def CHECK_FUNCS_IN(conf, list, library, mandatory=False, checklibc=False,
 525                    headers=None, link=True, empty_decl=True, set_target=True):
 526     """
 527     check that the functions in 'list' are available in 'library'
 528     if they are, then make that library available as a dependency
 529
 530     if the library is not available and mandatory==True, then
 531     raise an error.
 532
 533     If the library is not available and mandatory==False, then
 534     add the library to the list of dependencies to remove from
 535     build rules
 536
 537     optionally check for the functions first in libc
 538     """
 539     remaining = TO_LIST(list)
 540     liblist   = TO_LIST(library)
 541
 542     # check if some already found
 543     for f in remaining[:]:
 544         if CONFIG_SET(conf, 'HAVE_%s' % f.upper()):
 545             remaining.remove(f)
 546
 547     # see if the functions are in libc
 548     if checklibc:
 549         for f in remaining[:]:
 550             if CHECK_FUNC(conf, f, link=True, headers=headers):
 551                 remaining.remove(f)
 552
 553     if remaining == []:
 554         for lib in liblist:
 555             if GET_TARGET_TYPE(conf, lib) != 'SYSLIB' and empty_decl:
 556                 SET_TARGET_TYPE(conf, lib, 'EMPTY')
 557         return True
 558
 559     checklist = conf.CHECK_LIB(liblist, empty_decl=empty_decl, set_target=set_target)
 560     for lib in liblist[:]:
 561         if not lib in checklist and mandatory:
 562             Logs.error("Mandatory library '%s' not found for functions '%s'" % (lib, list))
 563             sys.exit(1)
 564
 565     ret = True
 566     for f in remaining:
 567         if not CHECK_FUNC(conf, f, lib=' '.join(checklist), headers=headers, link=link):
 568             ret = False
 569
 570     return ret
 571
 572
 573 @conf
 574 def IN_LAUNCH_DIR(conf):
 575     '''return True if this rule is being run from the launch directory'''
 576     return os.path.realpath(conf.curdir) == os.path.realpath(Options.launch_dir)
 577 Options.Handler.IN_LAUNCH_DIR = IN_LAUNCH_DIR
 578
 579
 580 @conf
 581 def SAMBA_CONFIG_H(conf, path=None):
 582     '''write out config.h in the right directory'''
 583     # we don't want to produce a config.h in places like lib/replace
 584     # when we are building projects that depend on lib/replace
 585     if not IN_LAUNCH_DIR(conf):
 586         return
 587
 588     if Options.options.developer:
 589         # we add these here to ensure that -Wstrict-prototypes is not set during configure
 590         conf.ADD_CFLAGS('-Wall -g -Wshadow -Wstrict-prototypes -Wpointer-arith -Wcast-qual -Wcast-align -Wwrite-strings -Werror-implicit-function-declaration -Wformat=2 -Wno-format-y2k -Wmissing-prototypes',
 591                         testflags=True)
 592         conf.env.DEVELOPER_MODE = True
 593
 594     if Options.options.picky_developer:
 595         conf.ADD_CFLAGS('-Werror', testflags=True)
 596
 597     if Options.options.fatal_errors:
 598         conf.ADD_CFLAGS('-Wfatal-errors', testflags=True)
 599
 600     if Options.options.pedantic:
 601         conf.ADD_CFLAGS('-W', testflags=True)
 602
 603     if path is None:
 604         conf.write_config_header('config.h', top=True)
 605     else:
 606         conf.write_config_header(path)
 607     conf.SAMBA_CROSS_CHECK_COMPLETE()
 608
 609
 610 @conf
 611 def CONFIG_PATH(conf, name, default):
 612     '''setup a configurable path'''
 613     if not name in conf.env:
 614         if default[0] == '/':
 615             conf.env[name] = default
 616         else:
 617             conf.env[name] = conf.env['PREFIX'] + default
 618
 619 @conf
 620 def ADD_CFLAGS(conf, flags, testflags=False):
 621     '''add some CFLAGS to the command line
 622        optionally set testflags to ensure all the flags work
 623     '''
 624     if testflags:
 625         ok_flags=[]
 626         for f in flags.split():
 627             if CHECK_CFLAGS(conf, f):
 628                 ok_flags.append(f)
 629         flags = ok_flags
 630     if not 'EXTRA_CFLAGS' in conf.env:
 631         conf.env['EXTRA_CFLAGS'] = []
 632     conf.env['EXTRA_CFLAGS'].extend(TO_LIST(flags))
 633
 634 @conf
 635 def ADD_LDFLAGS(conf, flags, testflags=False):
 636     '''add some LDFLAGS to the command line
 637        optionally set testflags to ensure all the flags work
 638     '''
 639     if testflags:
 640         ok_flags=[]
 641         for f in flags.split():
 642             if CHECK_LDFLAGS(conf, f):
 643                 ok_flags.append(f)
 644         flags = ok_flags
 645     if not 'EXTRA_LDFLAGS' in conf.env:
 646         conf.env['EXTRA_LDFLAGS'] = []
 647     conf.env['EXTRA_LDFLAGS'].extend(TO_LIST(flags))
 648
 649
 650
 651 @conf
 652 def ADD_EXTRA_INCLUDES(conf, includes):
 653     '''add some extra include directories to all builds'''
 654     if not 'EXTRA_INCLUDES' in conf.env:
 655         conf.env['EXTRA_INCLUDES'] = []
 656     conf.env['EXTRA_INCLUDES'].extend(TO_LIST(includes))
 657
 658
 659
 660 def CURRENT_CFLAGS(bld, target, cflags, hide_symbols=False):
 661     '''work out the current flags. local flags are added first'''
 662     if not 'EXTRA_CFLAGS' in bld.env:
 663         list = []
 664     else:
 665         list = bld.env['EXTRA_CFLAGS'];
 666     ret = TO_LIST(cflags)
 667     ret.extend(list)
 668     if hide_symbols and bld.env.HAVE_VISIBILITY_ATTR:
 669         ret.append('-fvisibility=hidden')
 670     return ret
 671
 672
 673 @conf
 674 def CHECK_CC_ENV(conf):
 675     """trim whitespaces from 'CC'.
 676     The build farm sometimes puts a space at the start"""
 677     if os.environ.get('CC'):
 678         conf.env.CC = TO_LIST(os.environ.get('CC'))
 679         if len(conf.env.CC) == 1:
 680             # make for nicer logs if just a single command
 681             conf.env.CC = conf.env.CC[0]
 682
 683
 684 @conf
 685 def SETUP_CONFIGURE_CACHE(conf, enable):
 686     '''enable/disable cache of configure results'''
 687     if enable:
 688         # when -C is chosen, we will use a private cache and will
 689         # not look into system includes. This roughtly matches what
 690         # autoconf does with -C
 691         cache_path = os.path.join(conf.blddir, '.confcache')
 692         mkdir_p(cache_path)
 693         Options.cache_global = os.environ['WAFCACHE'] = cache_path
 694     else:
 695         # when -C is not chosen we will not cache configure checks
 696         # We set the recursion limit low to prevent waf from spending
 697         # a lot of time on the signatures of the files.
 698         Options.cache_global = os.environ['WAFCACHE'] = ''
 699         preproc.recursion_limit = 1
 700     # in either case we don't need to scan system includes
 701     preproc.go_absolute = False