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