#
# Lasso - A free implementation of the Liberty Alliance specifications.
#
# Copyright (C) 2004-2007 Entr'ouvert
# http://lasso.entrouvert.org
#
# Authors: See AUTHORS file in top-level directory.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
import os
import re
from six import print_
import sys
from utils import *
from optparse import OptionParser
try:
from lxml import etree as ET
except ImportError:
try:
import cElementTree as ET
except ImportError:
try:
import elementtree.ElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
sys.path.append(os.path.dirname(__file__))
# monkey patch os.path to include relpath if python version is < 2.6
if not hasattr(os.path, "relpath"):
def relpath(longPath, basePath):
if not longPath.startswith(basePath):
raise RuntimeError("Unexpected arguments")
if longPath == basePath:
return "."
i = len(basePath)
if not basePath.endswith(os.path.sep):
i += len(os.path.sep)
return longPath[i:]
os.path.relpath = relpath
class BindingData:
src_dir = os.path.dirname(__file__)
def __init__(self, options = None):
self.headers = []
# [(char,string)]
# where char is:
# - i: integer
# - s: string
self.constants = []
self.structs = []
self.struct_dict = {}
self.functions = []
self.enums = []
self.options = options
self.overrides = ET.parse(os.path.join(self.src_dir, 'overrides.xml'))
self.functions_toskip = dict()
self.structs_toskip = dict()
for func in self.overrides.findall('func'):
if func.attrib.get('skip') == 'true':
self.functions_toskip[func.attrib.get('name')] = 1
for struct in self.overrides.findall('struct'):
if struct.attrib.get('skip') == 'true':
self.structs_toskip[struct.attrib.get('name')] = 1
def match_tag_language(self,tag):
if self.options and self.options.language:
languages = tag.attrib.get('language')
if languages:
lang_list = languages.split(' ')
if self.options.language in lang_list:
return True
else:
return False
else:
return True
else:
return True
def display_structs(self):
for struct in self.structs:
struct.display()
def display_funcs(self):
for func in self.functions:
print(func.return_type, func.name)
for a in func.args:
print(' ', a)
def order_class_hierarchy(self):
new_order = []
while self.structs:
for c in self.structs:
if c.parent == 'GObject' or c.parent in [x.name for x in new_order]:
self.structs.remove(c)
new_order.append(c)
break
self.structs = new_order
def create_struct_dict(self):
for c in self.structs:
self.struct_dict[c.name] = c
def attach_methods(self):
self.create_struct_dict()
for f in self.functions[:]:
if len(f.args) == 0:
continue
if f.name.endswith('_new') or '_new_' in f.name:
# constructor for another class
continue
arg_type = f.args[0][0]
if arg_type[-1] == '*':
arg_type = arg_type[:-1]
arg_type = arg_type.replace('const ','')
c = self.struct_dict.get(arg_type)
if not c:
continue
c.methods.append(f)
if f.docstring and f.docstring.parameters:
# remove first parameter, which is self/this/etc.
f.docstring.parameters = f.docstring.parameters[1:]
self.functions.remove(f)
def look_for_docstrings(self, srcdir, exception_doc):
def getfunc(name):
funcs = [f for f in self.functions if f.name == name]
if not funcs:
return None
else:
return funcs[0]
regex = re.compile(r'\/\*\*\s(.*?)\*\/', re.DOTALL)
for base, dirnames, filenames in os.walk(srcdir):
bname = os.path.basename(base)
if bname == '.svn':
# ignore svn directories
continue
if not 'Makefile.am' in filenames:
# not a source dir
continue
makefile_am = open(os.path.join(base, 'Makefile.am')).read()
filenames = [x for x in filenames if x.endswith('.c') if x in makefile_am]
for filename in filenames:
s = open(os.path.join(base, filename)).read()
docstrings = regex.findall(s)
for d in docstrings:
docstring = '\n'.join([x[3:] for x in d.splitlines()])
function_name = docstring.splitlines(1)[0].strip().strip(':')
func = getfunc(function_name)
if not func:
continue
func.docstring = DocString(func, docstring, self)
if exception_doc:
lines = os.popen('perl ../utility-scripts/error-analyzer.pl %s' % srcdir, 'r').readlines()
for line in lines:
elts = re.split(r' +',line.strip())
func = getfunc(elts[0])
if func:
func.errors = elts[1:]
class Struct:
def __init__(self, name):
self.name = name[1:] # skip leading _
self.parent = None
self.members = []
self.methods = []
def __repr__(self):
return '<Struct name:%s, childof:%s>' % (self.name, self.parent)
def display(self):
print(self.__repr__())
for m in self.members:
print(' ', m)
for m in self.methods:
print(' ', m)
def getMember(self, name):
l = [m for m in self.members if arg_name(m) == name]
if l:
return l[0]
else:
return None
def getMethod(self, name):
l = [m for m in self.methods if m.name == name]
if l:
return l[0]
else:
return None
toskip = None
class Function:
return_type = None
return_type_qualifier = None
return_arg = None
name = None
rename = None
args = None
docstring = None
return_owner = True
skip = False
errors = None
def __repr__(self):
return '<Function return_type:%s name:%s args:%r>' % (
self.return_arg, self.name, self.args)
def apply_overrides(self):
for func in binding.overrides.findall('func'):
if not binding.match_tag_language(func):
continue
if func.attrib.get('name') != self.name:
continue
for param in func.findall('param'):
try:
arg = [x for x in self.args if x[1] == param.attrib.get('name')][0]
except IndexError:
print_('W: no such param (%s) in function (%s)' % (
param.attrib.get('name'), self.name), file=sys.stderr)
continue
if param.attrib.get('optional') == 'true':
arg[2]['optional'] = True
if param.attrib.get('default'):
arg[2]['default'] = param.attrib.get('default')
if param.attrib.get('type'):
arg[0] = param.attrib.get('type')
if param.attrib.get('elem_type'):
arg[2]['element-type'] = param.attrib.get('elem_type')
if func.attrib.get('rename'):
self.rename = func.attrib.get('rename')
if func.attrib.get('return_owner'):
self.return_owner = (func.attrib.get('return_owner') != 'false')
if func.attrib.get('return_type'):
self.return_type = func.attrib.get('return_type')
if func.attrib.get('skip'):
skip = func.attrib.get('skip')
if skip == 'true':
self.skip = True
elif skip == 'unless-id-wsf' and not binding.options.idwsf:
self.skip = True
elif binding.options.language in skip.split(','):
self.skip = True
if func.attrib.get('return_type_qualifier'):
self.return_type_qualifier = func.attrib.get('return_type_qualifier')
for param in binding.overrides.findall('arg'):
if not binding.match_tag_language(param):
continue
arg_name = param.attrib.get('name')
arg_sub = param.attrib.get('rename')
if arg_name and arg_sub:
args = [ x for x in self.args if x[1] == arg_name]
for arg in args:
arg[2]['original-name'] = arg[1]
arg[1] = arg_sub
class DocString:
orig_docstring = None
parameters = None
return_value = None
description = None
def __init__(self, function, docstring, binding_data):
self.binding_data = binding_data
self.orig_docstring = docstring
self.parameters = []
self.params = {}
lines = docstring.splitlines()
# ignore the first line, it has the symbol name
lines = lines[1:]
# look for parameters
while lines[0].strip():
if not self.parameters and not lines[0].startswith('@'):
# function without parameters
break
if not self.parameters:
self.parameters = []
if lines[0][0] == '@':
splits = lines[0][1:].split(':', 2)
param_name = splits[0]
if len(splits) > 2:
param_options = splits[1]
param_desc = splits[2]
self.parameters.append([param_name, param_desc, param_options])
self.params[param_name] = { 'desc': param_desc, 'options': param_options }
for a in function.args:
if a[1] == param_name or a[2].get('original-name') == param_name:
arg = a
break
else:
raise Exception('should not happen ' + param_name + ' ' + lines[0] + repr(function))
self.annotation2arg(arg, param_options)
else:
param_desc = splits[1]
self.parameters.append([param_name, param_desc])
self.params[param_name] = { 'desc': param_desc }
else:
# continuation of previous description
self.parameters[-1][1] = self.parameters[-1][1] + ' ' + lines[0].strip()
lines = lines[1:]
# blank line then description, till the end or the return value
lines = lines[1:]
self.description = ''
while not lines[0].startswith('Return value'):
self.description += lines[0] + '\n'
if len(lines) == 1:
self.description = self.description.strip()
return
lines = lines[1:]
self.description = self.description.strip()
# return value
if lines[0].startswith('Return value') or lines[0].startswith('Returns'):
lines[0] = lines[0].split(':', 1)[1]
accu = ''
while lines[0].strip():
accu = accu + ' ' + lines[0].strip()
if len(lines) == 1:
break
lines = lines[1:]
# find GObject-introspection annotations
if re.match(r'\s*\(', accu):
annotation, accu = accu.split(':', 1)
self.annotation2arg(function.return_arg, annotation)
self.return_value = accu.strip() # remove leading space
def annotation2arg(self, arg, annotation):
'''Convert GObject-introspection annotations to arg options'''
if 'allow-none' in annotation:
arg[2]['optional'] = True
if re.search(r'\(\s*out\s*\)', annotation):
arg[2]['out'] = True
if re.search(r'\(\s*in\s*\)', annotation):
arg[2]['in'] = True
m = re.search(r'\(\s*default\s*([^ )]*)\s*\)', annotation)
if m:
prefix = ''
if is_boolean(arg):
prefix = 'b:'
elif is_int(arg, self.binding_data):
prefix = 'c:'
else:
raise Exception('should not happen: could not found type for default: ' + annotation)
arg[2]['default'] = prefix + m.group(1)
arg[2]['optional'] = True
m = re.search(r'\(\s*element-type\s+([\w*]+)(?:\s+([\w*]+))?', annotation)
if m:
if len(m.groups()) > 2:
arg[2]['key-type'] = \
convert_type_from_gobject_annotation(m.group(1))
arg[2]['value-type'] = \
convert_type_from_gobject_annotation(m.group(2))
else:
arg[2]['element-type'] = \
convert_type_from_gobject_annotation(m.group(1))
m = re.search(r'\(\s*transfer\s+(\w+)', annotation)
if m:
arg[2]['transfer'] = m.group(1)
def normalise_var(type, name):
if name[0] == '*':
type += '*'
name = name[1:]
return type, name
exclude_private = True
def parse_header(header_file):
global binding
struct_names = {}
in_comment = False
in_enum = False
in_struct = None
in_struct_private = False
in_ifdef_zero = False
lines = open(header_file).readlines()
i = 0
while i < len(lines):
line = lines[i]
while line.endswith('\\\n'):
i += 1
line = line[:-2] + ' ' + lines[i].lstrip()
if in_comment:
if '*/' in line:
in_comment = False
elif '/*' in line and not '*/' in line:
in_comment = True
elif in_ifdef_zero:
# minimal support for code sections commented with #if 0
if line.startswith('#endif'):
in_ifdef_zero = False
elif line.startswith('#if 0'):
in_ifdef_zero = True
elif in_enum:
if line.startswith('}'):
in_enum = False
enum_name = line[2:].strip().strip(';')
binding.enums.append(enum_name)
else:
m = re.match('\s*([a-zA-Z0-9_]+)', line)
if m:
binding.constants.append(('i', m.group(1)))
elif line.startswith('#define'):
m = re.match(r'#define\s+([a-zA-Z0-9_]+)\s+([-\w"]+)', line)
if m:
constant_name = m.group(1)
if constant_name[0] != '_':
# ignore private constants
if '"' in line:
constant_type = 's'
elif m.group(2).startswith('LASSO_'):
l = [ c for c in binding.constants if m.group(2) == c[1] ]
if l:
contant_type = l[0][0]
else:
raise Exception()
else:
constant_type = 'i'
constant = (constant_type, constant_name)
binding.constants.append(constant)
elif line.startswith('typedef enum {'):
in_enum = True
elif line.startswith('typedef struct'):
m = re.match('typedef struct ([a-zA-Z0-9_]+)', line)
if m:
struct_name = m.group(1)
if not (struct_name.endswith('Class') or struct_name.endswith('Private')):
struct_names[struct_name] = True
elif line.startswith('struct _'):
m = re.match('struct ([a-zA-Z0-9_]+)', line)
struct_name = m.group(1)
if struct_name in struct_names:
in_struct = Struct(struct_name)
in_struct_private = False
elif in_struct:
if line.startswith('}'):
if not in_struct.name in binding.structs_toskip:
binding.structs.append(in_struct)
else:
print_('W: skipping structure %s due to overrides.xml' % in_struct.name, file=sys.stderr)
in_struct = None
elif '/*< public >*/' in line:
in_struct_private = False
elif '/*< private >*/' in line:
in_struct_private = True
elif in_struct_private and exclude_private:
pass
elif 'DEPRECATED' in line and exclude_private:
pass
else:
# TODO: Add parsing of OFTYPE
# Transform struct to typedef
# example: "struct _LassoAssertion" -> "LassoAssertion"
line = re.sub('\s+struct _', ' ', line)
member_match = re.match('\s+(\w+)\s+(\*?\w+)', line)
if member_match:
member_type, member_name = normalise_var(member_match.group(1), member_match.group(2))
field = (member_type, member_name, {})
if member_type == 'void*':
print_('W: skipping field %s.%s' % (in_struct.name, member_name), file=sys.stderr)
else:
if is_glist(field) or is_hashtable(field):
found = re.search(r' of ([^*]*)', line)
if found:
field[2]['element-type'] = clean_type(found.group(1))
if member_name == 'parent':
in_struct.parent = member_type
else:
in_struct.members.append(field)
elif line.startswith('LASSO_EXPORT '):
while not line.strip().endswith(';'):
i += 1
line = line[:-1] + ' ' + lines[i].lstrip()
# parse the type, then the name, then argument list
m = re.match(r'LASSO_EXPORT\s+([^(]*(?:\s|\*))(\w+)\s*\(\s*(.*?)\s*\)\s*;', line)
if m and (not exclude_private or not m.group(2).endswith('_get_type')):
return_type, function_name, args = m.groups()
return_type = return_type.strip()
f = Function()
if function_name[0] == '*':
return_type += '*'
function_name = function_name[1:]
if binding.functions_toskip.get(function_name) != 1:
if re.search(r'\<const\>', return_type):
f.return_owner = False
# clean the type
return_type = clean_type(return_type)
if return_type != 'void':
f.return_type = return_type
f.return_arg = (return_type, None, {})
if function_name.endswith('_destroy') and exclude_private:
# skip the _destroy functions, they are just wrapper over
# g_object_unref
pass
else:
f.name = function_name
f.args = []
for arg in [x.strip() for x in args.split(',')]:
arg = clean_type(arg)
if arg == 'void' or arg == '':
continue
m = re.match(r'(.*(?:\s|\*))(\w+)', arg)
if m:
type, name = m.groups()
type = clean_type(type)
f.args.append(list((type, name, {})))
else:
print_('failed to process:', arg, 'in line:', line, file=sys.stderr)
f.skip = True
f.apply_overrides()
if not f.skip:
binding.functions.append(f)
else:
print_('W: skipping function', f, file=sys.stderr)
i += 1
def parse_headers(srcdir):
wsf_prefixes = ['disco_', 'dst_', 'is_', 'profile_service_', 'discovery_',
'wsf_', 'interaction_', 'utility_', 'sa_', 'authentication_',
'wsse_', 'sec_', 'idwsf2_', 'wsf2_', 'wsa_', 'wsu', 'soap_binding']
srcdir = os.path.abspath(srcdir)
parentdir = os.path.dirname(srcdir)
exclusion = ('xml_idff.h', 'xml_idwsf.h', 'xml_saml2.h', \
'xml_idwsf2.h', 'xml_soap11.h',
'lasso_config.h', 'saml2_xsd.h' )
if not binding.options.idwsf:
exclusion += ( 'idwsf_strings.h', )
for base, dirnames, filenames in os.walk(srcdir):
bname = os.path.basename(base)
if bname == '.svn':
# ignore svn directories
continue
if not 'Makefile.am' in filenames:
# not a source dir
continue
if not binding.options.idwsf and (bname == 'id-wsf' or \
bname == 'id-wsf-2.0' or bname == 'ws'):
# ignore ID-WSF
continue
makefile_am = open(os.path.join(base, 'Makefile.am')).read()
filenames = [x for x in filenames if x.endswith('.h') if x in makefile_am]
for filename in filenames:
if filename in exclusion:
continue
if 'private' in filename:
continue
if not binding.options.idwsf:
if True in (filename.startswith(wsf_prefix) for wsf_prefix in wsf_prefixes):
continue
header_path = os.path.join(base, filename)
header_relpath = os.path.relpath(header_path, parentdir)
binding.headers.append(header_relpath)
parse_header(header_path)
binding.constants.append(('b', 'LASSO_WSF_ENABLED'))
def main():
global binding
parser = OptionParser()
parser.add_option('-l', '--language', dest = 'language')
parser.add_option('-s', '--src-dir', dest = 'srcdir', default = '../lasso/')
parser.add_option('--enable-id-wsf', dest = 'idwsf', action = 'store_true')
parser.add_option('--enable-exception-docs', dest= 'exception_doc', action = 'store_true')
options, args = parser.parse_args()
if not options.language:
parser.print_help()
sys.exit(1)
binding = BindingData(options)
parse_headers(options.srcdir)
binding.look_for_docstrings(options.srcdir, options.exception_doc)
binding.order_class_hierarchy()
binding.attach_methods()
if options.language == 'python':
from python import lang
python_binding = lang.Binding(binding)
python_binding.generate()
elif options.language == 'php5':
from php5 import lang
php5_binding = lang.Binding(binding)
php5_binding.generate()
elif options.language == 'java':
from java import lang
java_binding = lang.Binding(binding)
java_binding.generate()
elif options.language == 'java-list':
from java import lang
java_binding = lang.Binding(binding)
java_binding.print_list_of_files()
elif options.language == 'perl':
from perl import lang
perl_binding = lang.Binding(binding)
perl_binding.generate()
if __name__ == '__main__':
main()