mirror of https://github.com/svaarala/duktape.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
344 lines
10 KiB
344 lines
10 KiB
#!/usr/bin/python
|
|
#
|
|
# Combine all source and header files in source directory into
|
|
# a single C file.
|
|
#
|
|
# The process is not very simple or clean. This helper is not
|
|
# a generic or 100% correct in the general case: it just needs
|
|
# to work for Duktape.
|
|
#
|
|
# Overview of the process:
|
|
#
|
|
# * Parse all relevant C and H files.
|
|
#
|
|
# * Change all non-exposed functions and variables to "static" in
|
|
# both headers (extern -> static) and in implementation files.
|
|
#
|
|
# * Emit internal headers by starting from duk_internal.h (the only
|
|
# internal header included by Duktape C files) and emulating the
|
|
# include mechanism recursively.
|
|
#
|
|
# * Emit all source files, removing any internal includes (these
|
|
# should all be duk_internal.h ideally but there are a few remnants).
|
|
#
|
|
# At every step, source and header lines are represented with explicit
|
|
# line objects which keep track of original filename and line. The
|
|
# output contains #line directives, if necessary, to ensure error
|
|
# throwing and other diagnostic info will work in a useful manner when
|
|
# deployed.
|
|
#
|
|
# Making the process deterministic is important, so that if users have
|
|
# diffs that they apply to the combined source, such diffs would apply
|
|
# for as long as possible.
|
|
#
|
|
# Limitations and notes:
|
|
#
|
|
# * #defines are not #undef'd at the end of an input file, so defines
|
|
# may bleed to other files. These need to be fixed in the original
|
|
# sources.
|
|
#
|
|
# * System headers included with a certain define (like _BSD_SOURCE)
|
|
# are not handled correctly now.
|
|
#
|
|
# * External includes are not removed or combined: some of them are
|
|
# inside #ifdef directives, so it would difficult to do so. Ideally
|
|
# there would be no external includes in individual files.
|
|
|
|
import os
|
|
import sys
|
|
import re
|
|
import json
|
|
import optparse
|
|
|
|
re_extinc = re.compile(r'^#include <(.*?)>.*$')
|
|
re_intinc = re.compile(r'^#include \"(duk.*?)\".*$') # accept duktape.h too
|
|
|
|
class File:
|
|
filename_full = None
|
|
filename = None
|
|
lines = None
|
|
|
|
def __init__(self, filename, lines):
|
|
self.filename = os.path.basename(filename)
|
|
self.filename_full = filename
|
|
self.lines = lines
|
|
|
|
class Line:
|
|
filename_full = None
|
|
filename = None
|
|
lineno = None
|
|
data = None
|
|
|
|
def __init__(self, filename, lineno, data):
|
|
self.filename = os.path.basename(filename)
|
|
self.filename_full = filename
|
|
self.lineno = lineno
|
|
self.data = data
|
|
|
|
def read(filename):
|
|
lines = []
|
|
|
|
f = None
|
|
try:
|
|
f = open(filename, 'rb')
|
|
lineno = 0
|
|
for line in f:
|
|
lineno += 1
|
|
if len(line) > 0 and line[-1] == '\n':
|
|
line = line[:-1]
|
|
lines.append(Line(filename, lineno, line))
|
|
finally:
|
|
if f is not None:
|
|
f.close()
|
|
|
|
return File(filename, lines)
|
|
|
|
def findFile(files, filename):
|
|
for i in files:
|
|
if i.filename == filename:
|
|
return i
|
|
return None
|
|
|
|
def processIncludes(f):
|
|
extinc = []
|
|
intinc = []
|
|
|
|
for line in f.lines:
|
|
if not line.data.startswith('#include'):
|
|
continue
|
|
|
|
m = re_extinc.match(line.data)
|
|
if m is not None:
|
|
# external includes are kept; they may even be conditional
|
|
extinc.append(m.group(1))
|
|
#line.data = ''
|
|
continue
|
|
|
|
m = re_intinc.match(line.data)
|
|
if m is not None:
|
|
intinc.append(m.group(1))
|
|
#line.data = ''
|
|
continue
|
|
|
|
print(line.data)
|
|
raise Exception('cannot parse include directive')
|
|
|
|
return extinc, intinc
|
|
|
|
def processDeclarations(f):
|
|
for line in f.lines:
|
|
# FIXME: total placeholder
|
|
if line.data.startswith('int ') or line.data.startswith('void '):
|
|
line.data = 'static ' + line.data
|
|
elif line.data.startswith('extern int') or line.data.startswith('extern void '):
|
|
line.data = 'static ' + line.data[7:] # replace extern with static
|
|
|
|
def createCombined(files, extinc, intinc, duk_version, git_commit, git_describe, git_branch, license_file, authors_file, line_directives):
|
|
res = []
|
|
line_map = [] # indicate combined source lines where uncombined file/line would change
|
|
metadata = {
|
|
'line_map': line_map
|
|
}
|
|
|
|
|
|
emit_state = [ None, None ] # curr_filename, curr_lineno
|
|
|
|
# Because duktape.c/duktape.h/duk_config.h are often distributed or
|
|
# included in project sources as is, add a license reminder and
|
|
# Duktape version information to the duktape.c header (duktape.h
|
|
# already contains them).
|
|
|
|
duk_major = duk_version / 10000
|
|
duk_minor = duk_version / 100 % 100
|
|
duk_patch = duk_version % 100
|
|
res.append('/*')
|
|
res.append(' * Single source autogenerated distributable for Duktape %d.%d.%d.' % (duk_major, duk_minor, duk_patch))
|
|
res.append(' *')
|
|
res.append(' * Git commit %s (%s).' % (git_commit, git_describe))
|
|
res.append(' * Git branch %s.' % git_branch)
|
|
res.append(' *')
|
|
res.append(' * See Duktape AUTHORS.rst and LICENSE.txt for copyright and')
|
|
res.append(' * licensing information.')
|
|
res.append(' */')
|
|
res.append('')
|
|
|
|
# Add LICENSE.txt and AUTHORS.rst to combined source so that they're automatically
|
|
# included and are up-to-date.
|
|
|
|
res.append('/* LICENSE.txt */')
|
|
f = open(license_file, 'rb')
|
|
for line in f:
|
|
res.append(line.strip())
|
|
f.close()
|
|
res.append('/* AUTHORS.rst */')
|
|
f = open(authors_file, 'rb')
|
|
for line in f:
|
|
res.append(line.strip())
|
|
f.close()
|
|
|
|
def emit(line):
|
|
if isinstance(line, (str, unicode)):
|
|
res.append(line)
|
|
emit_state[1] += 1
|
|
else:
|
|
if line.filename != emit_state[0] or line.lineno != emit_state[1]:
|
|
line_map.append({ 'original_file': line.filename,
|
|
'original_line': line.lineno,
|
|
'combined_line': len(res) + 1 })
|
|
if line_directives:
|
|
res.append('#line %d "%s"' % (line.lineno, line.filename))
|
|
res.append(line.data)
|
|
emit_state[0] = line.filename
|
|
emit_state[1] = line.lineno + 1
|
|
|
|
processed = {}
|
|
|
|
# Helper to process internal headers recursively, starting from duk_internal.h
|
|
def processHeader(f_hdr):
|
|
#print('Process header: ' + f_hdr.filename)
|
|
for line in f_hdr.lines:
|
|
m = re_intinc.match(line.data)
|
|
if m is None:
|
|
emit(line)
|
|
continue
|
|
incname = m.group(1)
|
|
if incname in [ 'duktape.h', 'duk_custom.h' ]:
|
|
# keep a few special headers as is
|
|
emit(line)
|
|
continue
|
|
|
|
#print('Include: ' + incname)
|
|
f_inc = findFile(files, incname)
|
|
assert(f_inc)
|
|
|
|
if processed.has_key(f_inc.filename):
|
|
#print('already included, skip: ' + f_inc.filename)
|
|
emit('/* already included: %s */' % f_inc.filename)
|
|
continue
|
|
processed[f_inc.filename] = True
|
|
|
|
# include file in this place, recursively
|
|
processHeader(f_inc)
|
|
|
|
# Process internal headers by starting with duk_internal.h
|
|
f_dukint = findFile(files, 'duk_internal.h')
|
|
assert(f_dukint)
|
|
processHeader(f_dukint)
|
|
|
|
# Mark all internal headers processed
|
|
for f in files:
|
|
if os.path.splitext(f.filename)[1] != '.h':
|
|
continue
|
|
processed[f.filename] = True
|
|
|
|
# Then emit remaining files
|
|
for f in files:
|
|
if processed.has_key(f.filename):
|
|
continue
|
|
|
|
for line in f.lines:
|
|
m = re_intinc.match(line.data)
|
|
if m is None:
|
|
emit(line)
|
|
else:
|
|
incname = m.group(1)
|
|
emit('/* include removed: %s */' % incname)
|
|
|
|
return '\n'.join(res) + '\n', metadata
|
|
|
|
def main():
|
|
parser = optparse.OptionParser()
|
|
parser.add_option('--source-dir', dest='source_dir', help='Source directory')
|
|
parser.add_option('--output-source', dest='output_source', help='Output source filename')
|
|
parser.add_option('--output-metadata', dest='output_metadata', help='Output metadata filename')
|
|
parser.add_option('--duk-version', type='int', dest='duk_version', help='Duktape version integer (e.g. 10203 for 1.2.3)')
|
|
parser.add_option('--git-commit', dest='git_commit', help='Git commit hash')
|
|
parser.add_option('--git-describe', dest='git_describe', help='Git describe')
|
|
parser.add_option('--git-branch', dest='git_branch', help='Git branch')
|
|
parser.add_option('--license-file', dest='license_file', help='License file to embed')
|
|
parser.add_option('--authors-file', dest='authors_file', help='Authors file to embed')
|
|
parser.add_option('--line-directives', dest='line_directives', action='store_true', default=False, help='Use #line directives in combined source')
|
|
(opts, args) = parser.parse_args()
|
|
|
|
assert(opts.source_dir)
|
|
assert(opts.output_source)
|
|
assert(opts.output_metadata)
|
|
assert(opts.duk_version)
|
|
assert(opts.git_commit)
|
|
assert(opts.git_describe)
|
|
assert(opts.git_branch)
|
|
assert(opts.license_file)
|
|
assert(opts.authors_file)
|
|
|
|
if not os.path.exists('LICENSE.txt'):
|
|
raise Exception('CWD must be Duktape checkout top')
|
|
|
|
print 'Read input files'
|
|
files = []
|
|
filelist = os.listdir(opts.source_dir)
|
|
filelist.sort() # for consistency
|
|
handpick = [
|
|
'duk_replacements.c',
|
|
'duk_strings.c',
|
|
'duk_debug_macros.c',
|
|
'duk_builtins.c',
|
|
'duk_error_macros.c',
|
|
'duk_unicode_support.c',
|
|
'duk_util_misc.c',
|
|
'duk_util_hashprime.c',
|
|
'duk_hobject_class.c'
|
|
]
|
|
handpick.reverse()
|
|
for fn in handpick:
|
|
# These files must appear before the alphabetically sorted
|
|
# ones so that static variables get defined before they're
|
|
# used. We can't forward declare them because that would
|
|
# cause C++ issues (see GH-63). When changing, verify by
|
|
# compiling with g++.
|
|
idx = filelist.index(fn)
|
|
filelist.insert(0, filelist.pop(idx))
|
|
for fn in filelist:
|
|
if os.path.splitext(fn)[1] not in [ '.c', '.h' ]:
|
|
continue
|
|
res = read(os.path.join(opts.source_dir, fn))
|
|
files.append(res)
|
|
print '%d files read' % len(files)
|
|
|
|
print 'Process #include statements'
|
|
extinc = []
|
|
intinc = []
|
|
for f in files:
|
|
extnew, intnew = processIncludes(f)
|
|
for i in extnew:
|
|
if i in extinc:
|
|
continue
|
|
extinc.append(i)
|
|
for i in intnew:
|
|
if i in intinc:
|
|
continue
|
|
intinc.append(i)
|
|
|
|
#print('external includes: ' + ', '.join(extinc))
|
|
#print('internal includes: ' + ', '.join(intinc))
|
|
|
|
print 'Process declarations (non-exposed are converted to static)'
|
|
for f in files:
|
|
#processDeclarations(f)
|
|
pass
|
|
|
|
print 'Output final file'
|
|
combined_source, metadata = \
|
|
createCombined(files, extinc, intinc, opts.duk_version,
|
|
opts.git_commit, opts.git_describe, opts.git_branch,
|
|
opts.license_file, opts.authors_file,
|
|
opts.line_directives)
|
|
with open(opts.output_source, 'wb') as f:
|
|
f.write(combined_source)
|
|
with open(opts.output_metadata, 'wb') as f:
|
|
f.write(json.dumps(metadata, indent=4))
|
|
|
|
print 'Wrote %d bytes to %s' % (len(combined_source), opts.output_source)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
|