from __future__ import absolute_import, division, print_function

import argparse

import fileinput

import re

import sys

simpletypes = ["int", "gint", "guint", "gboolean", "size_t", "gssize",

"time_t"]

excluded = [

# I don't remember why this function is excluded; something to do

# with the fact that it takes a (const) GList as a parameter.

"purple_presence_add_list",

# These functions are excluded because they involve value of the

# type PurpleConvPlacementFunc, which is a pointer to a function and

# (currently?) can't be translated into a DBus type. Normally,

# functions with untranslatable types are skipped, but this script

# assumes that all non-pointer type names beginning with "Purple"

# are enums, which is not true in this case.

"purple_conversation_placement_add_fnc",

"purple_conversation_placement_get_fnc",

"purple_conversation_placement_get_current_func",

"purple_conversation_placement_set_current_func",

# Similar to the above:

"purple_account_set_register_callback",

"purple_account_unregister",

# Similar to the above:

"purple_protocol_server_iface_unregister_user",

# Similar to the above, again

"purple_menu_action_new",

"purple_menu_action_set_callback",

"purple_menu_action_get_callback",

# These functions are excluded because they involve setting arbitrary

# data via pointers for protocols and UIs. This just won't work.

"purple_blist_get_ui_data",

"purple_blist_set_ui_data",

"purple_blist_node_get_ui_data",

"purple_blist_node_set_ui_data",

"purple_buddy_get_protocol_data",

"purple_buddy_set_protocol_data",

# This is excluded because this script treats PurpleLogReadFlags*

# as pointer to a struct, instead of a pointer to an enum. This

# causes a compilation error. Someone should fix this script.

"purple_log_read",

# Similiar to the above:

"purple_notify_is_valid_ui_handle",

stringlists = [

"purple_prefs_get_path_list",

"purple_prefs_get_string_list",

"purple_uri_list_extract_filenames",

"purple_uri_list_extract_uris",

"purple_prefs_get_children_names",

constlists = [

"purple_account_get_status_types",

"purple_accounts_get_all",

"purple_account_option_get_list",

"purple_connections_get_all",

"purple_connections_get_connecting",

"purple_conversations_get_all",

"purple_conversations_get_ims",

"purple_conversations_get_chats",

"purple_chat_conversation_get_users",

"purple_chat_conversation_get_ignored",

"purple_mime_document_get_fields",

"purple_mime_document_get_parts",

"purple_mime_part_get_fields",

"purple_notify_user_info_get_entries",

"purple_request_fields_get_required",

"purple_request_field_list_get_selected",

"purple_request_field_list_get_items",

"purple_savedstatuses_get_all",

"purple_status_type_get_attrs",

"purple_presence_get_statuses",

"purple_conversation_get_message_history",

pointer = "#pointer#"

class MyException(Exception):

pass

def ctopascal(name):

newname = ""

for word in name.split("_"):

newname += word.capitalize()

return newname

class Parameter(object):

def __init__(self, type, name):

self.name = name

self.type = type

def fromtokens(tokens, parameternumber=-1):

if len(tokens) == 0:

raise MyException()

if len(tokens) == 1 or tokens[-1] == pointer:

if parameternumber >= 0:

return Parameter(tokens, "param%i" % (parameternumber, ))

else:

raise MyException()

else:

return Parameter(tokens[:-1], tokens[-1])

fromtokens = staticmethod(fromtokens)

class Binding(object):

def __init__(self, functiontext, paramtexts, output=None):

self.function = Parameter.fromtokens(functiontext.split())

if self.function.name in excluded:

raise MyException()

self.params = []

for i in range(len(paramtexts)):

self.params.append(Parameter.fromtokens(paramtexts[i].split(), i))

self.call = "%s(%s)" % (self.function.name,

", ".join(param.name for param in self.params))

self.output = output

def process(self):

for param in self.params:

self.processinput(param.type, param.name)

self.processoutput(self.function.type, "RESULT")

self.flush()

def processinput(self, type, name):

const = False

unsigned = False

if type[0] == "const":

type = type[1:]

const = True

if type[0] == "unsigned":

type = type[1:]

unsigned = True

if len(type) == 1:

# simple types (int, gboolean, etc.) and enums

if type[0] in simpletypes or (

type[0].startswith("Purple") and

not type[0].endswith("Callback")):

return self.inputsimple(type, name, unsigned)

# pointers ...

if len(type) == 2 and type[1] == pointer:

# strings

if type[0] in ["char", "gchar"]:

if const:

return self.inputstring(type, name, unsigned)

else:

raise MyException()

elif type[0] == "GHashTable":

return self.inputhash(type, name)

# known object types are transformed to integer handles

elif type[0].startswith("Purple"):

return self.inputpurplestructure(type, name)

# special case for *_get_data functions, be careful here...

elif (type[0] == "size_t" or type[0] == "gsize") and name == "len":

return self.inputgetdata(type, name)

# unknown pointers are always replaced with NULL

else:

return self.inputpointer(type, name)

raise MyException()

def processoutput(self, type, name):

const = False

unsigned = False

# the "void" type is simple ...

if type == ["void"]:

return self.outputvoid(type, name)

if type[0] == "const":

type = type[1:]

const = True

if type[0] == "unsigned":

type = type[1:]

unsigned = True

# a string

if type == ["char", pointer] or type == ["gchar", pointer]:

return self.outputstring(type, name, const)

# simple types (ints, booleans, enums, ...)

if (len(type) == 1 and

(type[0] in simpletypes or type[0].startswith("Purple"))):

return self.outputsimple(type, name, unsigned)

# pointers ...

if len(type) == 2 and type[1] == pointer:

# handles

if type[0].startswith("Purple"):

return self.outputpurplestructure(type, name)

if type[0] in ["GList", "GSList"]:

return self.outputlist(type, name)

# Special case for *_get_data functions

if type[0] == "gconstpointer":

return self.outputgetdata(type, name)

raise MyException()

class ClientBinding(Binding):

def __init__(self, functiontext, paramtexts, knowntypes, headersonly,

**kwargs):

Binding.__init__(self, functiontext, paramtexts, **kwargs)

self.knowntypes = knowntypes

self.headersonly = headersonly

self.paramshdr = []

self.decls = []

self.inputparams = []

self.outputparams = []

self.returncode = []

def flush(self):

paramslist = ", ".join(self.paramshdr)

if paramslist == "":

paramslist = "void"

print("%s %s(%s)" % (self.functiontype, self.function.name,

paramslist),

end=' ',

file=self.output)

if self.headersonly:

print(";", file=self.output)

return

print("{", file=self.output)

for decl in self.decls:

print(decl, file=self.output)

print('dbus_g_proxy_call(purple_proxy, "%s", NULL,' % (

ctopascal(self.function.name), ),

file=self.output)

for type_name in self.inputparams:

print("\t%s, %s, " % type_name, end=' ', file=self.output)

print("G_TYPE_INVALID,", file=self.output)

for type_name in self.outputparams:

print("\t%s, &%s, " % type_name, end=' ', file=self.output)

print("G_TYPE_INVALID);", file=self.output)

for code in self.returncode:

print(code, file=self.output)

print("}\n", file=self.output)

def definepurplestructure(self, type):

if self.headersonly and type[0] not in self.knowntypes:

print("struct _%s;" % (type[0], ), file=self.output)

print("typedef struct _%s %s;" % (type[0], type[0]),

file=self.output)

self.knowntypes.append(type[0])

def inputsimple(self, type, name, us):

self.paramshdr.append("%s %s" % (type[0], name))

if us:

self.inputparams.append(("G_TYPE_UINT", name))

else:

self.inputparams.append(("G_TYPE_INT", name))

def inputstring(self, type, name, us):

if us:

self.paramshdr.append("const unsigned char *%s" % (name, ))

else:

self.paramshdr.append("const char *%s" % (name, ))

self.inputparams.append(("G_TYPE_STRING", name))

def inputpurplestructure(self, type, name):

self.paramshdr.append("const %s *%s" % (type[0], name))

self.inputparams.append(("G_TYPE_INT",

"GPOINTER_TO_INT(%s)" % (name, )))

self.definepurplestructure(type)

def inputpointer(self, type, name):

name += "_NULL"

self.paramshdr.append("const %s *%s" % (type[0], name))

self.inputparams.append(("G_TYPE_INT", "0"))

def inputhash(self, type, name):

self.paramshdr.append("const GHashTable *%s" % (name, ))

self.inputparams.append(

('dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_STRING)',

name))

def outputvoid(self, type, name):

self.functiontype = "void"

def outputstring(self, type, name, const):

self.functiontype = "char*"

self.decls.append("char *%s = NULL;" % (name, ))

self.outputparams.append(("G_TYPE_STRING", name))

self.returncode.append("return %s;" % (name, ))

def outputsimple(self, type, name, us):

self.functiontype = type[0]

self.decls.append("%s %s = 0;" % (type[0], name))

if us:

self.outputparams.append(("G_TYPE_UINT", name))

else:

self.outputparams.append(("G_TYPE_INT", name))

self.returncode.append("return %s;" % (name, ))

# we could add "const" to the return type but this would probably

# be a nuisance

def outputpurplestructure(self, type, name):

name = name + "_ID"

self.functiontype = "%s*" % (type[0], )

self.decls.append("int %s = 0;" % (name, ))

self.outputparams.append(("G_TYPE_INT", "%s" % (name, )))

self.returncode.append("return (%s*) GINT_TO_POINTER(%s);" % (type[0],

name))

self.definepurplestructure(type)

def outputlist(self, type, name):

self.functiontype = "%s*" % (type[0], )

self.decls.append("GArray *%s;" % (name, ))

self.outputparams.append(

('dbus_g_type_get_collection("GArray", G_TYPE_INT)', name))

self.returncode.append("return garray_int_to_%s(%s);" %

(type[0].lower(), name))

# Special case for *_get_data functions, don't need client bindings,

# but do need the name so it doesn't crash

def inputgetdata(self, type, name):

raise MyException()

def outputgetdata(self, type, name):

raise MyException()

class ServerBinding(Binding):

def __init__(self, functiontext, paramtexts, **kwargs):

Binding.__init__(self, functiontext, paramtexts, **kwargs)

self.dparams = ""

self.cparams = []

self.cdecls = []

self.ccode = []

self.cparamsout = []

self.ccodeout = []

self.argfunc = "dbus_message_get_args"

def flush(self):

print("static DBusMessage*", file=self.output)

print("%s_DBUS(DBusMessage *message_DBUS, DBusError *error_DBUS) {" %

self.function.name,

file=self.output)

print("\tDBusMessage *reply_DBUS;", file=self.output)

for decl in self.cdecls:

print(decl, file=self.output)

print("\t%s(message_DBUS, error_DBUS," % (self.argfunc, ), end=' ',

file=self.output)

for param in self.cparams:

print("DBUS_TYPE_%s, &%s," % param, end=' ', file=self.output)

print("DBUS_TYPE_INVALID);", file=self.output)

print("\tCHECK_ERROR(error_DBUS);", file=self.output)

for code in self.ccode:

print(code, file=self.output)

print("\treply_DBUS = dbus_message_new_method_return (message_DBUS);",

file=self.output)

print("\tdbus_message_append_args(reply_DBUS,", end=' ',

file=self.output)

for param in self.cparamsout:

if type(param) is str:

print("%s," % (param, ), end=' ', file=self.output)

else:

print("DBUS_TYPE_%s, &%s," % param, end=' ', file=self.output)

print("DBUS_TYPE_INVALID);", file=self.output)

for code in self.ccodeout:

print(code, file=self.output)

print("\treturn reply_DBUS;\n}\n", file=self.output)

def addstring(self, *items):

for item in items:

self.dparams += item + r"\0"

def addintype(self, type, name):

self.addstring("in", type, name)

def addouttype(self, type, name):

self.addstring("out", type, name)

# input parameters

def inputsimple(self, type, name, us):

if us:

self.cdecls.append("\tdbus_uint32_t %s;" % (name, ))

self.cparams.append(("UINT32", name))

self.addintype("u", name)

else:

self.cdecls.append("\tdbus_int32_t %s;" % (name, ))

self.cparams.append(("INT32", name))

self.addintype("i", name)

def inputstring(self, type, name, us):

if us:

self.cdecls.append("\tconst unsigned char *%s;" % (name, ))

else:

self.cdecls.append("\tconst char *%s;" % (name, ))

self.cparams.append(("STRING", name))

self.ccode.append(

"\t%s = (%s && %s[0]) ? %s : NULL;" % (name, name, name, name))

self.addintype("s", name)

def inputhash(self, type, name):

self.argfunc = "purple_dbus_message_get_args"

self.cdecls.append("\tDBusMessageIter %s_ITER;" % (name, ))

self.cdecls.append("\tGHashTable *%s;" % (name, ))

self.cparams.append(("ARRAY", "%s_ITER" % (name, )))

self.ccode.append(

"\t%s = purple_dbus_iter_hash_table(&%s_ITER, error_DBUS);" % (

name,

name))

self.ccode.append("\tCHECK_ERROR(error_DBUS);")

self.ccodeout.append("\tg_hash_table_destroy(%s);" % (name, ))

self.addintype("a{ss}", name)

def inputpurplestructure(self, type, name):

self.cdecls.append("\tdbus_int32_t %s_ID;" % (name, ))

self.cdecls.append("\t%s *%s;" % (type[0], name))

self.cparams.append(("INT32", name + "_ID"))

self.ccode.append(

"\tPURPLE_DBUS_ID_TO_POINTER(%s, %s_ID, %s, error_DBUS);" % (

name,

name,

type[0]))

self.addintype("i", name)

def inputpointer(self, type, name):

self.cdecls.append("\tdbus_int32_t %s_NULL;" % (name, ))

self.cdecls.append("\t%s *%s;" % (type[0], name))

self.cparams.append(("INT32", name + "_NULL"))

self.ccode.append("\t%s = NULL;" % (name, ))

self.addintype("i", name)

# output parameters

def outputvoid(self, type, name):

self.ccode.append("\t%s;" % (self.call, )) # just call the function

def outputstring(self, type, name, const):

if const:

self.cdecls.append("\tconst char *%s;" % (name, ))

else:

self.cdecls.append("\tchar *%s;" % (name, ))

self.ccode.append("\tif ((%s = %s) == NULL)" % (name, self.call))

self.ccode.append("\t\t%s = \"\";" % (name, ))

self.cparamsout.append(("STRING", name))

self.addouttype("s", name)

if not const:

self.ccodeout.append("\tg_free(%s);" % (name, ))

def outputsimple(self, type, name, us):

if us:

self.cdecls.append("\tdbus_uint32_t %s;" % (name, ))

self.cparamsout.append(("UINT32", name))

self.addouttype("u", name)

else:

self.cdecls.append("\tdbus_int32_t %s;" % (name, ))

self.cparamsout.append(("INT32", name))

self.addouttype("i", name)

self.ccode.append("\t%s = %s;" % (name, self.call))

def outputpurplestructure(self, type, name):

self.cdecls.append("\tdbus_int32_t %s;" % (name, ))

self.ccode.append(

"\tPURPLE_DBUS_POINTER_TO_ID(%s, %s, error_DBUS);" % (name,

self.call))

self.cparamsout.append(("INT32", name))

self.addouttype("i", name)

# GList*, GSList*, assume that list is a list of objects

# unless the function is in stringlists

def outputlist(self, type, name):

self.cdecls.append("\tdbus_int32_t %s_LEN;" % (name, ))

self.ccodeout.append("\tg_free(%s);" % (name, ))

self.cdecls.append("\t%s *list;" % (type[0], ))

if self.function.name in stringlists:

self.cdecls.append("\tchar **%s;" % (name, ))

self.ccode.append("\tlist = %s;" % (self.call, ))

self.ccode.append(

"\t%s = (char **)purple_%s_to_array(list, &%s_LEN);" % (

name,

type[0],

name))

self.cparamsout.append(

"DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &%s, %s_LEN" % (name,

name))

if self.function.name not in constlists:

type_name = type[0].lower()[1:]

self.ccodeout.append(

"\tg_%s_foreach(list, (GFunc)g_free, NULL);" % (

type_name, ))

self.ccodeout.append("\tg_%s_free(list);" % (type_name, ))

self.addouttype("as", name)

else:

self.cdecls.append("\tdbus_int32_t *%s;" % (name, ))

self.ccode.append("\tlist = %s;" % (self.call, ))

self.ccode.append("\t%s = purple_dbusify_%s(list, &%s_LEN);" % (

name,

type[0],

name))

if self.function.name not in constlists:

type_name = type[0].lower()[1:]

self.ccode.append("\tg_%s_free(list);" % (type_name, ))

self.cparamsout.append(

"DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &%s, %s_LEN" % (name, name))

self.addouttype("ai", name)

# Special case for *_get_data functions

def inputgetdata(self, type, name):

self.cdecls.append("\tsize_t %s = 0;" % (name, ))

return True

def outputgetdata(self, type, name):

# This is a total hack, but self.call is set up before the parameters

# are processed, so we can't tell it to pass a parameter by reference.

params = ', '.join('&len' if param.name == 'len' else param.name

for param in self.params)

self.call = "%s(%s)" % (self.function.name, params)

self.cdecls.append("\tgconstpointer %s;" % (name, ))

self.ccode.append("\t%s = %s;" % (name, self.call))

self.cparamsout.append("DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &%s, %s" % (

name,

"len"))

self.addouttype("ay", name)

class BindingSet(object):

regexp = r"^(\w[^()]*)\(([^()]*)\)\s*;\s*$"

def __init__(self, inputfile, fprefix, output=None):

self.inputiter = iter(inputfile)

self.functionregexp = re.compile(

"^%s(\w[^()]*)\(([^()]*)\)\s*;\s*$" % (fprefix, ))

self.typeregexp = re.compile("^\w+\s*\*?\s*$")

self.output = output

def process(self):

print("/* Generated by %s. Do not edit! */" % (sys.argv[0], ),

file=self.output)

for line in self.inputiter:

words = line.split()

if len(words) == 0: # empty line

continue

if line[0] == "#": # preprocessor directive

continue

if words[0] in ["typedef", "struct", "enum", "static"]:

continue

# accumulate lines until the parentheses are balance or an

# empty line has been encountered

myline = line.strip()

while (myline.count("(") > myline.count(")") or

self.typeregexp.match(myline)):

newline = next(self.inputiter).strip()

if len(newline) == 0:

break

myline += " " + newline

# is this a function declaration?

thematch = self.functionregexp.match(

myline.replace("*", " " + pointer + " "))

if thematch is None:

continue

functiontext = thematch.group(1)

paramstext = thematch.group(2).strip()

if (paramstext == "void") or (paramstext == ""):

paramtexts = []

else:

paramtexts = paramstext.split(",")

try:

self.processfunction(functiontext, paramtexts)

except MyException:

pass

except:

raise

self.flush()

class ServerBindingSet (BindingSet):

def __init__(self, inputfile, fprefix, **kwargs):

BindingSet.__init__(self, inputfile, fprefix, **kwargs)

self.functions = []

def processfunction(self, functiontext, paramtexts):

binding = ServerBinding(functiontext, paramtexts, output=self.output)

binding.process()

self.functions.append((binding.function.name, binding.dparams))

def flush(self):

print("static PurpleDBusBinding bindings_DBUS[] = { ",

file=self.output)

for function, params in self.functions:

print('{"%s", "%s", %s_DBUS},' %

(ctopascal(function), params, function), file=self.output)

print("{NULL, NULL, NULL}", file=self.output)

print("};", file=self.output)

print("#define PURPLE_DBUS_REGISTER_BINDINGS(handle) "

"purple_dbus_register_bindings(handle, bindings_DBUS)",

file=self.output)

class ClientBindingSet (BindingSet):

def __init__(self, inputfile, fprefix, headersonly, **kwargs):

BindingSet.__init__(self, inputfile, fprefix, **kwargs)

self.functions = []

self.knowntypes = []

self.headersonly = headersonly

def processfunction(self, functiontext, paramtexts):

binding = ClientBinding(functiontext, paramtexts, self.knowntypes,

self.headersonly, output=self.output)

binding.process()

def flush(self):

pass

parser = argparse.ArgumentParser()

parser.add_argument('input', nargs='*',

help='Input files (or stdin if not specified)')

parser.add_argument('-o', '--output',

help='Output to file instead of stdout')

parser.add_argument('-a', '--append', action='store_true',

help='Append to file instead of overwriting it')

parser.add_argument('-e', '--export-only', action='store_true',

help='Prefix functions for export')

parser.add_argument('-c', '--client', action='store_true',

help='Produce client bindings instead of server bindings')

parser.add_argument('-H', '--headers', action='store_true',

help='Produce headers only')

args = parser.parse_args()

if args.export_only:

fprefix = "DBUS_EXPORT\s+"

fprefix = ""

myinput = fileinput.input(args.input)

if args.output is not None:

output = open(args.output, 'a' if args.append else 'w')

output = None

if args.client:

bindings = ClientBindingSet(myinput, fprefix, args.headers, output=output)

bindings = ServerBindingSet(myinput, fprefix, output=output)