def check(args):
filename = args[0]
output = ChunkedIO()
namespace = Namespace('Test', '1.0')
logger = MessageLogger.get(namespace=namespace, output=output)
logger.enable_warnings(True)
transformer = Transformer(namespace)
transformer.set_include_paths(
[os.path.join(top_srcdir, 'gir'), top_builddir])
transformer.register_include(Include.from_string('GObject-2.0'))
ss = SourceScanner()
options = Options()
exit_code = process_packages(options, ['gobject-2.0'])
if exit_code:
sys.exit(exit_code)
ss.set_cpp_options(options.cpp_includes, options.cpp_defines,
options.cpp_undefines)
ss.parse_files([filename])
ss.parse_macros([filename])
transformer.parse(ss.get_symbols())
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
main = MainTransformer(transformer, blocks)
main.transform()
final = IntrospectablePass(transformer, blocks)
final.validate()
emitted_warnings = [w[w.find(':') + 1:] for w in output.getvalue()]
expected_warnings = _extract_expected(filename)
expected_warnings.sort()
emitted_warnings.sort()
if len(expected_warnings) != len(emitted_warnings):
raise SystemExit('ERROR in %r: %d warnings were emitted, '
'expected %d:\n%s' %
(os.path.basename(filename), len(emitted_warnings),
len(expected_warnings),
_diff(expected_warnings, emitted_warnings)))
for emitted_warning, expected_warning in zip(emitted_warnings,
expected_warnings):
if expected_warning != emitted_warning:
raise SystemExit(
'ERROR in %r: expected warning does not match emitted '
'warning:\n%s' %
(filename, _diff([expected_warning], [emitted_warning])))
def annotation_main(args):
parser = optparse.OptionParser('%prog [options] sources')
group = optparse.OptionGroup(parser, "Tool modes, one is required")
group.add_option("-e",
"--extract",
action="store_true",
dest="extract",
help="Extract annotations from the input files")
parser.add_option_group(group)
group = get_preprocessor_option_group(parser)
group.add_option("-L",
"--library-path",
action="append",
dest="library_paths",
default=[],
help="directories to search for libraries")
group.add_option("",
"--pkg",
action="append",
dest="packages",
default=[],
help="pkg-config packages to get cflags from")
parser.add_option_group(group)
options, args = parser.parse_args(args)
if not options.extract:
raise SystemExit("ERROR: Nothing to do")
if options.packages:
process_packages(options, options.packages)
logger = message.MessageLogger.get(namespace=None)
ss = create_source_scanner(options, args)
if options.extract:
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
print '/' + ('*' * 60) + '/'
print '/* THIS FILE IS GENERATED DO NOT EDIT */'
print '/' + ('*' * 60) + '/'
print
for block in sorted(blocks.values()):
print block.to_gtk_doc()
print
print
print '/' + ('*' * 60) + '/'
print '/* THIS FILE IS GENERATED DO NOT EDIT */'
print '/' + ('*' * 60) + '/'
return 0
def check(args):
filename = args[0]
output = StringIO()
namespace = Namespace("Test", "1.0")
logger = MessageLogger.get(namespace=namespace, output=output)
logger.enable_warnings(True)
transformer = Transformer(namespace)
transformer.set_include_paths(
[os.path.join(top_srcdir, 'gir'), top_builddir])
transformer.register_include(Include.from_string("GObject-2.0"))
ss = SourceScanner()
options = Options()
exit_code = process_packages(options, ['gobject-2.0'])
if exit_code:
sys.exit(exit_code)
ss.set_cpp_options(options.cpp_includes, options.cpp_defines,
options.cpp_undefines)
ss.parse_files([filename])
ss.parse_macros([filename])
transformer.parse(ss.get_symbols())
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
main = MainTransformer(transformer, blocks)
main.transform()
final = IntrospectablePass(transformer, blocks)
final.validate()
raw = output.getvalue()
if raw.endswith('\n'):
raw = raw[:-1]
warnings = raw.split('\n')
failed_tests = 0
expected_warnings = _extract_expected(filename)
if '' in warnings:
warnings.remove('')
if len(expected_warnings) != len(warnings):
raise SystemExit(
"ERROR in %r: expected %d warnings, but got %d:\n"
"----\nexpected:\n%s\n----\ngot:\n%s\n----" %
(os.path.basename(filename), len(expected_warnings), len(warnings),
'\n'.join([w[1] for w in expected_warnings]), '\n'.join(
[w.split(':', 2)[2][1:] for w in warnings])))
for warning, (sort_key, expected) in zip(warnings, expected_warnings):
actual = warning.split(":", 1)[1]
if _diff(expected, actual, filename):
raise SystemExit("ERROR: tests %r failed" % (filename, ))
def check(args):
filename = args[0]
output = ChunkedIO()
namespace = Namespace('Test', '1.0')
logger = MessageLogger.get(namespace=namespace, output=output)
logger.enable_warnings(True)
transformer = Transformer(namespace)
transformer.set_include_paths([os.path.join(top_srcdir, 'gir'), top_builddir])
transformer.register_include(Include.from_string('GObject-2.0'))
ss = SourceScanner()
options = Options()
exit_code = process_packages(options, ['gobject-2.0'])
if exit_code:
sys.exit(exit_code)
ss.set_cpp_options(options.cpp_includes, options.cpp_defines, options.cpp_undefines)
ss.parse_files([filename])
ss.parse_macros([filename])
transformer.parse(ss.get_symbols())
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
main = MainTransformer(transformer, blocks)
main.transform()
final = IntrospectablePass(transformer, blocks)
final.validate()
emitted_warnings = [w[w.find(':') + 1:] for w in output.getvalue()]
expected_warnings = _extract_expected(filename)
expected_warnings.sort()
emitted_warnings.sort()
if len(expected_warnings) != len(emitted_warnings):
raise SystemExit('ERROR in %r: %d warnings were emitted, '
'expected %d:\n%s' % (os.path.basename(filename),
len(emitted_warnings),
len(expected_warnings),
_diff(expected_warnings, emitted_warnings)))
for emitted_warning, expected_warning in zip(emitted_warnings, expected_warnings):
if expected_warning != emitted_warning:
raise SystemExit('ERROR in %r: expected warning does not match emitted '
'warning:\n%s' % (filename,
_diff([expected_warning], [emitted_warning])))
def annotation_main(args):
parser = optparse.OptionParser("%prog [options] sources")
group = optparse.OptionGroup(parser, "Tool modes, one is required")
group.add_option(
"-e", "--extract", action="store_true", dest="extract", help="Extract annotations from the input files"
)
parser.add_option_group(group)
group = get_preprocessor_option_group(parser)
group.add_option(
"-L",
"--library-path",
action="append",
dest="library_paths",
default=[],
help="directories to search for libraries",
)
group.add_option(
"", "--pkg", action="append", dest="packages", default=[], help="pkg-config packages to get cflags from"
)
parser.add_option_group(group)
options, args = parser.parse_args(args)
if not options.extract:
raise SystemExit("ERROR: Nothing to do")
if options.packages:
process_packages(options, options.packages)
logger = message.MessageLogger.get(namespace="")
ss = create_source_scanner(options, args)
if options.extract:
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
print "/" + ("*" * 60) + "/"
print "/* THIS FILE IS GENERATED DO NOT EDIT */"
print "/" + ("*" * 60) + "/"
print
for block in sorted(blocks.values()):
print block.to_gtk_doc()
print
print
print "/" + ("*" * 60) + "/"
print "/* THIS FILE IS GENERATED DO NOT EDIT */"
print "/" + ("*" * 60) + "/"
return 0
def do_test(self):
# Parse GTK-Doc comment block
commentblock = testcase.find('commentblock').text
parsed_docblock = AnnotationParser().parse_comment_block((commentblock, 'test.c', 1))
parsed_tree = parsed2tree(parsed_docblock).split('\n')
# Get expected output
expected_docblock = testcase.find('docblock')
expected_tree = expected2tree(expected_docblock).split('\n')
# Construct a meaningful message
msg = 'Parsed DocBlock object tree does not match expected output:\n\n'
msg += '%s\n\n' % (commentblock, )
diff = difflib.unified_diff(expected_tree, parsed_tree,
'Expected DocBlock', 'Parsed DocBlock',
n=max(len(expected_tree), len(parsed_tree)),
lineterm='')
for line in diff:
msg += '%s\n' % (line, )
# Compare parsed with expected DocBlock tree
self.assertEqual(parsed_tree, expected_tree, msg)
def scanner_main(args):
parser = _get_option_parser()
(options, args) = parser.parse_args(args)
if len(args) <= 1:
_error('Need at least one filename')
if options.typelib_xml:
return typelib_xml_strip(args[1])
if options.inject:
if len(args) != 4:
_error('Need three filenames; e.g. g-ir-scanner '
'--inject Source.gir Additions.xml SourceOut.gir')
return inject(*args[1:4])
if options.xpath_assertions:
return validate(options.xpath_assertions, args[1])
if not options.namespace_name:
_error('Namespace name missing')
if options.format == 'gir':
from giscanner.girwriter import GIRWriter as Writer
else:
_error("Unknown format: %s" % (options.format, ))
if not (options.libraries or options.program):
_error("Must specify --program or --library")
libraries = options.libraries
filenames = []
for arg in args:
if (arg.endswith('.c') or
arg.endswith('.h')):
if not os.path.exists(arg):
_error('%s: no such a file or directory' % (arg, ))
# Make absolute, because we do comparisons inside scannerparser.c
# against the absolute path that cpp will give us
filenames.append(os.path.abspath(arg))
cachestore = CacheStore()
transformer = Transformer(cachestore,
options.namespace_name,
options.namespace_version)
if options.strip_prefix:
transformer.set_strip_prefix(options.strip_prefix)
else:
transformer.set_strip_prefix(options.namespace_name)
transformer.set_include_paths(options.include_paths)
shown_include_warning = False
for include in options.includes:
if os.sep in include:
raise ValueError("Invalid include path %r" % (include, ))
try:
include_obj = Include.from_string(include)
except:
sys.stderr.write("Malformed include %r\n" % (include, ))
sys.exit(1)
transformer.register_include(include_obj)
packages = set(options.packages)
packages.update(transformer.get_pkgconfig_packages())
process_packages(parser, options, packages)
# Run the preprocessor, tokenize and construct simple
# objects representing the raw C symbols
ss = SourceScanner()
ss.set_cpp_options(options.cpp_includes,
options.cpp_defines,
options.cpp_undefines)
ss.parse_files(filenames)
ss.parse_macros(filenames)
# Transform the C symbols into AST nodes
transformer.set_source_ast(ss)
# Transform the C AST nodes into higher level
# GLib/GObject nodes
glibtransformer = GLibTransformer(transformer,
noclosure=options.noclosure)
# Do enough parsing that we have the get_type() functions to reference
# when creating the introspection binary
glibtransformer.init_parse()
if options.program:
args=[options.program]
args.extend(options.program_args)
binary = IntrospectionBinary(args)
else:
binary = compile_introspection_binary(options,
glibtransformer.get_get_type_functions())
shlibs = resolve_shlibs(options, binary, libraries)
glibtransformer.set_introspection_binary(binary)
namespace = glibtransformer.parse()
ap = AnnotationParser(namespace, ss, transformer)
try:
ap.parse()
except InvalidAnnotationError, e:
raise SystemExit("ERROR in annotation: %s" % (str(e), ))
def scanner_main(args):
parser = _get_option_parser()
(options, args) = parser.parse_args(args)
if options.passthrough_gir:
passthrough_gir(options.passthrough_gir, sys.stdout)
if options.test_codegen:
return test_codegen(options.test_codegen)
if len(args) <= 1:
_error('Need at least one filename')
if not options.namespace_name:
_error('Namespace name missing')
if options.format == 'gir':
from giscanner.girwriter import GIRWriter as Writer
else:
_error("Unknown format: %s" % (options.format, ))
if not (options.libraries
or options.program
or options.header_only):
_error("Must specify --program or --library")
namespace = create_namespace(options)
logger = message.MessageLogger.get(namespace=namespace)
if options.warn_all:
logger.enable_warnings(True)
transformer = create_transformer(namespace, options)
packages = set(options.packages)
packages.update(transformer.get_pkgconfig_packages())
exit_code = process_packages(options, packages)
if exit_code:
return exit_code
ss = create_source_scanner(options, args)
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
# Transform the C symbols into AST nodes
transformer.set_annotations(blocks)
transformer.parse(ss.get_symbols())
if not options.header_only:
shlibs = create_binary(transformer, options, args)
else:
shlibs = []
main = MainTransformer(transformer, blocks)
main.transform()
utils.break_on_debug_flag('tree')
final = IntrospectablePass(transformer, blocks)
final.validate()
warning_count = logger.get_warning_count()
if options.warn_fatal and warning_count > 0:
message.fatal("warnings configured as fatal")
return 1
elif warning_count > 0 and options.warn_all is False:
print ("g-ir-scanner: %s: warning: %d warnings suppressed (use --warn-all to see them)"
% (transformer.namespace.name, warning_count, ))
# Write out AST
if options.packages_export:
exported_packages = options.packages_export
else:
exported_packages = options.packages
writer = Writer(transformer.namespace, shlibs, transformer.get_includes(),
exported_packages, options.c_includes)
data = writer.get_xml()
write_output(data, options)
return 0
def scanner_main(args):
parser = _get_option_parser()
(options, args) = parser.parse_args(args)
if options.passthrough_gir:
passthrough_gir(options.passthrough_gir, sys.stdout)
if options.test_codegen:
return test_codegen(options.test_codegen)
if len(args) <= 1:
_error('Need at least one filename')
if not options.namespace_name:
_error('Namespace name missing')
if options.format == 'gir':
from giscanner.girwriter import GIRWriter as Writer
else:
_error("Unknown format: %s" % (options.format, ))
if not (options.libraries
or options.program
or options.header_only):
_error("Must specify --program or --library")
namespace = create_namespace(options)
logger = message.MessageLogger.get(namespace=namespace)
if options.warn_all:
logger.enable_warnings(True)
transformer = create_transformer(namespace, options)
packages = set(options.packages)
packages.update(transformer.get_pkgconfig_packages())
if packages:
exit_code = process_packages(options, packages)
if exit_code:
return exit_code
ss = create_source_scanner(options, args)
ap = AnnotationParser()
blocks = ap.parse(ss.get_comments())
# Transform the C symbols into AST nodes
transformer.set_annotations(blocks)
transformer.parse(ss.get_symbols())
if not options.header_only:
shlibs = create_binary(transformer, options, args)
else:
shlibs = []
main = MainTransformer(transformer, blocks)
main.transform()
utils.break_on_debug_flag('tree')
final = IntrospectablePass(transformer, blocks)
final.validate()
warning_count = logger.get_warning_count()
if options.warn_fatal and warning_count > 0:
message.fatal("warnings configured as fatal")
return 1
elif warning_count > 0 and options.warn_all is False:
print ("g-ir-scanner: %s: warning: %d warnings suppressed (use --warn-all to see them)"
% (transformer.namespace.name, warning_count, ))
# Write out AST
if options.packages_export:
exported_packages = options.packages_export
else:
exported_packages = options.packages
writer = Writer(transformer.namespace, shlibs, transformer.get_includes(),
exported_packages, options.c_includes)
data = writer.get_xml()
write_output(data, options)
return 0
