script/generate_param.py

   1 # Unix SMB/CIFS implementation.
   2 # Copyright (C) 2014 Catalyst.Net Ltd
   3 #
   4 # Auto generate param_functions.c
   5 #
   6 #   ** NOTE! The following LGPL license applies to the ldb
   7 #   ** library. This does NOT imply that all of Samba is released
   8 #   ** under the LGPL
   9 #
  10 #  This library is free software; you can redistribute it and/or
  11 #  modify it under the terms of the GNU Lesser General Public
  12 #  License as published by the Free Software Foundation; either
  13 #  version 3 of the License, or (at your option) any later version.
  14 #
  15 #  This library is distributed in the hope that it will be useful,
  16 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 #  Lesser General Public License for more details.
  19 #
  20 #  You should have received a copy of the GNU Lesser General Public
  21 #  License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22 #
  23
  24 import os
  25 import xml.etree.ElementTree as ET
  26 import optparse
  27
  28 # parse command line arguments
  29 parser = optparse.OptionParser()
  30 parser.add_option("-f", "--file", dest="filename",
  31                   help="input file", metavar="FILE")
  32 parser.add_option("-o", "--output", dest="output",
  33                   help='output file', metavar="FILE")
  34 parser.add_option("--mode", type="choice", metavar="<FUNCTIONS|S3PROTO|LIBPROTO|PARAMDEFS|PARAMTABLE>",
  35                   choices=["FUNCTIONS", "S3PROTO", "LIBPROTO", "PARAMDEFS", "PARAMTABLE"], default="FUNCTIONS")
  36 parser.add_option("--scope", metavar="<GLOBAL|LOCAL>",
  37                   choices=["GLOBAL", "LOCAL"], default="GLOBAL")
  38
  39 (options, args) = parser.parse_args()
  40
  41 if options.filename is None:
  42     parser.error("No input file specified")
  43 if options.output is None:
  44     parser.error("No output file specified")
  45
  46
  47 def iterate_all(path):
  48     """Iterate and yield all the parameters.
  49
  50     :param path: path to parameters xml file
  51     """
  52
  53     try:
  54         p = open(path, 'r')
  55     except IOError as e:
  56         raise Exception("Error opening parameters file")
  57     out = p.read()
  58
  59     # parse the parameters xml file
  60     root = ET.fromstring(out)
  61     for parameter in root:
  62         name = parameter.attrib.get("name")
  63         param_type = parameter.attrib.get("type")
  64         context = parameter.attrib.get("context")
  65         func = parameter.attrib.get("function")
  66         synonym = parameter.attrib.get("synonym")
  67         removed = parameter.attrib.get("removed")
  68         generated = parameter.attrib.get("generated_function")
  69         handler = parameter.attrib.get("handler")
  70         enumlist = parameter.attrib.get("enumlist")
  71         deprecated = parameter.attrib.get("deprecated")
  72         synonyms = parameter.findall('synonym')
  73
  74         if removed == "1":
  75             continue
  76
  77         constant = parameter.attrib.get("constant")
  78         parm = parameter.attrib.get("parm")
  79         if name is None or param_type is None or context is None:
  80             raise Exception("Error parsing parameter: " + name)
  81         if func is None:
  82             func = name.replace(" ", "_").lower()
  83         if enumlist is None:
  84             enumlist = "NULL"
  85         if handler is None:
  86             handler = "NULL"
  87         yield {'name': name,
  88                'type': param_type,
  89                'context': context,
  90                'function': func,
  91                'constant': (constant == '1'),
  92                'parm': (parm == '1'),
  93                'synonym' : synonym,
  94                'generated' : generated,
  95                'enumlist' : enumlist,
  96                'handler' : handler,
  97                'deprecated' : deprecated,
  98                'synonyms' : synonyms }
  99
 100
 101 # map doc attributes to a section of the generated function
 102 context_dict = {"G": "_GLOBAL", "S": "_LOCAL"}
 103 param_type_dict = {
 104                     "boolean"      : "_BOOL",
 105                     "list"         : "_LIST",
 106                     "string"       : "_STRING",
 107                     "integer"      : "_INTEGER",
 108                     "enum"         : "_INTEGER",
 109                     "char"         : "_CHAR",
 110                     "boolean-auto" : "_INTEGER",
 111                     "cmdlist"      : "_LIST",
 112                     "bytes"        : "_INTEGER",
 113                     "octal"        : "_INTEGER",
 114                     "ustring"      : "_STRING",
 115                   }
 116
 117
 118 def generate_functions(path_in, path_out):
 119     f = open(path_out, 'w')
 120     try:
 121         f.write('/* This file was automatically generated by generate_param.py. DO NOT EDIT */\n\n')
 122         for parameter in iterate_all(options.filename):
 123             # filter out parameteric options
 124             if ':' in parameter['name']:
 125                 continue
 126             if parameter['synonym'] == "1":
 127                 continue
 128             if parameter['generated'] == "0":
 129                 continue
 130
 131             output_string = "FN"
 132             temp = context_dict.get(parameter['context'])
 133             if temp is None:
 134                 raise Exception(parameter['name'] + " has an invalid context " + parameter['context'])
 135             output_string += temp
 136             if parameter['constant']:
 137                 output_string += "_CONST"
 138             if parameter['parm']:
 139                 output_string += "_PARM"
 140             temp = param_type_dict.get(parameter['type'])
 141             if temp is None:
 142                 raise Exception(parameter['name'] + " has an invalid param type " + parameter['type'])
 143             output_string += temp
 144             f.write(output_string + "(" + parameter['function'] + ", " + parameter['function'] + ')\n')
 145     finally:
 146         f.close()
 147
 148
 149 mapping = {
 150             'boolean'      : 'bool ',
 151             'string'       : 'char *',
 152             'integer'      : 'int ',
 153             'char'         : 'char ',
 154             'list'         : 'const char **',
 155             'enum'         : 'int ',
 156             'boolean-auto' : 'int ',
 157             'cmdlist'      : 'const char **',
 158             'bytes'        : 'int ',
 159             'octal'        : 'int ',
 160             'ustring'      : 'char *',
 161           }
 162
 163
 164 def make_s3_param_proto(path_in, path_out):
 165     file_out = open(path_out, 'w')
 166     try:
 167         file_out.write('/* This file was automatically generated by generate_param.py. DO NOT EDIT */\n\n')
 168         header = get_header(path_out)
 169         file_out.write("#ifndef %s\n" % header)
 170         file_out.write("#define %s\n\n" % header)
 171         for parameter in iterate_all(path_in):
 172             # filter out parameteric options
 173             if ':' in parameter['name']:
 174                 continue
 175             if parameter['synonym'] == "1":
 176                 continue
 177             if parameter['generated'] == "0":
 178                 continue
 179
 180             output_string = ""
 181             if parameter['constant']:
 182                 output_string += 'const '
 183             param_type = mapping.get(parameter['type'])
 184             if param_type is None:
 185                 raise Exception(parameter['name'] + " has an invalid context " + parameter['context'])
 186             output_string += param_type
 187             output_string += "lp_%s" % parameter['function']
 188
 189             param = None
 190             if parameter['parm']:
 191                 param = "const struct share_params *p"
 192             else:
 193                 param = "int"
 194
 195             if parameter['type'] == 'string' and not parameter['constant']:
 196                 if parameter['context'] == 'G':
 197                     output_string += '(TALLOC_CTX *ctx);\n'
 198                 elif parameter['context'] == 'S':
 199                     output_string += '(TALLOC_CTX *ctx, %s);\n' % param
 200                 else:
 201                     raise Exception(parameter['name'] + " has an invalid param type " + parameter['type'])
 202             else:
 203                 if parameter['context'] == 'G':
 204                     output_string += '(void);\n'
 205                 elif parameter['context'] == 'S':
 206                     output_string += '(%s);\n' % param
 207                 else:
 208                     raise Exception(parameter['name'] + " has an invalid param type " + parameter['type'])
 209
 210             file_out.write(output_string)
 211
 212         file_out.write("\n#endif /* %s */\n\n" % header)
 213     finally:
 214         file_out.close()
 215
 216
 217 def make_lib_proto(path_in, path_out):
 218     file_out = open(path_out, 'w')
 219     try:
 220         file_out.write('/* This file was automatically generated by generate_param.py. DO NOT EDIT */\n\n')
 221         for parameter in iterate_all(path_in):
 222             # filter out parameteric options
 223             if ':' in parameter['name']:
 224                 continue
 225             if parameter['synonym'] == "1":
 226                 continue
 227             if parameter['generated'] == "0":
 228                 continue
 229
 230             output_string = ""
 231             if parameter['constant']:
 232                 output_string += 'const '
 233             param_type = mapping.get(parameter['type'])
 234             if param_type is None:
 235                 raise Exception(parameter['name'] + " has an invalid context " + parameter['context'])
 236             output_string += param_type
 237
 238             output_string += "lpcfg_%s" % parameter['function']
 239
 240             if parameter['type'] == 'string' and not parameter['constant']:
 241                 if parameter['context'] == 'G':
 242                     output_string += '(struct loadparm_context *, TALLOC_CTX *ctx);\n'
 243                 elif parameter['context'] == 'S':
 244                     output_string += '(struct loadparm_service *, struct loadparm_service *, TALLOC_CTX *ctx);\n'
 245                 else:
 246                     raise Exception(parameter['name'] + " has an invalid param type " + parameter['type'])
 247             else:
 248                 if parameter['context'] == 'G':
 249                     output_string += '(struct loadparm_context *);\n'
 250                 elif parameter['context'] == 'S':
 251                     output_string += '(struct loadparm_service *, struct loadparm_service *);\n'
 252                 else:
 253                     raise Exception(parameter['name'] + " has an invalid param type " + parameter['type'])
 254
 255             file_out.write(output_string)
 256     finally:
 257         file_out.close()
 258
 259
 260 def get_header(path):
 261     header = os.path.basename(path).upper()
 262     header = header.replace(".", "_").replace("\\", "_").replace("-", "_")
 263     return "__%s__" % header
 264
 265
 266 def make_param_defs(path_in, path_out, scope):
 267     file_out = open(path_out, 'w')
 268     try:
 269         file_out.write('/* This file was automatically generated by generate_param.py. DO NOT EDIT */\n\n')
 270         header = get_header(path_out)
 271         file_out.write("#ifndef %s\n" % header)
 272         file_out.write("#define %s\n\n" % header)
 273         if scope == "GLOBAL":
 274             file_out.write("/**\n")
 275             file_out.write(" * This structure describes global (ie., server-wide) parameters.\n")
 276             file_out.write(" */\n")
 277             file_out.write("struct loadparm_global \n")
 278             file_out.write("{\n")
 279             file_out.write("\tTALLOC_CTX *ctx; /* Context for talloced members */\n")
 280         elif scope == "LOCAL":
 281             file_out.write("/**\n")
 282             file_out.write(" * This structure describes a single service.\n")
 283             file_out.write(" */\n")
 284             file_out.write("struct loadparm_service \n")
 285             file_out.write("{\n")
 286             file_out.write("\tbool   autoloaded;\n")
 287
 288         for parameter in iterate_all(path_in):
 289             # filter out parameteric options
 290             if ':' in parameter['name']:
 291                 continue
 292             if parameter['synonym'] == "1":
 293                 continue
 294
 295             if (scope == "GLOBAL" and parameter['context'] != "G" or
 296                 scope == "LOCAL" and parameter['context'] != "S"):
 297                 continue
 298
 299             output_string = "\t"
 300             param_type = mapping.get(parameter['type'])
 301             if param_type is None:
 302                 raise Exception(parameter['name'] + " has an invalid context " + parameter['context'])
 303             output_string += param_type
 304
 305             output_string += "  %s;\n" % parameter['function']
 306             file_out.write(output_string)
 307
 308         file_out.write("LOADPARM_EXTRA_%sS\n" % scope)
 309         file_out.write("};\n")
 310         file_out.write("\n#endif /* %s */\n\n" % header)
 311     finally:
 312         file_out.close()
 313
 314
 315 type_dict = {
 316               "boolean"      : "P_BOOL",
 317               "boolean-rev"  : "P_BOOLREV",
 318               "boolean-auto" : "P_ENUM",
 319               "list"         : "P_LIST",
 320               "string"       : "P_STRING",
 321               "integer"      : "P_INTEGER",
 322               "enum"         : "P_ENUM",
 323               "char"         : "P_CHAR",
 324               "cmdlist"      : "P_CMDLIST",
 325               "bytes"        : "P_BYTES",
 326               "octal"        : "P_OCTAL",
 327               "ustring"      : "P_USTRING",
 328             }
 329
 330
 331 def make_param_table(path_in, path_out):
 332     file_out = open(path_out, 'w')
 333     try:
 334         file_out.write('/* This file was automatically generated by generate_param.py. DO NOT EDIT */\n\n')
 335         header = get_header(path_out)
 336         file_out.write("#ifndef %s\n" % header)
 337         file_out.write("#define %s\n\n" % header)
 338
 339         file_out.write("struct parm_struct parm_table[] = {\n")
 340
 341         for parameter in iterate_all(path_in):
 342             # filter out parameteric options
 343             if ':' in parameter['name']:
 344                 continue
 345             if parameter['context'] == 'G':
 346                 p_class = "P_GLOBAL"
 347             else:
 348                 p_class = "P_LOCAL"
 349
 350             p_type = type_dict.get(parameter['type'])
 351
 352             if parameter['context'] == 'G':
 353                 temp = "GLOBAL"
 354             else:
 355                 temp = "LOCAL"
 356             offset = "%s_VAR(%s)" % (temp, parameter['function'])
 357
 358             enumlist = parameter['enumlist']
 359             handler = parameter['handler']
 360             synonym = parameter['synonym']
 361             deprecated = parameter['deprecated']
 362             flags_list = []
 363             if synonym == "1":
 364                 flags_list.append("FLAG_SYNONYM")
 365             if deprecated == "1":
 366                 flags_list.append("FLAG_DEPRECATED")
 367             flags = "|".join(flags_list)
 368             synonyms = parameter['synonyms']
 369
 370             file_out.write("\t{\n")
 371             file_out.write("\t\t.label\t\t= \"%s\",\n" % parameter['name'])
 372             file_out.write("\t\t.type\t\t= %s,\n" % p_type)
 373             file_out.write("\t\t.p_class\t= %s,\n" % p_class)
 374             file_out.write("\t\t.offset\t\t= %s,\n" % offset)
 375             file_out.write("\t\t.special\t= %s,\n" % handler)
 376             file_out.write("\t\t.enum_list\t= %s,\n" % enumlist)
 377             if flags != "":
 378                 file_out.write("\t\t.flags\t\t= %s,\n" % flags)
 379             file_out.write("\t},\n")
 380
 381             if synonyms is not None:
 382                 # for synonyms, we only list the synonym flag:
 383                 flags = "FLAG_SYNONYM"
 384                 for syn in synonyms:
 385                     file_out.write("\t{\n")
 386                     file_out.write("\t\t.label\t\t= \"%s\",\n" % syn.text)
 387                     file_out.write("\t\t.type\t\t= %s,\n" % p_type)
 388                     file_out.write("\t\t.p_class\t= %s,\n" % p_class)
 389                     file_out.write("\t\t.offset\t\t= %s,\n" % offset)
 390                     file_out.write("\t\t.special\t= %s,\n" % handler)
 391                     file_out.write("\t\t.enum_list\t= %s,\n" % enumlist)
 392                     if flags != "":
 393                         file_out.write("\t\t.flags\t\t= %s,\n" % flags)
 394                     file_out.write("\t},\n")
 395
 396         file_out.write("\n\t{ .label = NULL }\n")
 397         file_out.write("};\n")
 398         file_out.write("\n#endif /* %s */\n\n" % header)
 399     finally:
 400         file_out.close()
 401
 402
 403 if options.mode == 'FUNCTIONS':
 404     generate_functions(options.filename, options.output)
 405 elif options.mode == 'S3PROTO':
 406     make_s3_param_proto(options.filename, options.output)
 407 elif options.mode == 'LIBPROTO':
 408     make_lib_proto(options.filename, options.output)
 409 elif options.mode == 'PARAMDEFS':
 410     make_param_defs(options.filename, options.output, options.scope)
 411 elif options.mode == 'PARAMTABLE':
 412     make_param_table(options.filename, options.output)