555 lines
15 KiB
Python
555 lines
15 KiB
Python
|
#! /usr/bin/python2
|
||
|
|
import os.path
|
||
|
|
import sys
|
||
|
|
import shlex
|
||
|
|
import re
|
||
|
|
import subprocess
|
||
|
|
import shutil
|
||
|
|
import pickle
|
||
|
|
|
||
|
|
import multiprocessing
|
||
|
|
|
||
|
|
def find_pound_include (line, use_outside, use_slash):
|
||
|
|
inc = re.findall (ur"^\s*#\s*include\s*\"(.+?)\"", line)
|
||
|
|
if len(inc) == 1:
|
||
|
|
nm = inc[0]
|
||
|
|
if use_outside or os.path.exists (nm):
|
||
|
|
if use_slash or '/' not in nm:
|
||
|
|
return nm
|
||
|
|
return ""
|
||
|
|
|
||
|
|
def find_system_include (line):
|
||
|
|
inc = re.findall (ur"^\s*#\s*include\s*<(.+?)>", line)
|
||
|
|
if len(inc) == 1:
|
||
|
|
return inc[0]
|
||
|
|
return ""
|
||
|
|
|
||
|
|
def find_pound_define (line):
|
||
|
|
inc = re.findall (ur"^\s*#\s*define ([A-Za-z0-9_]+)", line)
|
||
|
|
if len(inc) != 0:
|
||
|
|
if len(inc) > 1:
|
||
|
|
print "What? more than 1 match in #define??"
|
||
|
|
print inc
|
||
|
|
sys.exit(5)
|
||
|
|
return inc[0];
|
||
|
|
return ""
|
||
|
|
|
||
|
|
def is_pound_if (line):
|
||
|
|
inc = re.findall ("^\s*#\s*if\s", line)
|
||
|
|
if not inc:
|
||
|
|
inc = re.findall ("^\s*#\s*if[n]?def\s", line)
|
||
|
|
if inc:
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def is_pound_endif (line):
|
||
|
|
inc = re.findall ("^\s*#\s*endif", line)
|
||
|
|
if inc:
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def find_pound_if (line):
|
||
|
|
inc = re.findall (ur"^\s*#\s*if\s+(.*)", line)
|
||
|
|
if len(inc) == 0:
|
||
|
|
inc = re.findall (ur"^\s*#\s*elif\s+(.*)", line)
|
||
|
|
if len(inc) > 0:
|
||
|
|
inc2 = re.findall (ur"defined\s*\((.+?)\)", inc[0])
|
||
|
|
inc3 = re.findall (ur"defined\s+([a-zA-Z0-9_]+)", inc[0])
|
||
|
|
for yy in inc3:
|
||
|
|
inc2.append (yy)
|
||
|
|
return inc2
|
||
|
|
else:
|
||
|
|
inc = re.findall (ur"^\s*#\s*ifdef\s(.*)", line)
|
||
|
|
if len(inc) == 0:
|
||
|
|
inc = re.findall (ur"^\s*#\s*ifndef\s(.*)", line)
|
||
|
|
if len(inc) > 0:
|
||
|
|
inc2 = re.findall ("[A-Za-z_][A-Za-z_0-9]*", inc[0])
|
||
|
|
return inc2
|
||
|
|
if len(inc) == 0:
|
||
|
|
return list ()
|
||
|
|
print "WTF. more than one line returned for find_pound_if"
|
||
|
|
print inc
|
||
|
|
sys.exit(5)
|
||
|
|
|
||
|
|
|
||
|
|
# IINFO - this is a vector of include information. It consists of 7 elements.
|
||
|
|
# [0] - base name of the file
|
||
|
|
# [1] - path leading to this file.
|
||
|
|
# [2] - orderd list of all headers directly included by this file.
|
||
|
|
# [3] - Ordered list of any headers included within condionally compiled code.
|
||
|
|
# headers files are expected to have all includes one level deep due to
|
||
|
|
# the omnipresent guards at the top of the file.
|
||
|
|
# [4] - List of all macros which are consumed (used) within this file.
|
||
|
|
# [5] - list of all macros which may be defined in this file.
|
||
|
|
# [6] - The source code for this file, if cached.
|
||
|
|
# [7] - line number info for any headers in the source file. Indexed by base
|
||
|
|
# name, returning the line the include is on.
|
||
|
|
|
||
|
|
empty_iinfo = ("", "", list(), list(), list(), list(), list())
|
||
|
|
|
||
|
|
# This function will process a file and extract interesting information.
|
||
|
|
# DO_MACROS indicates whether macros defined and used should be recorded.
|
||
|
|
# KEEP_SRC indicates the source for the file should be cached.
|
||
|
|
def process_include_info (filen, do_macros, keep_src):
|
||
|
|
header = False
|
||
|
|
if not os.path.exists (filen):
|
||
|
|
return empty_iinfo
|
||
|
|
|
||
|
|
sfile = open (filen, "r");
|
||
|
|
data = sfile.readlines()
|
||
|
|
sfile.close()
|
||
|
|
|
||
|
|
# Ignore the initial #ifdef HEADER_H in header files
|
||
|
|
if filen[-2:] == ".h":
|
||
|
|
nest = -1
|
||
|
|
header = True
|
||
|
|
else:
|
||
|
|
nest = 0
|
||
|
|
|
||
|
|
macout = list ()
|
||
|
|
macin = list()
|
||
|
|
incl = list()
|
||
|
|
cond_incl = list()
|
||
|
|
src_line = { }
|
||
|
|
guard = ""
|
||
|
|
|
||
|
|
for line in (data):
|
||
|
|
if is_pound_if (line):
|
||
|
|
nest += 1
|
||
|
|
elif is_pound_endif (line):
|
||
|
|
nest -= 1
|
||
|
|
|
||
|
|
nm = find_pound_include (line, True, True)
|
||
|
|
if nm != "" and nm not in incl and nm[-2:] == ".h":
|
||
|
|
incl.append (nm)
|
||
|
|
if nest > 0:
|
||
|
|
cond_incl.append (nm)
|
||
|
|
if keep_src:
|
||
|
|
src_line[nm] = line
|
||
|
|
continue
|
||
|
|
|
||
|
|
if do_macros:
|
||
|
|
d = find_pound_define (line)
|
||
|
|
if d:
|
||
|
|
if d not in macout:
|
||
|
|
macout.append (d);
|
||
|
|
continue
|
||
|
|
|
||
|
|
d = find_pound_if (line)
|
||
|
|
if d:
|
||
|
|
# The first #if in a header file should be the guard
|
||
|
|
if header and len (d) == 1 and guard == "":
|
||
|
|
if d[0][-2:] == "_H":
|
||
|
|
guard = d
|
||
|
|
else:
|
||
|
|
guard = "Guess there was no guard..."
|
||
|
|
else:
|
||
|
|
for mac in d:
|
||
|
|
if mac != "defined" and mac not in macin:
|
||
|
|
macin.append (mac);
|
||
|
|
|
||
|
|
if not keep_src:
|
||
|
|
data = list()
|
||
|
|
|
||
|
|
return (os.path.basename (filen), os.path.dirname (filen), incl, cond_incl,
|
||
|
|
macin, macout, data, src_line)
|
||
|
|
|
||
|
|
# Extract header info, but no macros or source code.
|
||
|
|
def process_ii (filen):
|
||
|
|
return process_include_info (filen, False, False)
|
||
|
|
|
||
|
|
# Extract header information, and collect macro information.
|
||
|
|
def process_ii_macro (filen):
|
||
|
|
return process_include_info (filen, True, False)
|
||
|
|
|
||
|
|
# Extract header information, cache the source lines.
|
||
|
|
def process_ii_src (filen):
|
||
|
|
return process_include_info (filen, False, True)
|
||
|
|
|
||
|
|
# Extract header information, coolewc macro info and cache the source lines.
|
||
|
|
def process_ii_macro_src (filen):
|
||
|
|
return process_include_info (filen, True, True)
|
||
|
|
|
||
|
|
|
||
|
|
def ii_base (iinfo):
|
||
|
|
return iinfo[0]
|
||
|
|
|
||
|
|
def ii_path (iinfo):
|
||
|
|
return iinfo[1]
|
||
|
|
|
||
|
|
def ii_include_list (iinfo):
|
||
|
|
return iinfo[2]
|
||
|
|
|
||
|
|
def ii_include_list_cond (iinfo):
|
||
|
|
return iinfo[3]
|
||
|
|
|
||
|
|
def ii_include_list_non_cond (iinfo):
|
||
|
|
l = ii_include_list (iinfo)
|
||
|
|
for n in ii_include_list_cond (iinfo):
|
||
|
|
l.remove (n)
|
||
|
|
return l
|
||
|
|
|
||
|
|
def ii_macro_consume (iinfo):
|
||
|
|
return iinfo[4]
|
||
|
|
|
||
|
|
def ii_macro_define (iinfo):
|
||
|
|
return iinfo[5]
|
||
|
|
|
||
|
|
def ii_src (iinfo):
|
||
|
|
return iinfo[6]
|
||
|
|
|
||
|
|
def ii_src_line (iinfo):
|
||
|
|
return iinfo[7]
|
||
|
|
|
||
|
|
def ii_read (fname):
|
||
|
|
f = open (fname, 'rb')
|
||
|
|
incl = pickle.load (f)
|
||
|
|
consumes = pickle.load (f)
|
||
|
|
defines = pickle.load (f)
|
||
|
|
obj = (fname,fname,incl,list(), list(), consumes, defines, list(), list())
|
||
|
|
return obj
|
||
|
|
|
||
|
|
def ii_write (fname, obj):
|
||
|
|
f = open (fname, 'wb')
|
||
|
|
pickle.dump (obj[2], f)
|
||
|
|
pickle.dump (obj[4], f)
|
||
|
|
pickle.dump (obj[5], f)
|
||
|
|
f.close ()
|
||
|
|
|
||
|
|
# execute a system command which returns file names
|
||
|
|
def execute_command (command):
|
||
|
|
files = list()
|
||
|
|
f = os.popen (command)
|
||
|
|
for x in f:
|
||
|
|
if x[0:2] == "./":
|
||
|
|
fn = x.rstrip()[2:]
|
||
|
|
else:
|
||
|
|
fn = x.rstrip()
|
||
|
|
files.append(fn)
|
||
|
|
return files
|
||
|
|
|
||
|
|
# Try to locate a build directory from PATH
|
||
|
|
def find_gcc_bld_dir (path):
|
||
|
|
blddir = ""
|
||
|
|
# Look for blddir/gcc/tm.h
|
||
|
|
command = "find " + path + " -mindepth 2 -maxdepth 3 -name tm.h"
|
||
|
|
files = execute_command (command)
|
||
|
|
for y in files:
|
||
|
|
p = os.path.dirname (y)
|
||
|
|
if os.path.basename (p) == "gcc":
|
||
|
|
blddir = p
|
||
|
|
break
|
||
|
|
# If not found, try looking a bit deeper
|
||
|
|
# Dont look this deep initially because a lot of cross target builds may show
|
||
|
|
# up in the list before a native build... but those are better than nothing.
|
||
|
|
if not blddir:
|
||
|
|
command = "find " + path + " -mindepth 3 -maxdepth 5 -name tm.h"
|
||
|
|
files = execute_command (command)
|
||
|
|
for y in files:
|
||
|
|
p = os.path.dirname (y)
|
||
|
|
if os.path.basename (p) == "gcc":
|
||
|
|
blddir = p
|
||
|
|
break
|
||
|
|
|
||
|
|
return blddir
|
||
|
|
|
||
|
|
|
||
|
|
# Find files matching pattern NAME, return in a list.
|
||
|
|
# CURRENT is True if you want to include the current directory
|
||
|
|
# DEEPER is True if you want to search 3 levels below the current directory
|
||
|
|
# any files with testsuite diurectories are ignored
|
||
|
|
|
||
|
|
def find_gcc_files (name, current, deeper):
|
||
|
|
files = list()
|
||
|
|
command = ""
|
||
|
|
if current:
|
||
|
|
if not deeper:
|
||
|
|
command = "find -maxdepth 1 -name " + name + " -not -path \"./testsuite/*\""
|
||
|
|
else:
|
||
|
|
command = "find -maxdepth 4 -name " + name + " -not -path \"./testsuite/*\""
|
||
|
|
else:
|
||
|
|
if deeper:
|
||
|
|
command = "find -maxdepth 4 -mindepth 2 -name " + name + " -not -path \"./testsuite/*\""
|
||
|
|
|
||
|
|
if command != "":
|
||
|
|
files = execute_command (command)
|
||
|
|
|
||
|
|
return files
|
||
|
|
|
||
|
|
# find the list of unique include names found in a file.
|
||
|
|
def find_unique_include_list_src (data):
|
||
|
|
found = list ()
|
||
|
|
for line in data:
|
||
|
|
d = find_pound_include (line, True, True)
|
||
|
|
if d and d not in found and d[-2:] == ".h":
|
||
|
|
found.append (d)
|
||
|
|
return found
|
||
|
|
|
||
|
|
# find the list of unique include names found in a file.
|
||
|
|
def find_unique_include_list (filen):
|
||
|
|
data = open (filen).read().splitlines()
|
||
|
|
return find_unique_include_list_src (data)
|
||
|
|
|
||
|
|
|
||
|
|
# Create the macin, macout, and incl vectors for a file FILEN.
|
||
|
|
# macin are the macros that are used in #if* conditional expressions
|
||
|
|
# macout are the macros which are #defined
|
||
|
|
# incl is the list of incluide files encountered
|
||
|
|
# returned as a tuple of the filename followed by the triplet of lists
|
||
|
|
# (filen, macin, macout, incl)
|
||
|
|
|
||
|
|
def create_macro_in_out (filen):
|
||
|
|
sfile = open (filen, "r");
|
||
|
|
data = sfile.readlines()
|
||
|
|
sfile.close()
|
||
|
|
|
||
|
|
macout = list ()
|
||
|
|
macin = list()
|
||
|
|
incl = list()
|
||
|
|
|
||
|
|
for line in (data):
|
||
|
|
d = find_pound_define (line)
|
||
|
|
if d != "":
|
||
|
|
if d not in macout:
|
||
|
|
macout.append (d);
|
||
|
|
continue
|
||
|
|
|
||
|
|
d = find_pound_if (line)
|
||
|
|
if len(d) != 0:
|
||
|
|
for mac in d:
|
||
|
|
if mac != "defined" and mac not in macin:
|
||
|
|
macin.append (mac);
|
||
|
|
continue
|
||
|
|
|
||
|
|
nm = find_pound_include (line, True, True)
|
||
|
|
if nm != "" and nm not in incl:
|
||
|
|
incl.append (nm)
|
||
|
|
|
||
|
|
return (filen, macin, macout, incl)
|
||
|
|
|
||
|
|
# create the macro information for filen, and create .macin, .macout, and .incl
|
||
|
|
# files. Return the created macro tuple.
|
||
|
|
def create_include_data_files (filen):
|
||
|
|
|
||
|
|
macros = create_macro_in_out (filen)
|
||
|
|
depends = macros[1]
|
||
|
|
defines = macros[2]
|
||
|
|
incls = macros[3]
|
||
|
|
|
||
|
|
disp_message = filen
|
||
|
|
if len (defines) > 0:
|
||
|
|
disp_message = disp_message + " " + str(len (defines)) + " #defines"
|
||
|
|
dfile = open (filen + ".macout", "w")
|
||
|
|
for x in defines:
|
||
|
|
dfile.write (x + "\n")
|
||
|
|
dfile.close ()
|
||
|
|
|
||
|
|
if len (depends) > 0:
|
||
|
|
disp_message = disp_message + " " + str(len (depends)) + " #if dependencies"
|
||
|
|
dfile = open (filen + ".macin", "w")
|
||
|
|
for x in depends:
|
||
|
|
dfile.write (x + "\n")
|
||
|
|
dfile.close ()
|
||
|
|
|
||
|
|
if len (incls) > 0:
|
||
|
|
disp_message = disp_message + " " + str(len (incls)) + " #includes"
|
||
|
|
dfile = open (filen + ".incl", "w")
|
||
|
|
for x in incls:
|
||
|
|
dfile.write (x + "\n")
|
||
|
|
dfile.close ()
|
||
|
|
|
||
|
|
return macros
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
# extract data for include file name_h and enter it into the dictionary.
|
||
|
|
# this does not change once read in. use_requires is True if you want to
|
||
|
|
# prime the values with already created .requires and .provides files.
|
||
|
|
def get_include_data (name_h, use_requires):
|
||
|
|
macin = list()
|
||
|
|
macout = list()
|
||
|
|
incl = list ()
|
||
|
|
if use_requires and os.path.exists (name_h + ".requires"):
|
||
|
|
macin = open (name_h + ".requires").read().splitlines()
|
||
|
|
elif os.path.exists (name_h + ".macin"):
|
||
|
|
macin = open (name_h + ".macin").read().splitlines()
|
||
|
|
|
||
|
|
if use_requires and os.path.exists (name_h + ".provides"):
|
||
|
|
macout = open (name_h + ".provides").read().splitlines()
|
||
|
|
elif os.path.exists (name_h + ".macout"):
|
||
|
|
macout = open (name_h + ".macout").read().splitlines()
|
||
|
|
|
||
|
|
if os.path.exists (name_h + ".incl"):
|
||
|
|
incl = open (name_h + ".incl").read().splitlines()
|
||
|
|
|
||
|
|
if len(macin) == 0 and len(macout) == 0 and len(incl) == 0:
|
||
|
|
return ()
|
||
|
|
data = ( name_h, macin, macout, incl )
|
||
|
|
return data
|
||
|
|
|
||
|
|
# find FIND in src, and replace it with the list of headers in REPLACE.
|
||
|
|
# Remove any duplicates of FIND in REPLACE, and if some of the REPLACE
|
||
|
|
# headers occur earlier in the include chain, leave them.
|
||
|
|
# Return the new SRC only if anything changed.
|
||
|
|
def find_replace_include (find, replace, src):
|
||
|
|
res = list()
|
||
|
|
seen = { }
|
||
|
|
anything = False
|
||
|
|
for line in src:
|
||
|
|
inc = find_pound_include (line, True, True)
|
||
|
|
if inc == find:
|
||
|
|
for y in replace:
|
||
|
|
if seen.get(y) == None:
|
||
|
|
res.append("#include \""+y+"\"\n")
|
||
|
|
seen[y] = True
|
||
|
|
if y != find:
|
||
|
|
anything = True
|
||
|
|
# if find isnt in the replacement list, then we are deleting FIND, so changes.
|
||
|
|
if find not in replace:
|
||
|
|
anything = True
|
||
|
|
else:
|
||
|
|
if inc in replace:
|
||
|
|
if seen.get(inc) == None:
|
||
|
|
res.append (line)
|
||
|
|
seen[inc] = True
|
||
|
|
else:
|
||
|
|
res.append (line)
|
||
|
|
|
||
|
|
if (anything):
|
||
|
|
return res
|
||
|
|
else:
|
||
|
|
return list()
|
||
|
|
|
||
|
|
|
||
|
|
# pass in a require and provide dictionary to be read in.
|
||
|
|
def read_require_provides (require, provide):
|
||
|
|
if not os.path.exists ("require-provide.master"):
|
||
|
|
print "require-provide.master file is not available. please run data collection."
|
||
|
|
sys.exit(1)
|
||
|
|
incl_list = open("require-provide.master").read().splitlines()
|
||
|
|
for f in incl_list:
|
||
|
|
if os.path.exists (f+".requires"):
|
||
|
|
require[os.path.basename (f)] = open (f + ".requires").read().splitlines()
|
||
|
|
else:
|
||
|
|
require[os.path.basename (f)] = list ()
|
||
|
|
if os.path.exists (f+".provides"):
|
||
|
|
provide[os.path.basename (f)] = open (f + ".provides").read().splitlines()
|
||
|
|
else:
|
||
|
|
provide [os.path.basename (f)] = list ()
|
||
|
|
|
||
|
|
|
||
|
|
def build_include_list (filen):
|
||
|
|
include_files = list()
|
||
|
|
sfile = open (filen, "r")
|
||
|
|
data = sfile.readlines()
|
||
|
|
sfile.close()
|
||
|
|
for line in data:
|
||
|
|
nm = find_pound_include (line, False, False)
|
||
|
|
if nm != "" and nm[-2:] == ".h":
|
||
|
|
if nm not in include_files:
|
||
|
|
include_files.append(nm)
|
||
|
|
return include_files
|
||
|
|
|
||
|
|
def build_reverse_include_list (filen):
|
||
|
|
include_files = list()
|
||
|
|
sfile = open (filen, "r")
|
||
|
|
data = sfile.readlines()
|
||
|
|
sfile.close()
|
||
|
|
for line in reversed(data):
|
||
|
|
nm = find_pound_include (line, False, False)
|
||
|
|
if nm != "":
|
||
|
|
if nm not in include_files:
|
||
|
|
include_files.append(nm)
|
||
|
|
return include_files
|
||
|
|
|
||
|
|
# Get compilation return code, and compensate for a warning that we want to
|
||
|
|
# consider an error when it comes to inlined templates.
|
||
|
|
def get_make_rc (rc, output):
|
||
|
|
rc = rc % 1280
|
||
|
|
if rc == 0:
|
||
|
|
# This is not considered an error during compilation of an individual file,
|
||
|
|
# but it will cause an error during link if it isn't defined. If this
|
||
|
|
# warning is seen during compiling a file, make it a build error so we
|
||
|
|
# don't remove the header.
|
||
|
|
h = re.findall ("warning: inline function.*used but never defined", output)
|
||
|
|
if len(h) != 0:
|
||
|
|
rc = 1
|
||
|
|
return rc;
|
||
|
|
|
||
|
|
def get_make_output (build_dir, make_opt):
|
||
|
|
devnull = open('/dev/null', 'w')
|
||
|
|
at_a_time = multiprocessing.cpu_count() * 2
|
||
|
|
make = "make -j"+str(at_a_time)+ " "
|
||
|
|
if build_dir != "":
|
||
|
|
command = "cd " + build_dir +"; " + make + make_opt
|
||
|
|
else:
|
||
|
|
command = make + make_opt
|
||
|
|
process = subprocess.Popen(command, stdout=devnull, stderr=subprocess.PIPE, shell=True)
|
||
|
|
output = process.communicate();
|
||
|
|
rc = get_make_rc (process.returncode, output[1])
|
||
|
|
return (rc , output[1])
|
||
|
|
|
||
|
|
def spawn_makes (command_list):
|
||
|
|
devnull = open('/dev/null', 'w')
|
||
|
|
rc = (0,"", "")
|
||
|
|
proc_res = list()
|
||
|
|
text = " Trying target builds : "
|
||
|
|
for command_pair in command_list:
|
||
|
|
tname = command_pair[0]
|
||
|
|
command = command_pair[1]
|
||
|
|
text += tname + ", "
|
||
|
|
c = subprocess.Popen(command, bufsize=-1, stdout=devnull, stderr=subprocess.PIPE, shell=True)
|
||
|
|
proc_res.append ((c, tname))
|
||
|
|
|
||
|
|
print text[:-2]
|
||
|
|
|
||
|
|
for p in proc_res:
|
||
|
|
output = p[0].communicate()
|
||
|
|
ret = (get_make_rc (p[0].returncode, output[1]), output[1], p[1])
|
||
|
|
if (ret[0] != 0):
|
||
|
|
# Just record the first one.
|
||
|
|
if rc[0] == 0:
|
||
|
|
rc = ret;
|
||
|
|
return rc
|
||
|
|
|
||
|
|
def get_make_output_parallel (targ_list, make_opt, at_a_time):
|
||
|
|
command = list()
|
||
|
|
targname = list()
|
||
|
|
if at_a_time == 0:
|
||
|
|
at_a_time = multiprocessing.cpu_count() * 2
|
||
|
|
proc_res = [0] * at_a_time
|
||
|
|
for x in targ_list:
|
||
|
|
if make_opt[-2:] == ".o":
|
||
|
|
s = "cd " + x[1] + "/gcc/; make " + make_opt
|
||
|
|
else:
|
||
|
|
s = "cd " + x[1] +"; make " + make_opt
|
||
|
|
command.append ((x[0],s))
|
||
|
|
|
||
|
|
num = len(command)
|
||
|
|
rc = (0,"", "")
|
||
|
|
loops = num // at_a_time
|
||
|
|
|
||
|
|
if (loops > 0):
|
||
|
|
for idx in range (loops):
|
||
|
|
ret = spawn_makes (command[idx*at_a_time:(idx+1)*at_a_time])
|
||
|
|
if ret[0] != 0:
|
||
|
|
rc = ret
|
||
|
|
break
|
||
|
|
|
||
|
|
if (rc[0] == 0):
|
||
|
|
leftover = num % at_a_time
|
||
|
|
if (leftover > 0):
|
||
|
|
ret = spawn_makes (command[-leftover:])
|
||
|
|
if ret[0] != 0:
|
||
|
|
rc = ret
|
||
|
|
|
||
|
|
return rc
|
||
|
|
|
||
|
|
|
||
|
|
def readwholefile (src_file):
|
||
|
|
sfile = open (src_file, "r")
|
||
|
|
src_data = sfile.readlines()
|
||
|
|
sfile.close()
|
||
|
|
return src_data
|
||
|
|
|