Mercurial > hg > orthanc-stone
annotate Resources/CodeGeneration/stonegentool.py @ 508:7105a0bad250 bgo-commands-codegen
- Added HandleSerializedMessage to IStoneApplication (empty impl)
- Split UpdateWebApplication with "WithString" and "WithSerializedMessage" variants
- Due to the modules in TS, globals are now unallowed and the callbacks from C++ to JS are stored in the "window" instance
- Split UpdateStoneApplicationStatusFromCpp with "WithString" and "WithSerializedMessage" variants
- Split NotifyStatusUpdateFromCppToWeb with "WithString" and "WithSerializedMessage" variants
- SendMessageToStoneApplication (C++ global) has been split into SendSerializedMessageToStoneApplication and SendCommandToStoneApplication
- In WasmPlatformApplicationAdapter: HandleMessageFromWeb becomes HandleCommandFromWeb
- In WasmPlatformApplicationAdapter: added HandleSerializedMessageFromWeb
- stonegentool now handles the "json" primitive type (used, a.o., in the VSOL "EditInstance" message)
- Fixed indentation and added json serialization overloads in the stonegentool templates
- Added test of the json primitive type to testWasmIntegrated (in Resources/CodeGeneration)
- Adapted testWasmIntegrated (in Resources/CodeGeneration) to the changes above
| author | Benjamin Golinvaux <bgo@osimis.io> |
|---|---|
| date | Wed, 06 Mar 2019 10:14:59 +0100 |
| parents | ce49eae4c887 |
| children | dea3787a8f4b |
| 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") |
|
508
7105a0bad250
- Added HandleSerializedMessage to IStoneApplication (empty impl)
Benjamin Golinvaux <bgo@osimis.io>
parents:
507
diff
changeset
|
113 retVal = retVal.replace("json", "Json::Value") |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
114 return retVal |
| 470 | 115 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
116 def CanonToTs(canonicalTypename): |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
117 # 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
|
118 # string remains string |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
119 # replace int32 by number |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
120 # replace float32 by number |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
121 # replace float64 by number |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
122 retVal = canonicalTypename |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
123 retVal = retVal.replace("map", "Map") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
124 retVal = retVal.replace("vector", "Array") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
125 retVal = retVal.replace("int32", "number") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
126 retVal = retVal.replace("float32", "number") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
127 retVal = retVal.replace("float64", "number") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
128 retVal = retVal.replace("bool", "boolean") |
|
508
7105a0bad250
- Added HandleSerializedMessage to IStoneApplication (empty impl)
Benjamin Golinvaux <bgo@osimis.io>
parents:
507
diff
changeset
|
129 retVal = retVal.replace("json", "Object") |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
130 return retVal |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
131 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
132 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
|
133 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
|
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 == '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
|
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 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
|
138 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
|
139 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
|
140 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
|
141 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
|
142 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
|
143 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
|
144 return False |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
145 return True |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
146 |
|
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
|
147 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
|
148 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
|
149 |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
150 def RegisterTemplateFunction(template,func): |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
151 """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
|
152 template.globals[func.__name__] = func |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
153 return func |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
154 |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
155 def MakeTemplate(templateStr): |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
156 template = Template(templateStr) |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
157 RegisterTemplateFunction(template,CanonToCpp) |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
158 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
|
159 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
|
160 RegisterTemplateFunction(template,NeedsCppConstruction) |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
161 return template |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
162 |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
163 def MakeTemplateFromFile(templateFileName): |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
164 templateFile = open(templateFileName, "r") |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
165 templateFileContents = templateFile.read() |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
166 return MakeTemplate(templateFileContents) |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
167 templateFile.close() |
| 469 | 168 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
169 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
|
170 """splits "A,B,C" into "A" and "B,C" where A, B and C are type names |
| 471 | 171 (including templates) like "int32", "TotoTutu", or |
| 172 "map<map<int32,vector<string>>,map<string,int32>>" """ | |
| 472 | 173 |
|
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
|
174 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
|
175 raise Exception( |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
176 "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
|
177 + " 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
|
178 ) |
| 471 | 179 |
|
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
|
180 # 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
|
181 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 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
|
183 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
|
184 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
|
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 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
|
188 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
|
189 return (sentence, "") |
| 471 | 190 |
|
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 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
192 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
|
193 """Splits something like |
| 471 | 194 vector<string>,int32,map<string,map<string,int32>> |
| 195 in: | |
| 196 - vector<string> | |
| 197 - int32 | |
| 198 map<string,map<string,int32>> | |
| 199 | |
| 200 This is not possible with a regex so | |
| 201 """ | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
202 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
|
203 tokenList = [] |
| 491 | 204 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
|
205 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
|
206 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
|
207 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
|
208 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
|
209 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
|
210 return tokenList |
| 471 | 211 |
|
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
|
212 |
| 490 | 213 templateRegex = \ |
| 214 re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>") | |
| 472 | 215 |
|
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
|
216 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
217 def ParseTemplateType(typename): |
| 491 | 218 """ If the type is a template like "SOMETHING<SOME<THING,EL<SE>>>", |
| 219 then it returns (true,"SOMETHING","SOME<THING,EL<SE>>") | |
| 470 | 220 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
|
221 |
|
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 # 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
|
223 # 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
|
224 # (space, tab, newline, return or formfeed) |
| 491 | 225 typename = "".join(typename.split()) |
| 226 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
|
227 if matches == None: |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
228 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
|
229 else: |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
230 m = matches |
| 489 | 231 assert len(m.groups()) == 2 |
| 232 # we need to split with the commas that are outside of the | |
| 233 # 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
|
234 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
|
235 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
|
236 |
| 491 | 237 |
| 238 def ComputeOrderFromTypeTree( | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
239 ancestors, |
|
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
240 genOrder, |
|
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
241 shortTypename, schema): |
| 491 | 242 |
| 243 if shortTypename in ancestors: | |
| 489 | 244 raise Exception( |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
245 "Cyclic dependency chain found: the last of " + str(ancestors) + |
|
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
246 + " depends on " + str(shortTypename) + " that is already in the list." |
| 489 | 247 ) |
| 248 | |
| 491 | 249 if not (shortTypename in genOrder): |
| 250 (isTemplate, _, dependentTypenames) = ParseTemplateType(shortTypename) | |
| 489 | 251 if isTemplate: |
| 491 | 252 # if it is a template, it HAS dependent types... They can be |
| 253 # anything (primitive, collection, enum, structs..). | |
| 254 # Let's process them! | |
| 255 for dependentTypename in dependentTypenames: | |
| 489 | 256 # childAncestors = ancestors.copy() NO TEMPLATE ANCESTOR!!! |
| 491 | 257 # childAncestors.append(typename) |
| 258 ComputeOrderFromTypeTree( | |
| 259 ancestors, genOrder, dependentTypename, schema | |
| 489 | 260 ) |
| 261 else: | |
| 491 | 262 # If it is not template, we are only interested if it is a |
| 263 # dependency that we must take into account in the dep graph, | |
| 264 # i.e., a struct. | |
| 265 if IsShortStructType(shortTypename, schema): | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
266 struct = schema[GetLongTypename(shortTypename, schema)] |
| 491 | 267 # The keys in the struct dict are the member names |
| 268 # The values in the struct dict are the member types | |
| 507 | 269 if struct: |
| 270 # we reach this if struct is not None AND not empty | |
| 271 for field in struct.keys(): | |
| 272 # we fill the chain of dependent types (starting here) | |
| 273 ancestors.append(shortTypename) | |
| 274 ComputeOrderFromTypeTree( | |
| 275 ancestors, genOrder, struct[field], schema) | |
| 276 # don't forget to restore it! | |
| 277 ancestors.pop() | |
| 491 | 278 |
| 279 # now we're pretty sure our dependencies have been processed, | |
| 280 # we can start marking our code for generation (it might | |
| 281 # already have been done if someone referenced us earlier) | |
| 282 if not shortTypename in genOrder: | |
| 283 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
|
284 |
| 491 | 285 # +-----------------------+ |
| 286 # | Utility functions | | |
| 287 # +-----------------------+ | |
| 288 | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
289 def IsShortStructType(typename, schema): |
| 491 | 290 fullStructName = "struct " + typename |
| 291 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
|
292 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
293 def GetLongTypename(shortTypename, schema): |
| 491 | 294 if shortTypename.startswith("enum "): |
| 295 raise RuntimeError('shortTypename.startswith("enum "):') | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
296 enumName = "enum " + shortTypename |
| 491 | 297 isEnum = enumName in schema |
| 490 | 298 |
| 491 | 299 if shortTypename.startswith("struct "): |
| 300 raise RuntimeError('shortTypename.startswith("struct "):') | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
301 structName = "struct " + shortTypename |
| 491 | 302 isStruct = ("struct " + shortTypename) in schema |
| 474 | 303 |
| 491 | 304 if isEnum and isStruct: |
| 305 raise RuntimeError('Enums and structs cannot have the same name') | |
| 474 | 306 |
| 491 | 307 if isEnum: |
| 308 return enumName | |
| 309 if isStruct: | |
| 310 return structName | |
| 311 | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
312 def IsTypename(fullName): |
| 491 | 313 return (fullName.startswith("enum ") or fullName.startswith("struct ")) |
| 314 | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
315 def IsEnumType(fullName): |
| 491 | 316 return fullName.startswith("enum ") |
| 490 | 317 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
318 def IsStructType(fullName): |
| 491 | 319 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
|
320 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
321 def GetShortTypename(fullTypename): |
| 491 | 322 if fullTypename.startswith("struct "): |
| 323 return fullTypename[7:] | |
| 324 elif fullTypename.startswith("enum"): | |
| 325 return fullTypename[5:] | |
| 326 else: | |
| 327 raise RuntimeError \ | |
| 328 ('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
|
329 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
330 def CheckSchemaSchema(schema): |
| 491 | 331 if not "rootName" in schema: |
| 332 raise Exception("schema lacks the 'rootName' key") | |
| 333 for name in schema.keys(): | |
| 334 if (not IsEnumType(name)) and (not IsStructType(name)) and \ | |
| 335 (name != 'rootName'): | |
| 336 raise RuntimeError \ | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
337 ('Type "' + str(name) + '" should start with "enum " or "struct "') |
| 491 | 338 |
| 339 # TODO: check enum fields are unique (in whole namespace) | |
| 340 # 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
|
341 # TODO: check that in the source schema, there are spaces after each colon |
| 491 | 342 |
| 343 # +-----------------------+ | |
| 344 # | Main processing logic | | |
| 345 # +-----------------------+ | |
| 346 | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
347 def ComputeRequiredDeclarationOrder(schema): |
| 491 | 348 # sanity check |
| 349 CheckSchemaSchema(schema) | |
| 474 | 350 |
| 491 | 351 # we traverse the type dependency graph and we fill a queue with |
| 352 # the required struct types, in a bottom-up fashion, to compute | |
| 353 # the declaration order | |
| 354 # The genOrder list contains the struct full names in the order | |
| 355 # where they must be defined. | |
| 356 # We do not care about the enums here... They do not depend upon | |
| 357 # anything and we'll handle them, in their original declaration | |
| 358 # order, at the start | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
359 genOrder = [] |
| 491 | 360 for fullName in schema.keys(): |
| 361 if IsStructType(fullName): | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
362 realName = GetShortTypename(fullName) |
|
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
363 ancestors = [] |
| 491 | 364 ComputeOrderFromTypeTree(ancestors, genOrder, realName, schema) |
| 365 return genOrder | |
| 489 | 366 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
367 def ProcessSchema(schema, genOrder): |
| 491 | 368 # sanity check |
| 369 CheckSchemaSchema(schema) | |
| 472 | 370 |
| 491 | 371 # let's doctor the schema to clean it up a bit |
| 372 # 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
|
373 enums = [] |
| 491 | 374 for fullName in schema.keys(): |
| 375 if IsEnumType(fullName): | |
| 376 # convert "enum Toto" to "Toto" | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
377 typename = GetShortTypename(fullName) |
| 491 | 378 enum = {} |
| 379 enum['name'] = typename | |
| 380 assert(type(schema[fullName]) == list) | |
| 381 enum['fields'] = schema[fullName] # must be a list | |
| 382 enums.append(enum) | |
| 489 | 383 |
| 491 | 384 # now that the order has been established, we actually store\ |
| 385 # the structs in the correct order | |
| 386 # the structs are like: | |
| 387 # example = [ | |
| 388 # { | |
| 389 # "name": "Message1", | |
| 390 # "fields": { | |
| 391 # "someMember":"int32", | |
| 392 # "someOtherMember":"vector<string>" | |
| 393 # } | |
| 394 # }, | |
| 395 # { | |
| 396 # "name": "Message2", | |
| 397 # "fields": { | |
| 398 # "someMember":"int32", | |
| 399 # "someOtherMember22":"vector<Message1>" | |
| 400 # } | |
| 401 # } | |
| 402 # ] | |
| 489 | 403 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
404 structs = [] |
| 491 | 405 for i in range(len(genOrder)): |
| 406 # this is already the short name | |
| 407 typename = genOrder[i] | |
| 408 fieldDict = schema["struct " + typename] | |
| 409 struct = {} | |
| 410 struct['name'] = typename | |
| 411 struct['fields'] = fieldDict | |
| 412 structs.append(struct) | |
| 489 | 413 |
| 491 | 414 templatingDict = {} |
| 415 templatingDict['enums'] = enums | |
| 416 templatingDict['structs'] = structs | |
| 417 templatingDict['rootName'] = schema['rootName'] | |
| 489 | 418 |
| 491 | 419 return templatingDict |
| 489 | 420 |
| 491 | 421 # +-----------------------+ |
| 422 # | Write to files | | |
| 423 # +-----------------------+ | |
| 474 | 424 |
| 491 | 425 # def WriteStreamsToFiles(rootName: str, genc: Dict[str, StringIO]) \ |
| 426 # -> None: | |
| 427 # pass | |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
428 |
| 491 | 429 def LoadSchema(fn): |
|
493
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
430 # 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
|
431 # 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
|
432 # (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
|
433 # 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
|
434 # contents never cause an error. |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
435 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
|
436 schemaText = f.read() |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
437 assert(type(schemaText) == str) |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
438 # 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
|
439 # 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
|
440 for i in range(len(schemaText)-1): |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
441 ch = schemaText[i] |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
442 nextCh = schemaText[i+1] |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
443 if ch == ':': |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
444 if not (nextCh == ' ' or nextCh == '\n'): |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
445 assert(False) |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
446 schema = yaml.load(schemaText) |
| 491 | 447 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
|
448 |
| 491 | 449 def GetTemplatingDictFromSchemaFilename(fn): |
| 450 obj = LoadSchema(fn) | |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
451 genOrder = ComputeRequiredDeclarationOrder(obj) |
| 491 | 452 templatingDict = ProcessSchema(obj, genOrder) |
| 507 | 453 currentDT = datetime.datetime.now() |
| 454 templatingDict['currentDatetime'] = str(currentDT) | |
| 491 | 455 return templatingDict |
| 470 | 456 |
| 491 | 457 # +-----------------------+ |
| 458 # | ENTRY POINT | | |
| 459 # +-----------------------+ | |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
460 |
|
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
|
461 if __name__ == "__main__": |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
462 import argparse |
| 468 | 463 |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
464 parser = argparse.ArgumentParser( |
| 491 | 465 usage="""stonegentool.py [-h] [-o OUT_DIR] [-v] input_schema |
| 466 EXAMPLE: python stonegentool.py -o "generated_files/" """ | |
| 467 + """ "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
|
468 ) |
| 491 | 469 parser.add_argument("input_schema", type=str, \ |
| 470 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
|
471 parser.add_argument( |
| 489 | 472 "-o", |
| 473 "--out_dir", | |
| 474 type=str, | |
| 475 default=".", | |
| 476 help="""path of the directory where the files | |
| 477 will be generated. Default is current | |
| 478 working folder""", | |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
479 ) |
|
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
480 parser.add_argument( |
| 489 | 481 "-v", |
| 482 "--verbosity", | |
| 483 action="count", | |
| 484 default=0, | |
| 485 help="""increase output verbosity (0 == errors | |
| 486 only, 1 == some verbosity, 2 == nerd | |
| 487 mode""", | |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
488 ) |
| 468 | 489 |
|
485
772516adcbf6
Ongoing work on code generation. Enums and structs OK in ts and cpp
bgo-osimis
parents:
482
diff
changeset
|
490 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
|
491 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
|
492 outDir = args.out_dir |
| 468 | 493 |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
494 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
|
495 |
|
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 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
|
497 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
|
498 template = MakeTemplateFromFile(tsTemplateFile) |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
499 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
|
500 outputTsFile = os.path.join( \ |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
501 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
|
502 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
|
503 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
|
504 |
|
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 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
|
506 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
|
507 template = MakeTemplateFromFile(cppTemplateFile) |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
508 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
|
509 outputCppFile = os.path.join( \ |
|
496
8b6ceae45ba0
Finished (untested) C++, html, typescript, tsc & browserify production.
bgo-osimis
parents:
494
diff
changeset
|
510 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
|
511 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
|
512 outFile.write(renderedCppCode) |
| 491 | 513 |
| 514 # def GenEnumDecl(genc: GenCode, fullName: str, schema: Dict) -> None: | |
| 515 # """Writes the enumerations in genc""" | |
| 516 # enumDict:Dict=schema[fullName] | |
| 517 # # jinja2 template | |
| 518 # j2cppEnum = Template(trim( | |
| 519 # """ {{fullName}} | |
| 520 # { | |
| 521 # {% for key in enumDict.keys()%} | |
| 522 # {{key}}, | |
| 523 # {%endfor%} | |
| 524 # }; | |
| 525 # """)) | |
| 526 # j2cppEnumR = j2cppEnum.render(locals()) | |
| 527 # genc.cppEnums.write(j2cppEnumR) | |
| 528 | |
| 529 # j2tsEnum = Template(trim( | |
| 530 # """ export {{fullName}} | |
| 531 # { | |
| 532 # {% for key in enumDict.keys()%} | |
| 533 # {{key}}, | |
| 534 # {%endfor%} | |
| 535 # }; | |
| 536 # """)) | |
| 537 # j2cppEnumR = j2cppEnum.render(locals()) | |
| 538 # genc.tsEnums.write(j2cppEnumR) | |
| 539 | |
| 540 | |
| 541 | |
| 542 # def GetSerializationCode(typename: str,valueName: str, tempName: str) | |
| 543 # if IsPrimitiveType(typename) or IsTemplateCollection(typename): | |
| 544 # # no need to write code for the primitive types or collections. | |
| 545 # # It is handled in C++ by the template functions and in TS by | |
| 546 # # the JSON.stringify code. | |
| 547 # elif IsStructType(typename): | |
| 548 # pass | |
| 549 | |
| 550 # def GenStructTypeDeclAndSerialize(genc: GenCode, type, schema) -> None: | |
| 551 # ###### | |
| 552 # # CPP | |
| 553 # ###### | |
| 554 # sampleCpp = """ struct Message1 | |
| 555 # { | |
| 556 # int32_t a; | |
| 557 # std::string b; | |
| 558 # EnumMonth0 c; | |
| 559 # bool d; | |
| 560 # }; | |
| 561 | |
| 562 # Json::Value StoneSerialize(const Message1& value) | |
| 563 # { | |
| 564 # Json::Value result(Json::objectValue); | |
| 565 # result["a"] = StoneSerialize(value.a); | |
| 566 # result["b"] = StoneSerialize(value.b); | |
| 567 # result["c"] = StoneSerialize(value.c); | |
| 568 # result["d"] = StoneSerialize(value.d); | |
| 569 # return result; | |
| 570 # } | |
| 571 # """ | |
| 572 | |
| 573 | |
| 574 # ###### | |
| 575 # # TS | |
| 576 # ###### | |
| 577 # sampleTs = """ | |
| 578 # { | |
| 579 # export class Message1 { | |
| 580 # a: number; | |
| 581 # b: string; | |
| 582 # c: EnumMonth0; | |
| 583 # d: boolean; | |
| 584 # public StoneSerialize(): string { | |
| 585 # let container: object = {}; | |
| 586 # container['type'] = 'Message1'; | |
| 587 # container['value'] = this; | |
| 588 # return JSON.stringify(container); | |
| 589 # } | |
| 590 # }; | |
| 591 # } | |
| 592 # """ | |
| 593 | |
| 594 | |
| 595 | |
| 596 | |
| 597 # tsText: StringIO = StringIO() | |
| 598 # cppText: StringIO = StringIO() | |
| 599 | |
| 600 # tsText.write("class %s\n" % typeDict["name"]) | |
| 601 # tsText.write("{\n") | |
| 602 | |
| 603 # cppText.write("struct %s\n" % typeDict["name"]) | |
| 604 # cppText.write("{\n") | |
| 605 | |
| 606 # """ | |
| 607 | |
| 608 # 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
|
609 |
| 491 | 610 # primitives: |
| 611 # ----------- | |
| 612 # int | |
| 613 # jsonValue val(objectInt); | |
| 614 # val.setValue("$name") | |
| 615 # parent.add(("$name",$name) | |
| 616 # double | |
| 617 # ... | |
| 618 # string | |
| 619 # ... | |
| 620 | |
| 621 # collections: | |
| 622 # ----------- | |
| 623 # dict { } | |
| 624 | |
| 625 # serializeValue() | |
| 626 # """ | |
| 627 | |
| 628 # for i in range(len(typeDict["fields"])): | |
| 629 # field = typeDict["fields"][i] | |
| 630 # name = field["name"] | |
| 631 # tsType = GetTypeScriptTypenameFromCanonical(field["type"]) | |
| 632 # tsText.write(" public %s %s;\n" % (tsType, name)) | |
| 633 # cppType = GetCppTypenameFromCanonical(field["type"]) | |
| 634 # cppText.write(" %s %s;\n" % (cppType, name)) | |
| 635 | |
| 636 # tsText.write("};\n\n") | |
| 637 # cppText.write("};\n\n") | |
| 638 | |
| 639 # genc.tsStructs.write(tsText.getvalue()) | |
| 640 # genc.cppStructs.write(cppText.getvalue()) | |
| 641 | |
| 642 | |
| 643 # def GenerateCodeFromTsTemplate(genc) | |
| 644 | |
| 645 | |
| 646 # +-----------------------+ | |
| 647 # | CODE GENERATION | | |
| 648 # +-----------------------+ | |
| 649 | |
| 650 # def GenPreambles(rootName: str, genc: GenCode) -> None: | |
| 651 # cppPreambleT = Template(trim( | |
| 652 # """// autogenerated by stonegentool on {{time.ctime()}} | |
| 653 # // for module {{rootName}} | |
| 654 # #include <cstdint> | |
| 655 # #include <string> | |
| 656 # #include <vector> | |
| 657 # #include <map> | |
| 658 # namespace {{rootName}} | |
| 659 # { | |
| 660 # Json::Value StoneSerialize(int32_t value) | |
| 661 # { | |
| 662 # Json::Value result(value); | |
| 663 # return result; | |
| 664 # } | |
| 665 # Json::Value StoneSerialize(double value) | |
| 666 # { | |
| 667 # Json::Value result(value); | |
| 668 # return result; | |
| 669 # } | |
| 670 # Json::Value StoneSerialize(bool value) | |
| 671 # { | |
| 672 # Json::Value result(value); | |
| 673 # return result; | |
| 674 # } | |
| 675 # Json::Value StoneSerialize(const std::string& value) | |
| 676 # { | |
| 677 # // the following is better than | |
| 678 # Json::Value result(value.data(),value.data()+value.size()); | |
| 679 # return result; | |
| 680 # } | |
| 681 # template<typename T> | |
| 682 # Json::Value StoneSerialize(const std::map<std::string,T>& value) | |
| 683 # { | |
| 684 # Json::Value result(Json::objectValue); | |
| 685 | |
| 686 # for (std::map<std::string, T>::const_iterator it = value.cbegin(); | |
| 687 # it != value.cend(); ++it) | |
| 688 # { | |
| 689 # // it->first it->second | |
| 690 # result[it->first] = StoneSerialize(it->second); | |
| 691 # } | |
| 692 # return result; | |
| 693 # } | |
| 694 # template<typename T> | |
| 695 # Json::Value StoneSerialize(const std::vector<T>& value) | |
| 696 # { | |
| 697 # Json::Value result(Json::arrayValue); | |
| 698 # for (size_t i = 0; i < value.size(); ++i) | |
| 699 # { | |
| 700 # result.append(StoneSerialize(value[i])); | |
| 701 # } | |
| 702 # return result; | |
| 703 # } | |
| 704 # """ | |
| 705 # cppPreambleR = cppPreambleT.render(locals()) | |
| 706 # genc.cppPreamble.write(cppPreambleR) | |
| 707 | |
| 708 # tsPreambleT = Template(trim( | |
| 709 # """// autogenerated by stonegentool on {{time.ctime()}} | |
| 710 # // for module {{rootName}} | |
| 711 | |
| 712 # namespace {{rootName}} | |
| 713 # { | |
| 714 # """ | |
| 715 # tsPreambleR = tsPreambleT.render(locals()) | |
| 716 # genc.tsPreamble.write(tsPreambleR) | |
| 717 | |
| 718 # def ComputeOrder_ProcessStruct( \ | |
| 719 # genOrder: List[str], name:str, schema: Dict[str, str]) -> None: | |
| 720 # # let's generate the code according to the | |
| 721 # struct = schema[name] | |
| 722 | |
| 723 # if not IsStructType(name): | |
| 724 # 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
|
725 |
|
6fbf2eae7c88
All unit tests pass for generation, including handler and dispatcher
bgo-osimis
parents:
491
diff
changeset
|
726 |