1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
"""
Generator application that generates c++ interfaces code from xml description
usage: Generator.py [-h] --parser-type {sdlrpcv2}
source-xml namespace output-dir
SmartSchema interface generator
positional arguments:
source-xml
namespace
output-dir
optional arguments:
-h, --help show this help message and exit
--parser-type {sdlrpcv2}
"""
import os.path
import argparse
import errno
import sys
import generator.parsers.SDLRPCV1
import generator.parsers.SDLRPCV2
import generator.parsers.JSONRPC
import generator.generators.SmartFactorySDLRPC
import generator.generators.SmartFactoryJSONRPC
from generator.parsers.RPCBase import ParseError
from generator.generators.SmartFactoryBase import GenerateError
SUPPORTED_FORMATS = {
"sdlrpcv1": (generator.parsers.SDLRPCV1.Parser,
generator.generators.SmartFactorySDLRPC.CodeGenerator),
"sdlrpcv2": (generator.parsers.SDLRPCV2.Parser,
generator.generators.SmartFactorySDLRPC.CodeGenerator),
"jsonrpc": (generator.parsers.JSONRPC.Parser,
generator.generators.SmartFactoryJSONRPC.CodeGenerator)
}
def _create_parser():
"""Create parser for parsing command-line arguments.
Returns an instance of argparse.ArgumentParser
"""
parser = argparse.ArgumentParser(
description="SmartSchema interface generator"
)
parser.add_argument("source-xml")
parser.add_argument("namespace")
parser.add_argument("output-dir")
parser.add_argument("--parser-type",
choices=SUPPORTED_FORMATS.keys(),
required=True)
return parser
def _handle_fatal_error(error):
"""Handle fatal error during parsing or code generation.
Keyword arguments:
error -- base exception to handle.
"""
print(error.message)
print
sys.exit(errno.EINVAL)
def main():
"""Main function of the generator that does actual work."""
args = vars(_create_parser().parse_args())
src_xml = args["source-xml"]
src_xml_name = os.path.splitext(os.path.basename(src_xml))[0]
namespace = args["namespace"]
output_dir = args["output-dir"]
parser_type = args["parser_type"]
print("""
Generating interface source code with following parameters:
Source xml : {0}
Namespace : {1}
Output directory: {2}
Parser type : {3}
""".format(src_xml, namespace, output_dir, parser_type))
# Select required parser and code generator
parser = SUPPORTED_FORMATS[parser_type][0]()
code_generator = SUPPORTED_FORMATS[parser_type][1]()
# Convert incoming xml to internal model
try:
interface = parser.parse(args["source-xml"])
except ParseError as error:
_handle_fatal_error(error)
# Generate SmartFactory source code from internal model
try:
code_generator.generate(interface,
src_xml_name,
namespace,
output_dir)
except GenerateError as error:
_handle_fatal_error(error)
print("Done.")
if __name__ == '__main__':
main()
|
