Mercurial > hg > orthanc-stone
annotate Resources/CodeGeneration/stonegentool.py @ 507:ce49eae4c887 bgo-commands-codegen
Codegen + Warning fixes
author | Benjamin Golinvaux <bgo@osimis.io> |
---|---|
date | Fri, 01 Mar 2019 16:18:38 +0100 |
parents | 8b6ceae45ba0 |
children | 7105a0bad250 |
rev | line source |
---|---|
471 | 1 import json |
491 | 2 import yaml |
471 | 3 import re |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
4 import os |
473 | 5 import sys |
491 | 6 from jinja2 import Template |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
7 from io import StringIO |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
8 import time |
507 | 9 import datetime |
469 | 10 |
472 | 11 """ |
12 1 2 3 4 5 6 7 | |
13 12345678901234567890123456789012345678901234567890123456789012345678901234567890 | |
14 """ | |
15 | |
491 | 16 # see https://stackoverflow.com/a/2504457/2927708 |
17 def trim(docstring): | |
18 if not docstring: | |
19 return '' | |
20 # Convert tabs to spaces (following the normal Python rules) | |
21 # and split into a list of lines: | |
22 lines = docstring.expandtabs().splitlines() | |
23 # Determine minimum indentation (first line doesn't count): | |
24 indent = sys.maxsize | |
25 for line in lines[1:]: | |
26 stripped = line.lstrip() | |
27 if stripped: | |
28 indent = min(indent, len(line) - len(stripped)) | |
29 # Remove indentation (first line is special): | |
30 trimmed = [lines[0].strip()] | |
31 if indent < sys.maxsize: | |
32 for line in lines[1:]: | |
33 trimmed.append(line[indent:].rstrip()) | |
34 # Strip off trailing and leading blank lines: | |
35 while trimmed and not trimmed[-1]: | |
36 trimmed.pop() | |
37 while trimmed and not trimmed[0]: | |
38 trimmed.pop(0) | |
39 # Return a single string: | |
40 return '\n'.join(trimmed) | |
41 | |
42 | |
43 class GenCode: | |
489 | 44 def __init__(self): |
45 | |
46 # file-wide preamble (#include directives, comment...) | |
47 self.cppPreamble = StringIO() | |
48 | |
49 self.cppEnums = StringIO() | |
50 self.cppStructs = StringIO() | |
51 self.cppDispatcher = StringIO() | |
52 self.cppHandler = StringIO() | |
473 | 53 |
489 | 54 # file-wide preamble (module directives, comment...) |
55 self.tsPreamble = StringIO() | |
56 | |
57 self.tsEnums = StringIO() | |
58 self.tsStructs = StringIO() | |
59 self.tsDispatcher = StringIO() | |
60 self.tsHandler = StringIO() | |
486
8e40355a172b
Unit tests OK for preambles, enums and structs in both TS and C++
bgo-osimis
parents:
485
diff
changeset
|
61 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
62 def FlattenToFiles(self, outputDir): |
489 | 63 raise NotImplementedError() |
64 | |
65 | |
473 | 66 class JsonHelpers: |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
67 """A set of utilities to perform JSON operations""" |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
68 |
473 | 69 @staticmethod |
70 def removeCommentsFromJsonContent(string): | |
71 """ | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
72 Remove comments from a JSON file |
473 | 73 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
74 Comments are not allowed in JSON but, i.e., Orthanc configuration files |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
75 contains C++ like comments that we need to remove before python can |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
76 parse the file |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
77 """ |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
78 # remove all occurrence streamed comments (/*COMMENT */) from string |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
79 string = re.sub(re.compile("/\*.*?\*/", re.DOTALL), "", string) |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
80 |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
81 # remove all occurrence singleline comments (//COMMENT\n ) from string |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
82 string = re.sub(re.compile("//.*?\n"), "", string) |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
83 |
473 | 84 return string |
85 | |
86 @staticmethod | |
87 def loadJsonWithComments(path): | |
88 """ | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
89 Reads a JSON file that may contain C++ like comments |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
90 """ |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
91 with open(path, "r") as fp: |
473 | 92 fileContent = fp.read() |
93 fileContent = JsonHelpers.removeCommentsFromJsonContent(fileContent) | |
94 return json.loads(fileContent) | |
95 | |
96 | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
97 def LoadSchemaFromJson(filePath): |
473 | 98 return JsonHelpers.loadJsonWithComments(filePath) |
469 | 99 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
100 def CanonToCpp(canonicalTypename): |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
101 # C++: prefix map vector and string with std::map, std::vector and |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
102 # std::string |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
103 # replace int32 by int32_t |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
104 # replace float32 by float |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
105 # replace float64 by double |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
106 retVal = canonicalTypename |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
107 retVal = retVal.replace("map", "std::map") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
108 retVal = retVal.replace("vector", "std::vector") |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
109 retVal = retVal.replace("string", "std::string") |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
110 retVal = retVal.replace("int32", "int32_t") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
111 retVal = retVal.replace("float32", "float") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
112 retVal = retVal.replace("float64", "double") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
113 return retVal |
470 | 114 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
115 def CanonToTs(canonicalTypename): |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
116 # TS: replace vector with Array and map with Map |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
117 # string remains string |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
118 # replace int32 by number |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
119 # replace float32 by number |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
120 # replace float64 by number |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
121 retVal = canonicalTypename |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
122 retVal = retVal.replace("map", "Map") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
123 retVal = retVal.replace("vector", "Array") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
124 retVal = retVal.replace("int32", "number") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
125 retVal = retVal.replace("float32", "number") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
126 retVal = retVal.replace("float64", "number") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
127 retVal = retVal.replace("bool", "boolean") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
128 return retVal |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
129 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
130 def NeedsTsConstruction(enums, tsType): |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
131 if tsType == 'boolean': |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
132 return False |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
133 elif tsType == 'number': |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
134 return False |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
135 elif tsType == 'string': |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
136 return False |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
137 else: |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
138 enumNames = [] |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
139 for enum in enums: |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
140 enumNames.append(enum['name']) |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
141 if tsType in enumNames: |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
142 return False |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
143 return True |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
144 |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
145 def NeedsCppConstruction(canonTypename): |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
146 return False |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
147 |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
148 def RegisterTemplateFunction(template,func): |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
149 """Makes a function callable by a jinja2 template""" |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
150 template.globals[func.__name__] = func |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
151 return func |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
152 |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
153 def MakeTemplate(templateStr): |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
154 template = Template(templateStr) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
155 RegisterTemplateFunction(template,CanonToCpp) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
156 RegisterTemplateFunction(template,CanonToTs) |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
157 RegisterTemplateFunction(template,NeedsTsConstruction) |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
158 RegisterTemplateFunction(template,NeedsCppConstruction) |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
159 return template |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
160 |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
161 def MakeTemplateFromFile(templateFileName): |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
162 templateFile = open(templateFileName, "r") |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
163 templateFileContents = templateFile.read() |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
164 return MakeTemplate(templateFileContents) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
165 templateFile.close() |
469 | 166 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
167 def EatToken(sentence): |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
168 """splits "A,B,C" into "A" and "B,C" where A, B and C are type names |
471 | 169 (including templates) like "int32", "TotoTutu", or |
170 "map<map<int32,vector<string>>,map<string,int32>>" """ | |
472 | 171 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
172 if sentence.count("<") != sentence.count(">"): |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
173 raise Exception( |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
174 "Error in the partial template type list " + str(sentence) + "." |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
175 + " The number of < and > do not match!" |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
176 ) |
471 | 177 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
178 # the template level we're currently in |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
179 templateLevel = 0 |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
180 for i in range(len(sentence)): |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
181 if (sentence[i] == ",") and (templateLevel == 0): |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
182 return (sentence[0:i], sentence[i + 1 :]) |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
183 elif sentence[i] == "<": |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
184 templateLevel += 1 |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
185 elif sentence[i] == ">": |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
186 templateLevel -= 1 |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
187 return (sentence, "") |
471 | 188 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
189 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
190 def SplitListOfTypes(typename): |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
191 """Splits something like |
471 | 192 vector<string>,int32,map<string,map<string,int32>> |
193 in: | |
194 - vector<string> | |
195 - int32 | |
196 map<string,map<string,int32>> | |
197 | |
198 This is not possible with a regex so | |
199 """ | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
200 stillStuffToEat = True |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
201 tokenList = [] |
491 | 202 restOfString = typename |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
203 while stillStuffToEat: |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
204 firstToken, restOfString = EatToken(restOfString) |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
205 tokenList.append(firstToken) |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
206 if restOfString == "": |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
207 stillStuffToEat = False |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
208 return tokenList |
471 | 209 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
210 |
490 | 211 templateRegex = \ |
212 re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>") | |
472 | 213 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
214 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
215 def ParseTemplateType(typename): |
491 | 216 """ If the type is a template like "SOMETHING<SOME<THING,EL<SE>>>", |
217 then it returns (true,"SOMETHING","SOME<THING,EL<SE>>") | |
470 | 218 otherwise it returns (false,"","")""" |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
219 |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
220 # let's remove all whitespace from the type |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
221 # split without argument uses any whitespace string as separator |
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
222 # (space, tab, newline, return or formfeed) |
491 | 223 typename = "".join(typename.split()) |
224 matches = templateRegex.match(typename) | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
225 if matches == None: |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
226 return (False, "", []) |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
227 else: |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
228 m = matches |
489 | 229 assert len(m.groups()) == 2 |
230 # we need to split with the commas that are outside of the | |
231 # defined types. Simply splitting at commas won't work | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
232 listOfDependentTypes = SplitListOfTypes(m.group(2)) |
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
233 return (True, m.group(1), listOfDependentTypes) |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
234 |
491 | 235 |
236 def ComputeOrderFromTypeTree( | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
237 ancestors, |
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
238 genOrder, |
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
239 shortTypename, schema): |
491 | 240 |
241 if shortTypename in ancestors: | |
489 | 242 raise Exception( |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
243 "Cyclic dependency chain found: the last of " + str(ancestors) + |
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
244 + " depends on " + str(shortTypename) + " that is already in the list." |
489 | 245 ) |
246 | |
491 | 247 if not (shortTypename in genOrder): |
248 (isTemplate, _, dependentTypenames) = ParseTemplateType(shortTypename) | |
489 | 249 if isTemplate: |
491 | 250 # if it is a template, it HAS dependent types... They can be |
251 # anything (primitive, collection, enum, structs..). | |
252 # Let's process them! | |
253 for dependentTypename in dependentTypenames: | |
489 | 254 # childAncestors = ancestors.copy() NO TEMPLATE ANCESTOR!!! |
491 | 255 # childAncestors.append(typename) |
256 ComputeOrderFromTypeTree( | |
257 ancestors, genOrder, dependentTypename, schema | |
489 | 258 ) |
259 else: | |
491 | 260 # If it is not template, we are only interested if it is a |
261 # dependency that we must take into account in the dep graph, | |
262 # i.e., a struct. | |
263 if IsShortStructType(shortTypename, schema): | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
264 struct = schema[GetLongTypename(shortTypename, schema)] |
491 | 265 # The keys in the struct dict are the member names |
266 # The values in the struct dict are the member types | |
507 | 267 if struct: |
268 # we reach this if struct is not None AND not empty | |
269 for field in struct.keys(): | |
270 # we fill the chain of dependent types (starting here) | |
271 ancestors.append(shortTypename) | |
272 ComputeOrderFromTypeTree( | |
273 ancestors, genOrder, struct[field], schema) | |
274 # don't forget to restore it! | |
275 ancestors.pop() | |
491 | 276 |
277 # now we're pretty sure our dependencies have been processed, | |
278 # we can start marking our code for generation (it might | |
279 # already have been done if someone referenced us earlier) | |
280 if not shortTypename in genOrder: | |
281 genOrder.append(shortTypename) | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
282 |
491 | 283 # +-----------------------+ |
284 # | Utility functions | | |
285 # +-----------------------+ | |
286 | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
287 def IsShortStructType(typename, schema): |
491 | 288 fullStructName = "struct " + typename |
289 return (fullStructName in schema) | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
290 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
291 def GetLongTypename(shortTypename, schema): |
491 | 292 if shortTypename.startswith("enum "): |
293 raise RuntimeError('shortTypename.startswith("enum "):') | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
294 enumName = "enum " + shortTypename |
491 | 295 isEnum = enumName in schema |
490 | 296 |
491 | 297 if shortTypename.startswith("struct "): |
298 raise RuntimeError('shortTypename.startswith("struct "):') | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
299 structName = "struct " + shortTypename |
491 | 300 isStruct = ("struct " + shortTypename) in schema |
474 | 301 |
491 | 302 if isEnum and isStruct: |
303 raise RuntimeError('Enums and structs cannot have the same name') | |
474 | 304 |
491 | 305 if isEnum: |
306 return enumName | |
307 if isStruct: | |
308 return structName | |
309 | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
310 def IsTypename(fullName): |
491 | 311 return (fullName.startswith("enum ") or fullName.startswith("struct ")) |
312 | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
313 def IsEnumType(fullName): |
491 | 314 return fullName.startswith("enum ") |
490 | 315 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
316 def IsStructType(fullName): |
491 | 317 return fullName.startswith("struct ") |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
318 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
319 def GetShortTypename(fullTypename): |
491 | 320 if fullTypename.startswith("struct "): |
321 return fullTypename[7:] | |
322 elif fullTypename.startswith("enum"): | |
323 return fullTypename[5:] | |
324 else: | |
325 raise RuntimeError \ | |
326 ('fullTypename should start with either "struct " or "enum "') | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
327 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
328 def CheckSchemaSchema(schema): |
491 | 329 if not "rootName" in schema: |
330 raise Exception("schema lacks the 'rootName' key") | |
331 for name in schema.keys(): | |
332 if (not IsEnumType(name)) and (not IsStructType(name)) and \ | |
333 (name != 'rootName'): | |
334 raise RuntimeError \ | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
335 ('Type "' + str(name) + '" should start with "enum " or "struct "') |
491 | 336 |
337 # TODO: check enum fields are unique (in whole namespace) | |
338 # TODO: check struct fields are unique (in each struct) | |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
339 # TODO: check that in the source schema, there are spaces after each colon |
491 | 340 |
341 # +-----------------------+ | |
342 # | Main processing logic | | |
343 # +-----------------------+ | |
344 | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
345 def ComputeRequiredDeclarationOrder(schema): |
491 | 346 # sanity check |
347 CheckSchemaSchema(schema) | |
474 | 348 |
491 | 349 # we traverse the type dependency graph and we fill a queue with |
350 # the required struct types, in a bottom-up fashion, to compute | |
351 # the declaration order | |
352 # The genOrder list contains the struct full names in the order | |
353 # where they must be defined. | |
354 # We do not care about the enums here... They do not depend upon | |
355 # anything and we'll handle them, in their original declaration | |
356 # order, at the start | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
357 genOrder = [] |
491 | 358 for fullName in schema.keys(): |
359 if IsStructType(fullName): | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
360 realName = GetShortTypename(fullName) |
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
361 ancestors = [] |
491 | 362 ComputeOrderFromTypeTree(ancestors, genOrder, realName, schema) |
363 return genOrder | |
489 | 364 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
365 def ProcessSchema(schema, genOrder): |
491 | 366 # sanity check |
367 CheckSchemaSchema(schema) | |
472 | 368 |
491 | 369 # let's doctor the schema to clean it up a bit |
370 # order DOES NOT matter for enums, even though it's a list | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
371 enums = [] |
491 | 372 for fullName in schema.keys(): |
373 if IsEnumType(fullName): | |
374 # convert "enum Toto" to "Toto" | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
375 typename = GetShortTypename(fullName) |
491 | 376 enum = {} |
377 enum['name'] = typename | |
378 assert(type(schema[fullName]) == list) | |
379 enum['fields'] = schema[fullName] # must be a list | |
380 enums.append(enum) | |
489 | 381 |
491 | 382 # now that the order has been established, we actually store\ |
383 # the structs in the correct order | |
384 # the structs are like: | |
385 # example = [ | |
386 # { | |
387 # "name": "Message1", | |
388 # "fields": { | |
389 # "someMember":"int32", | |
390 # "someOtherMember":"vector<string>" | |
391 # } | |
392 # }, | |
393 # { | |
394 # "name": "Message2", | |
395 # "fields": { | |
396 # "someMember":"int32", | |
397 # "someOtherMember22":"vector<Message1>" | |
398 # } | |
399 # } | |
400 # ] | |
489 | 401 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
402 structs = [] |
491 | 403 for i in range(len(genOrder)): |
404 # this is already the short name | |
405 typename = genOrder[i] | |
406 fieldDict = schema["struct " + typename] | |
407 struct = {} | |
408 struct['name'] = typename | |
409 struct['fields'] = fieldDict | |
410 structs.append(struct) | |
489 | 411 |
491 | 412 templatingDict = {} |
413 templatingDict['enums'] = enums | |
414 templatingDict['structs'] = structs | |
415 templatingDict['rootName'] = schema['rootName'] | |
489 | 416 |
491 | 417 return templatingDict |
489 | 418 |
491 | 419 # +-----------------------+ |
420 # | Write to files | | |
421 # +-----------------------+ | |
474 | 422 |
491 | 423 # def WriteStreamsToFiles(rootName: str, genc: Dict[str, StringIO]) \ |
424 # -> None: | |
425 # pass | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
426 |
491 | 427 def LoadSchema(fn): |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
428 # latin-1 is a trick, when we do NOT care about NON-ascii chars but |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
429 # we wish to avoid using a decoding error handler |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
430 # (see http://python-notes.curiousefficiency.org/en/latest/python3/text_file_processing.html#files-in-an-ascii-compatible-encoding-best-effort-is-acceptable) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
431 # TL;DR: all 256 values are mapped to characters in latin-1 so the file |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
432 # contents never cause an error. |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
433 with open(fn, 'r', encoding='latin-1') as f: |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
434 schemaText = f.read() |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
435 assert(type(schemaText) == str) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
436 # ensure there is a space after each colon. Otherwise, dicts could be |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
437 # erroneously recognized as an array of strings containing ':' |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
438 for i in range(len(schemaText)-1): |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
439 ch = schemaText[i] |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
440 nextCh = schemaText[i+1] |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
441 if ch == ':': |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
442 if not (nextCh == ' ' or nextCh == '\n'): |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
443 assert(False) |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
444 schema = yaml.load(schemaText) |
491 | 445 return schema |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
446 |
491 | 447 def GetTemplatingDictFromSchemaFilename(fn): |
448 obj = LoadSchema(fn) | |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
449 genOrder = ComputeRequiredDeclarationOrder(obj) |
491 | 450 templatingDict = ProcessSchema(obj, genOrder) |
507 | 451 currentDT = datetime.datetime.now() |
452 templatingDict['currentDatetime'] = str(currentDT) | |
491 | 453 return templatingDict |
470 | 454 |
491 | 455 # +-----------------------+ |
456 # | ENTRY POINT | | |
457 # +-----------------------+ | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
458 |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
459 if __name__ == "__main__": |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
460 import argparse |
468 | 461 |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
462 parser = argparse.ArgumentParser( |
491 | 463 usage="""stonegentool.py [-h] [-o OUT_DIR] [-v] input_schema |
464 EXAMPLE: python stonegentool.py -o "generated_files/" """ | |
465 + """ "mainSchema.yaml,App Specific Commands.json" """ | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
466 ) |
491 | 467 parser.add_argument("input_schema", type=str, \ |
468 help="path to the schema file") | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
469 parser.add_argument( |
489 | 470 "-o", |
471 "--out_dir", | |
472 type=str, | |
473 default=".", | |
474 help="""path of the directory where the files | |
475 will be generated. Default is current | |
476 working folder""", | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
477 ) |
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
478 parser.add_argument( |
489 | 479 "-v", |
480 "--verbosity", | |
481 action="count", | |
482 default=0, | |
483 help="""increase output verbosity (0 == errors | |
484 only, 1 == some verbosity, 2 == nerd | |
485 mode""", | |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
486 ) |
468 | 487 |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
488 args = parser.parse_args() |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
489 schemaFile = args.input_schema |
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
490 outDir = args.out_dir |
468 | 491 |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
492 tdico = GetTemplatingDictFromSchemaFilename(schemaFile) |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
493 |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
494 tsTemplateFile = \ |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
495 os.path.join(os.path.dirname(__file__), 'template.in.ts') |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
496 template = MakeTemplateFromFile(tsTemplateFile) |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
497 renderedTsCode = template.render(**tdico) |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
498 outputTsFile = os.path.join( \ |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
499 outDir,str(tdico['rootName']) + "_generated.ts") |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
500 with open(outputTsFile,"wt",encoding='utf8') as outFile: |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
501 outFile.write(renderedTsCode) |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
502 |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
503 cppTemplateFile = \ |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
504 os.path.join(os.path.dirname(__file__), 'template.in.h') |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
505 template = MakeTemplateFromFile(cppTemplateFile) |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
506 renderedCppCode = template.render(**tdico) |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
507 outputCppFile = os.path.join( \ |
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
508 outDir, str(tdico['rootName']) + "_generated.hpp") |
494
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
509 with open(outputCppFile,"wt",encoding='utf8') as outFile: |
fc17251477d6
TS and CPP tests OK. Ongoing code for C++ program that reads list of serialized messages in N files. Requires conan
bgo-osimis
parents:
493
diff
changeset
|
510 outFile.write(renderedCppCode) |
491 | 511 |
512 # def GenEnumDecl(genc: GenCode, fullName: str, schema: Dict) -> None: | |
513 # """Writes the enumerations in genc""" | |
514 # enumDict:Dict=schema[fullName] | |
515 # # jinja2 template | |
516 # j2cppEnum = Template(trim( | |
517 # """ {{fullName}} | |
518 # { | |
519 # {% for key in enumDict.keys()%} | |
520 # {{key}}, | |
521 # {%endfor%} | |
522 # }; | |
523 # """)) | |
524 # j2cppEnumR = j2cppEnum.render(locals()) | |
525 # genc.cppEnums.write(j2cppEnumR) | |
526 | |
527 # j2tsEnum = Template(trim( | |
528 # """ export {{fullName}} | |
529 # { | |
530 # {% for key in enumDict.keys()%} | |
531 # {{key}}, | |
532 # {%endfor%} | |
533 # }; | |
534 # """)) | |
535 # j2cppEnumR = j2cppEnum.render(locals()) | |
536 # genc.tsEnums.write(j2cppEnumR) | |
537 | |
538 | |
539 | |
540 # def GetSerializationCode(typename: str,valueName: str, tempName: str) | |
541 # if IsPrimitiveType(typename) or IsTemplateCollection(typename): | |
542 # # no need to write code for the primitive types or collections. | |
543 # # It is handled in C++ by the template functions and in TS by | |
544 # # the JSON.stringify code. | |
545 # elif IsStructType(typename): | |
546 # pass | |
547 | |
548 # def GenStructTypeDeclAndSerialize(genc: GenCode, type, schema) -> None: | |
549 # ###### | |
550 # # CPP | |
551 # ###### | |
552 # sampleCpp = """ struct Message1 | |
553 # { | |
554 # int32_t a; | |
555 # std::string b; | |
556 # EnumMonth0 c; | |
557 # bool d; | |
558 # }; | |
559 | |
560 # Json::Value StoneSerialize(const Message1& value) | |
561 # { | |
562 # Json::Value result(Json::objectValue); | |
563 # result["a"] = StoneSerialize(value.a); | |
564 # result["b"] = StoneSerialize(value.b); | |
565 # result["c"] = StoneSerialize(value.c); | |
566 # result["d"] = StoneSerialize(value.d); | |
567 # return result; | |
568 # } | |
569 # """ | |
570 | |
571 | |
572 # ###### | |
573 # # TS | |
574 # ###### | |
575 # sampleTs = """ | |
576 # { | |
577 # export class Message1 { | |
578 # a: number; | |
579 # b: string; | |
580 # c: EnumMonth0; | |
581 # d: boolean; | |
582 # public StoneSerialize(): string { | |
583 # let container: object = {}; | |
584 # container['type'] = 'Message1'; | |
585 # container['value'] = this; | |
586 # return JSON.stringify(container); | |
587 # } | |
588 # }; | |
589 # } | |
590 # """ | |
591 | |
592 | |
593 | |
594 | |
595 # tsText: StringIO = StringIO() | |
596 # cppText: StringIO = StringIO() | |
597 | |
598 # tsText.write("class %s\n" % typeDict["name"]) | |
599 # tsText.write("{\n") | |
600 | |
601 # cppText.write("struct %s\n" % typeDict["name"]) | |
602 # cppText.write("{\n") | |
603 | |
604 # """ | |
605 | |
606 # GenerateSerializationCode(typename,valueName) | |
482
f58fe38c8c04
Ongoing work on codegen: ts and cpp enum and struct writing seem to be OK. No file write yet
bgo-osimis
parents:
474
diff
changeset
|
607 |
491 | 608 # primitives: |
609 # ----------- | |
610 # int | |
611 # jsonValue val(objectInt); | |
612 # val.setValue("$name") | |
613 # parent.add(("$name",$name) | |
614 # double | |
615 # ... | |
616 # string | |
617 # ... | |
618 | |
619 # collections: | |
620 # ----------- | |
621 # dict { } | |
622 | |
623 # serializeValue() | |
624 # """ | |
625 | |
626 # for i in range(len(typeDict["fields"])): | |
627 # field = typeDict["fields"][i] | |
628 # name = field["name"] | |
629 # tsType = GetTypeScriptTypenameFromCanonical(field["type"]) | |
630 # tsText.write(" public %s %s;\n" % (tsType, name)) | |
631 # cppType = GetCppTypenameFromCanonical(field["type"]) | |
632 # cppText.write(" %s %s;\n" % (cppType, name)) | |
633 | |
634 # tsText.write("};\n\n") | |
635 # cppText.write("};\n\n") | |
636 | |
637 # genc.tsStructs.write(tsText.getvalue()) | |
638 # genc.cppStructs.write(cppText.getvalue()) | |
639 | |
640 | |
641 # def GenerateCodeFromTsTemplate(genc) | |
642 | |
643 | |
644 # +-----------------------+ | |
645 # | CODE GENERATION | | |
646 # +-----------------------+ | |
647 | |
648 # def GenPreambles(rootName: str, genc: GenCode) -> None: | |
649 # cppPreambleT = Template(trim( | |
650 # """// autogenerated by stonegentool on {{time.ctime()}} | |
651 # // for module {{rootName}} | |
652 # #include <cstdint> | |
653 # #include <string> | |
654 # #include <vector> | |
655 # #include <map> | |
656 # namespace {{rootName}} | |
657 # { | |
658 # Json::Value StoneSerialize(int32_t value) | |
659 # { | |
660 # Json::Value result(value); | |
661 # return result; | |
662 # } | |
663 # Json::Value StoneSerialize(double value) | |
664 # { | |
665 # Json::Value result(value); | |
666 # return result; | |
667 # } | |
668 # Json::Value StoneSerialize(bool value) | |
669 # { | |
670 # Json::Value result(value); | |
671 # return result; | |
672 # } | |
673 # Json::Value StoneSerialize(const std::string& value) | |
674 # { | |
675 # // the following is better than | |
676 # Json::Value result(value.data(),value.data()+value.size()); | |
677 # return result; | |
678 # } | |
679 # template<typename T> | |
680 # Json::Value StoneSerialize(const std::map<std::string,T>& value) | |
681 # { | |
682 # Json::Value result(Json::objectValue); | |
683 | |
684 # for (std::map<std::string, T>::const_iterator it = value.cbegin(); | |
685 # it != value.cend(); ++it) | |
686 # { | |
687 # // it->first it->second | |
688 # result[it->first] = StoneSerialize(it->second); | |
689 # } | |
690 # return result; | |
691 # } | |
692 # template<typename T> | |
693 # Json::Value StoneSerialize(const std::vector<T>& value) | |
694 # { | |
695 # Json::Value result(Json::arrayValue); | |
696 # for (size_t i = 0; i < value.size(); ++i) | |
697 # { | |
698 # result.append(StoneSerialize(value[i])); | |
699 # } | |
700 # return result; | |
701 # } | |
702 # """ | |
703 # cppPreambleR = cppPreambleT.render(locals()) | |
704 # genc.cppPreamble.write(cppPreambleR) | |
705 | |
706 # tsPreambleT = Template(trim( | |
707 # """// autogenerated by stonegentool on {{time.ctime()}} | |
708 # // for module {{rootName}} | |
709 | |
710 # namespace {{rootName}} | |
711 # { | |
712 # """ | |
713 # tsPreambleR = tsPreambleT.render(locals()) | |
714 # genc.tsPreamble.write(tsPreambleR) | |
715 | |
716 # def ComputeOrder_ProcessStruct( \ | |
717 # genOrder: List[str], name:str, schema: Dict[str, str]) -> None: | |
718 # # let's generate the code according to the | |
719 # struct = schema[name] | |
720 | |
721 # if not IsStructType(name): | |
722 # raise Exception(f'{typename} should start with "struct "') | |
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
723 |
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
724 |