def examples_work(env): """External entry point for non-command line invocations. Initialize the environment, build libxed, the examples, the kit and run the tests""" xbc.prep(env) verify_args(env) start_time = mbuild.get_time() xbc.init_once(env) init(env) if 'clean' in env['targets'] or env['clean']: xbc.xed_remove_files_glob(env) if len(env['targets']) <= 1: xbc.cexit(0) mbuild.cmkdir(env['build_dir']) work_queue = mbuild.work_queue_t(env['jobs']) xbc.get_libxed_names(env, work_queue) retval = build_examples(env, work_queue) end_time = mbuild.get_time() mbuild.msgb("EXAMPLES BUILD ELAPSED TIME", mbuild.get_elapsed_time(start_time, end_time)) return retval
def setup(env): mbuild.msgb("Using build_kit.setup") init_common_requirements(env) locate_pin_tree(env) init_pin_environment_compile(env) if not env['standalone_program']: init_pintool_environment_link(env) init_pintool_compiler_env(env)
def early_init(env, build_kit=False): """Called before parsing knobs for early init""" mbuild.msgb("Using build_kit.early_init") knobs(env) if not build_kit: #The buildkit's mfile is using this script as well. #The buildkit does not need the build_config information #and does not have access to it. So we import it only here. import build_config env['kit_info'] = build_config.kit_info()
def _test_map_all_zero(vv, phash_map_lu): """phash_map_lu is a dict[maps][0...255] pointing to a 2nd level lookup or it might be None indicating an empty map.""" all_zero_map= collections.defaultdict(bool) # Default False for xmap in phash_map_lu.keys(): omap = phash_map_lu[xmap] if omap == None: all_zero_map[xmap]=True mbuild.msgb("ALL ZEROS", "VV={} MAP={}".format(vv, xmap)) return all_zero_map
def work(): env = mbuild.env_t() env.parser.add_option( "--bulk-make-tests", "-b", dest="bulk_tests", action="append", default=[], help= "List of bulk tests from which to create test references. Repeatable") env.parser.add_option( "--rebase-tests", dest="rebase_tests", action="store_true", default=False, help="Update the reference output files. Do not compare.") env.parser.add_option("--tests", dest="tests", action="append", default=[], help="Directory where tests live.") env.parser.add_option("--otests", dest="otests", action="store", default='tests-base', help="Directory where tests live.") env.parser.add_option("-c", "--code", dest="codes", action="append", default=[], help="Codes for test subsetting (DEC, ENC, AVX, " + "AVX512X, AVX512PF, XOP, KNC)." + " Only used for running tests, not creating them.") env.parse_args() if not env['tests']: env['tests'] = ['tests-base'] xed = mbuild.join(env['build_dir'], 'xed') #xedexe = xed + ".exe" #if not os.path.exists(xed) and not os.path.exists(xedexe): # mbuild.die("Need the xed command line tool: %s or %s\n\n" % (xed,xedexe)) if len(env['bulk_tests']) != 0: mbuild.msgb("MAKE BULK TESTS") make_bulk_tests(env) sys.exit(0) if env['rebase_tests']: rebase_tests(env) sys.exit(0) errors = run_tests(env) sys.exit(errors)
def work(env): #with then env, the dag hash file is put in the build_dir. dag = mbuild.dag_t('circular-test', env=env) work_queue = mbuild.work_queue_t(env['jobs']) env.compile_and_link(dag, ['main.c'], 'main' + env['EXEEXT']) okay = work_queue.build(dag=dag) if not okay: mbuild.die("build failed") mbuild.msgb("SUCCESS")
def xed_remove_files_glob(env): """Clean up""" mbuild.msgb("CLEANING") try: if 'build_dir' in env: path = env['build_dir'] if path != '.' and path != '..': mbuild.remove_tree(path) return except: cdie("clean failed")
def init_pintool_compiler_env(env): if env['compiler'] == 'ms': init_ms_env_compile(env) if not env['standalone_program']: init_ms_env_link_tool(env) elif env['compiler'] in ['gnu', 'clang']: init_gnu_env_compile(env) if not env['standalone_program']: init_gnu_env_link_tool(env) else: mbuild.msgb("Unsupported compiler: %s" % (env['compiler']))
def locate_pin_tree(env): if 'pin' not in env: find_build_kit_path(env) env['pin'] = mbuild.join(env['build_kit_path'], 'pinkit') if not env['pin']: mbuild.die('Pin directory is not setup ' + 'properly in the environment {0}'.format(env['pin'])) if not os.path.exists(env['pin']): mbuild.die('cannot find the PIN directory: {0:s}'.format(env['pin'])) mbuild.msgb("FOUND PIN KIT", env['pin']) env['kit'] = True
def strip_file(env, fn, options=''): if env.on_windows(): return fne = env.expand(fn) mbuild.msgb("STRIPPING", fne) strip_cmd = " ".join([env['strip'], options, fne]) #mbuild.msgb("STRIP CMD", strip_cmd) (retcode, stdout, stderr) = mbuild.run_command(strip_cmd) if retcode != 0: dump_lines("strip stdout", stdout) dump_lines("strip stderr", stderr) cdie("Could not strip " + fne)
def find_path(cmd): mbuild.msgb("Checking location of %s (on PATH)" % (cmd)) path = os.getenv("PATH") for p in path.split(os.pathsep): f = os.path.join(p, cmd) if os.path.exists(f): return p # this relies on "which" being available.... cmd = "which %s" % (cmd) (retcode, stdout, stderr) = mbuild.run_command_unbufferred(cmd) if retcode == 0: return os.path.dirname(stdout[0]) return 'unknown'
def _build_doxygen_main(args, env): """Customize the doxygen input file. Run the doxygen command, copy in any images, and put the output in the right place.""" if type(args) is types.ListType: if len(args) < 2: mbuild.die( "Need subs dictionary and dummy file arg for the doxygen command " + "to indicate its processing") else: mbuild.die("Need a list for _build_doxygen_main with the subs " + "dictionary and the dummy file name") (subs, dummy_file) = args (doxygen_cmd, doxygen_okay) = _find_doxygen(env) if not doxygen_okay: msg = 'No good doxygen available on this system; ' + \ 'Your command line arguments\n\trequire it to be present. ' + \ 'Consider dropping the "doc" and "doc-build" options\n\t or ' + \ 'specify a path to doxygen with the --doxygen knob.\n\n\n' return (1, [msg]) # failure else: env['DOXYGEN'] = doxygen_cmd try: okay = _customize_doxygen_file(env, subs) except: mbuild.die("CUSTOMIZE DOXYGEN INPUT FILE FAILED") if not okay: return (1, ['Doxygen customization failed']) cmd = env['DOXYGEN'] + ' ' + \ env.escape_string(env['doxygen_config_customized']) if mbuild.verbose(1): mbuild.msgb("RUN DOXYGEN", cmd) (retval, output, error_output) = mbuild.run_command(cmd) for line in output: mbuild.msgb("DOX", line.rstrip()) if error_output: for line in error_output: mbuild.msgb("DOX-ERROR", line.rstrip()) if retval != 0: mbuild.msgb("DOXYGEN FAILED") mbuild.die("Doxygen run failed. Retval=", str(retval)) mbuild.touch(dummy_file) mbuild.msgb("DOXYGEN", "succeeded") return (0, []) # success
def copy_system_libraries(env, kitdir, files, extra_ld_library_paths=[]): """copy system libraries to kit on Linux systems. Return True on success.""" # Make a temporary environment for running ldd that includes any required # LD_LIBRARY_PATH additions. osenv = None if extra_ld_library_paths: osenv = copy.deepcopy(os.environ) s = None if 'LD_LIBRARY_PATH' in osenv: s = osenv['LD_LIBRARY_PATH'] osenv['LD_LIBRARY_PATH'] = ":".join(extra_ld_library_paths) if s: osenv['LD_LIBRARY_PATH'] += ":" + s okay = True if env.on_linux() or env.on_freebsd() or env.on_netbsd(): system_libraries = set() for binary_executable in files: if os.path.exists(binary_executable): (retval, lines, stderr) = mbuild.run_command( "ldd {}".format(binary_executable), osenv=osenv) for line in lines: line = line.rstrip() print("\t{}".format(line)) if retval != 0: # error handling if len(lines) >= 1: if lines[0].find("not a dynamic executable") != -1: continue elif lines[0].find( "not a dynamic ELF executable") != -1: continue mbuild.warn("Could not run ldd on [%s]" % binary_executable) return False if env.on_freebsd() or env.on_netbsd(): lines = lines[1:] ldd_okay, files = _grab_ldd_libraries(lines) if not ldd_okay: okay = False for lib in files: if not _file_to_avoid(env, lib): system_libraries.add(lib) for slib in system_libraries: mbuild.msgb("TO COPY", slib) for slib in system_libraries: mbuild.copy_file(src=slib, tgt=kitdir) return okay
def find_build_kit_path(env): if 'build_kit_path' not in env: try: env['build_kit_path'] = os.getenv("SDE_BUILD_KIT") mbuild.msgb("SDE_BUILD_KIT env var", env['build_kit_path']) except: mbuild.die("Could not find SDE_BUILD_KIT in the shell environment") if not env['build_kit_path']: mbuild.die("Could not find build_kit_path is not set properly") if os.path.exists(env['build_kit_path']): return mbuild.die("Could not find build kit at {0:s}".format( env['build_kit_path']))
def _greater_than_gcc(env,amaj,amin,aver): gcc = env.expand('%(CC)s') vstr = mbuild.get_gcc_version(gcc) mbuild.msgb("GCC VERSION", vstr) try: (vmaj, vmin, vver) = vstr.split('.') except: return False if vmaj > amaj: return True if vmaj == amaj and vmin > amin: return True if vmaj == amaj and vmin == amin and vver >= aver: return True return False
def _make_doxygen_reference_manual(env, doxygen_inputs, subs, work_queue, hash_file_name='dox'): """Install the doxygen reference manual the doyxgen_output_dir directory. doxygen_inputs is a list of files """ dox_dag = mbuild.dag_t(hash_file_name, env=env) # so that the scanner can find them dirs = {} for f in doxygen_inputs: dirs[os.path.dirname(f)] = True for d in dirs.iterkeys(): env.add_include_dir(d) # make sure the config and top file are in the inptus list doxygen_inputs.append(env['doxygen_config']) doxygen_inputs.append(env['doxygen_top_src']) dummy = env.build_dir_join('dummy-doxygen-' + hash_file_name) # Run it via the builder to make it dependence driven run_always = False if _empty_dir(env['doxygen_install']): run_always = True if run_always: _build_doxygen_main([subs, dummy], env) else: c1 = mbuild.plan_t(command=_build_doxygen_main, args=[subs, dummy], env=env, input=doxygen_inputs, output=dummy) dox1 = dox_dag.add(env, c1) okay = work_queue.build(dag=dox_dag) phase = "DOXYGEN" if not okay: mbuild.die("[%s] failed. dying..." % phase) if mbuild.verbose(1): mbuild.msgb(phase, "build succeeded")
def _test_map_all_zero(vv, phash_map_lu): """phash_map_lu is a dict[maps][0...255] pointing to a 2nd level lookup """ all_zero_map = {} for xmap in list(phash_map_lu.keys()): omap = phash_map_lu[xmap] all_zero = True for i in range(0, 256): value = omap[hex(i)] #mbuild.msgb("MAP VAL", "VV={} MAP={} OPCODE={} VALUE={}".format( # vv, xmap, i, value)) if value != '(xed3_find_func_t)0': all_zero = False break if all_zero: mbuild.msgb("ALL ZEROS", "VV={} MAP={}".format(vv, xmap)) all_zero_map[xmap] = True else: all_zero_map[xmap] = False return all_zero_map
def cond_add_elf_dwarf(env): "Set up for using libelf/libdwarf on linux." if 'ext_libs' not in env: env['ext_libs'] = [] if env['use_elf_dwarf']: if not env.on_linux(): die("No libelf/dwarf for this platform") else: return mbuild.msgb("ADDING ELF/DWARF") # set up the preprocessor define and linker requirements. _use_elf_dwarf(env) if env['use_elf_dwarf_precompiled']: mbuild.msgb("ADDING ELF/DWARF PRECOMPILED") _add_elf_dwarf_precompiled(env) else: env.add_include_dir('/usr/include/libdwarf')
def cond_add_elf_dwarf(env): "Set up for using libelf/libdwarf on linux." if 'ext_libs' not in env: env['ext_libs'] = [] if env['use_elf_dwarf']: if not env.on_linux(): die("No libelf/dwarf for this platform") else: return mbuild.msgb("ADDING ELF/DWARF") # set up the preprocessor define and linker requirements. _use_elf_dwarf(env) if not env['use_elf_dwarf_precompiled']: # presumably the user is supplying their own & setting rpaths, etc. return mbuild.msgb("ADDING ELF/DWARF PRECOMPILED") _add_elf_dwarf_precompiled(env)
def one_test(env,test_dir): cmd_fn = os.path.join(test_dir,"cmd") cmd = open(cmd_fn,'r').readlines()[0] # abspath required for windoze build_dir = mbuild.posix_slashes(os.path.abspath(env['build_dir'])) cmd2 = re.sub('BUILDDIR',build_dir,cmd) cmd2 = cmd2.strip() print(cmd2) (retcode, stdout,stderr) = mbuild.run_command(cmd2,separate_stderr=True) print("Retcode %s" % (str(retcode))) if stdout: stdout = _prep_stream(stdout,"STDOUT") if stderr: stderr = _prep_stream(stderr,"STDERR") ret_match = compare_file(os.path.join(test_dir,"retcode.reference"), [ str(retcode) ]) stdout_match = compare_file(os.path.join(test_dir,"stdout.reference"), stdout) stderr_match = compare_file(os.path.join(test_dir,"stderr.reference"), stderr) okay = True if not ret_match: mbuild.msgb("RETCODE MISMATCH") okay = False if not stdout_match: mbuild.msgb("STDOUT MISMATCH") okay = False if not stderr_match: mbuild.msgb("STDERR MISMATCH") okay = False print("-"*40 + "\n\n\n") return okay
def _modify_search_path_mac(env, fn): """Make example tools refer to the libxed.so from the lib directory if doing and install. Mac only.""" if not env['shared']: return if not env.on_mac(): return if not installing(env): return env['odll'] = '%(build_dir)s/libxed.dylib' env['ndll'] = '"@loader_path/../lib/libxed.dylib"' cmd = 'install_name_tool -change %(odll)s %(ndll)s ' + fn cmd = env.expand(cmd) env['odll'] = None env['ndll'] = None mbuild.msgb("SHDOBJ SEARCH PATH", cmd) (retcode, stdout, stderr) = mbuild.run_command(cmd) if retcode != 0: dump_lines("install_name_tool stdout", stdout) dump_lines("install_name_tool stderr", stderr) cdie("Could not modify dll path: " + cmd)
def _customize_doxygen_file(env, subs): """Change the $(*) strings to the proper value in the config file. Returns True on success""" # doxygen wants quotes around paths with spaces for k, s in subs.iteritems(): if re.search(' ', s): if not re.search('^".*"$', s): mbuild.die( "Doxygen requires quotes around strings with spaces: [%s]->[%s]" % (k, s)) return False # input and output files try: lines = file(env['doxygen_config']).readlines() except: mbuild.msgb("Could not open input file: " + env['doxygen_config']) return False env['doxygen_config_customized'] = \ env.build_dir_join(os.path.basename(env['doxygen_config']) + '.customized') try: ofile = open(env['doxygen_config_customized'], 'w') except: mbuild.msgb("Could not open output file: " + env['doxygen_config_customized']) return False # compile the patterns rsubs = {} for k, v in subs.iteritems(): rsubs[k] = re.compile(r'(?P<tag>[$][(]' + k + '[)])') olines = [] for line in lines: oline = line for k, p in rsubs.iteritems(): #print 'searching for', k, 'to replace it with', subs[k] m = p.search(oline) while m: #print 'replacing', k, 'with', subs[k] oline = _replace_match(oline, m, subs[k], 'tag') m = p.search(oline) olines.append(oline) try: for line in olines: ofile.write(line) except: ofile.close() mbuild.msgb("Could not write output file: " + env['doxygen_config_customized']) return False ofile.close() return True
def _get_xed_min_size(env): if not env.on_linux(): return xed_min = None #check if we have xed-min test for exe in env['example_exes']: if 'xed-min' in exe: xed_min = exe if not xed_min: return xbc.strip_file(env,xed_min) #get the size in MB size_bytes = os.path.getsize(xed_min) size_meg = size_bytes / (1024*1024.0) mbuild.msgb("XED-MIN SIZE", "%d = %.2fMB" % (size_bytes,size_meg)) import elf_sizes d = elf_sizes.work(xed_min,die_on_errors=False) if d: elf_sizes.print_table(d)
def one_test(env, test_dir): cmd_fn = os.path.join(test_dir, "cmd") cmd = open(cmd_fn, 'r').readlines()[0] # abspath required for windoze build_dir = mbuild.posix_slashes(os.path.abspath(env['build_dir'])) cmd2 = re.sub('BUILDDIR', build_dir, cmd) cmd2 = cmd2.strip() print(cmd2) (retcode, stdout, stderr) = mbuild.run_command(cmd2, separate_stderr=True) print("Retcode %s" % (str(retcode))) if stdout: if len(stdout) == 1: stdout = stdout[0].split("\n") if len(stdout) == 1 and stdout[0] == '': stdout = [] if len(stdout) > 0 and len(stdout[-1]) == 0: stdout.pop() for line in stdout: print("[STDOUT] %d %s" % (len(line), line)) if stderr: if len(stderr) == 1: stderr = stderr[0].split("\n") if len(stderr) == 1 and stderr[0] == '': stderr = [] for line in stderr: print("[STDERR] %s" % (line)) ret_match = compare_file(os.path.join(test_dir, "retcode.reference"), [str(retcode)]) stdout_match = compare_file(os.path.join(test_dir, "stdout.reference"), stdout) stderr_match = compare_file(os.path.join(test_dir, "stderr.reference"), stderr) okay = True if not ret_match: mbuild.msgb("RETCODE MISMATCH") okay = False if not stdout_match: mbuild.msgb("STDOUT MISMATCH") okay = False if not stderr_match: mbuild.msgb("STDERR MISMATCH") okay = False print("-" * 40 + "\n\n\n") return okay
def compare_file(reference, this_test): ref_lines = open(reference,'r').readlines() ref_lines = [ x.rstrip() for x in ref_lines] this_test = [ x.rstrip() for x in this_test] for line in difflib.unified_diff(ref_lines, this_test, fromfile=reference, tofile="current"): sys.stdout.write(line.rstrip()+'\n') if len(ref_lines) != len(this_test): mbuild.msgb("DIFFERENT NUMBER OF LINES", "ref %d test %d" % (len(ref_lines),len(this_test))) for ref in ref_lines: mbuild.msgb("EXPECTED",'%s' % (ref.strip())) return False for (ref,test) in zip(ref_lines,this_test): if ref.strip() != test.strip(): if ref.find("XED version") != -1: # skip the version lines continue mbuild.msgb("DIFFERENT", "\n\tref [%s]\n\ttest [%s]" % (ref, test)) return False return True
def run_tests(env): failing_tests = [] test_dirs = find_tests(env) errors = 0 skipped = 0 for tdir in test_dirs: #if env.on_windows(): # time.sleep(1) # try to avoid a bug on windows running commands to quickly print('-' * 40) mbuild.msgb("TESTING", tdir) codes_fn = os.path.join(tdir, "codes") codes = open(codes_fn, 'r').readlines()[0].strip().split() if all_codes_present(env['codes'], codes): okay = one_test(env, tdir) if not okay: failing_tests.append(tdir) errors += 1 else: mbuild.msgb("SKIPPING DUE TO TEST SUBSET RESTRICTION") print('-' * 40 + "\n\n\n") skipped += 1 ntests = len(test_dirs) tested = ntests - skipped mbuild.msgb("TESTS", str(ntests)) mbuild.msgb("SKIPPED", str(skipped)) mbuild.msgb("TESTED", str(tested)) mbuild.msgb("ERRORS", str(errors)) if tested: mbuild.msgb("PASS_PCT", "%2.4f%%" % (100.0 * (tested - errors) / tested)) else: mbuild.msgb("PASS_PCT", '0%') failing_tests.sort() for t in failing_tests: mbuild.msgb("FAIL", t) return errors
def _find_doxygen(env): """Find the right version of doxygen. Return a tuple of the command name and a boolean indicating whether or not the version checked out.""" if env['doxygen_cmd'] == '': doxygen_cmd_intel = "/usr/intel/bin/doxygen" doxygen_cmd_cygwin = "C:/cygwin/bin/doxygen" doxygen_cmd_mac = \ "/Applications/Doxygen.app/Contents/Resources/doxygen" doxygen_cmd = "doxygen" if env['build_os'] == 'win': if os.path.exists(doxygen_cmd_cygwin): doxygen_cmd = doxygen_cmd_cygwin else: mbuild.msgb( 'DOXYGEN', "Could not find cygwin's doxygen," + "trying doxygen from PATH") elif env['build_os'] == 'lin': if mbuild.verbose(1): mbuild.msgb("CHECKING FOR", doxygen_cmd_intel) if os.path.exists(doxygen_cmd_intel): doxygen_cmd = doxygen_cmd_intel elif env['build_os'] == 'mac': if mbuild.verbose(1): mbuild.msgb("CHECKING FOR", doxygen_cmd_mac) if os.path.exists(doxygen_cmd_mac): doxygen_cmd = doxygen_cmd_mac else: doxygen_cmd = env['doxygen_cmd'] doxygen_cmd = env.escape_string(doxygen_cmd) doxygen_okay = False if mbuild.verbose(1): mbuild.msgb('Checking doxygen version', '...') if mbuild.check_python_version(2, 4): try: (retval, output, error_output) = \ mbuild.run_command(doxygen_cmd + " --version") if retval == 0: if len(output) > 0: first_line = output[0].strip() if mbuild.verbose(1): mbuild.msgb("Doxygen version", first_line) doxygen_okay = _doxygen_version_okay(first_line, 1, 4, 6) else: for o in output: mbuild.msgb("Doxygen-version-check STDOUT", o) if error_output: for line in error_output: mbuild.msgb("STDERR ", line.rstrip()) except: mbuild.die("Doxygen required by the command line options " + "but no doxygen found") return (doxygen_cmd, doxygen_okay)
def set_env_gnu(env): """Example of setting up the GNU GCC environment for compilation""" env['LINK'] = env['CC'] flags = '' #coverage testing using the local compiler #flags += ' -fprofile-arcs -ftest-coverage' #env['LIBS'] += ' -lgcov' flags += ' -Wall' # the windows compiler finds this stuff so flag it on other platforms flags += ' -Wunused' # 2018-11-28: I am working on hammering out all the issues found by these knobs: #flags += ' -Wconversion' #flags += ' -Wsign-conversion' if env['use_werror']: flags += ' -Werror' if env['compiler'] != 'icc': flags += ' -Wno-long-long' flags += ' -Wno-unknown-pragmas' flags += ' -fmessage-length=0' flags += ' -pipe' # -pg is incompatible with -fomit-frame-pointer if (re.search(r' -pg', env['CXXFLAGS']) == None and re.search(r' -pg', env['CCFLAGS']) == None and (env['compiler'] != 'icc' or env['icc_version'] not in ['7', '8'])): flags += ' -fomit-frame-pointer' if env['compiler'] != 'icc' or (env['compiler'] == 'icc' and env['icc_version'] != '7'): flags += ' -fno-exceptions' # 2019-06-05: disabled - no longer needed # required for gcc421 xcode to avoidundefined symbols when linking tools. #if env.on_mac(): # flags += ' -fno-common' if env['build_os'] == 'win' or _greater_than_gcc(env, 4, 9, 0): flags += ' -Wformat-security' flags += ' -Wformat' else: # gcc3.4.4 on windows has problems with %x for xed_int32_t. # gcc4.9.2 works well. flags += ' -Wno-format' flags += ' -Wno-format-security' if env['compiler'] != 'icc': # c99 is required for c++ style comments. env['CSTD'] = 'c99' env['CCFLAGS'] += ' -std=%(CSTD)s ' if env['pedantic']: env['CCFLAGS'] += ' -pedantic ' if env['shared']: if not env.on_windows(): # -fvisibility=hidden only works on gcc>4. If not gcc, # assume it works. Really only a problem for older icc # compilers. if env['compiler'] == 'gcc': vstr = _gcc_version_string(env) mbuild.msgb("GCC VERSION", vstr) if env['compiler'] != 'gcc' or _greater_than_gcc(env, 4, 0, 0): hidden = ' -fvisibility=hidden' env['LINKFLAGS'] += hidden flags += hidden env['CCFLAGS'] += flags env['CCFLAGS'] += ' -Wstrict-prototypes' env['CCFLAGS'] += ' -Wwrite-strings' if env['compiler'] != 'icc': env['CCFLAGS'] += ' -Wredundant-decls' # Disabled the following. Generates too many silly errors/warnings #env['CCFLAGS'] += ' -Wmissing-prototypes' env['CXXFLAGS'] += flags
# See the License for the specific language governing permissions and # limitations under the License. # #END_LEGAL import os, sys sys.path = ['..'] + sys.path import mbuild env = mbuild.env_t() env.parse_args() env['jobs'] = 1 work_queue = mbuild.work_queue_t(env['jobs']) all_cmds = ['python -c "1+1"'] subs = {} command_list = [] for cmd in all_cmds: cmd = cmd % (subs) mbuild.msgb('ADDING', cmd) c = mbuild.command_t(cmd, output_file_name="foo") work_queue.add(c) command_list.append(cmd) phase = "BUILD" okay = work_queue.build() if not okay: mbuild.die("[%s] failed. dying..." % phase) mbuild.msgb(phase, "succeeded")
# you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # #END_LEGAL import sys import os import find import mbuild env = mbuild.env_t() env.parse_args() os.environ['LANG']='en_US.UTF-8' mbuild.cmkdir(env['build_dir']) dep_tracker = mbuild.dag_t() cmd1 = dep_tracker.add(env, env.cc_compile('foo.c')) work_queue = mbuild.work_queue_t() okay = work_queue.build(dag=dep_tracker) if not okay: mbuild.die("build failed") mbuild.msgb("SUCCESS")