orthanc-stone: Resources/CodeGeneration/stonegentool.py comparison

comparison Resources/CodeGeneration/stonegentool.py @ 489:f6b7f113cf27 bgo-commands-codegen

Ongoing work on code generation

author	bgo-osimis
date	Mon, 18 Feb 2019 07:46:59 +0100
parents	8e40355a172b
children	6470248790db

comparison

equal deleted inserted replaced

-:8e40355a172b
+:f6b7f113cf27
 import json
 import re
 import sys
 from typing import (
 Any,
 Dict,
 Generator,
 Iterable,
 Iterator,
 List,
 Match,
 Optional,
 Tuple,
 Union,
 cast,
 )
 from io import StringIO
 import time
 """
 1         2         3         4         5         6         7
 12345678901234567890123456789012345678901234567890123456789012345678901234567890
 """
 class GeneratedCode:
 def __init__(self):
-self.cppPreamble = StringIO() # file-wide preamble (#include directives, comment...)
-self.cppEnums = StringIO()
+# file-wide preamble (#include directives, comment...)
-self.cppStructs = StringIO()
+self.cppPreamble = StringIO()
-self.cppDispatcher = StringIO()
-self.cppHandler = StringIO()
+self.cppEnums = StringIO()
+self.cppStructs = StringIO()
-self.tsPreamble = StringIO() # file-wide preamble (module directives, comment...)
+self.cppDispatcher = StringIO()
-self.tsEnums = StringIO()
+self.cppHandler = StringIO()
-self.tsStructs = StringIO()
-self.tsDispatcher = StringIO()
+# file-wide preamble (module directives, comment...)
-self.tsHandler = StringIO()
+self.tsPreamble = StringIO()
-def FlattenToFiles(self,outputDir: str):
+self.tsEnums = StringIO()
-raise NotImplementedError()
+self.tsStructs = StringIO()
+self.tsDispatcher = StringIO()
+self.tsHandler = StringIO()
+def FlattenToFiles(self, outputDir: str):
+raise NotImplementedError()
+raise Exception("""
+$$$$TODO check field names are unique
+""")
 class JsonHelpers:
 """A set of utilities to perform JSON operations"""
 @staticmethod
 retVal = retVal.replace("vector", "std::vector")
 retVal = retVal.replace("int32", "int32_t")
 retVal = retVal.replace("float32", "float")
 retVal = retVal.replace("float64", "double")
 return retVal
 def GetTypeScriptTypeNameFromCanonical(canonicalTypeName: str) -> str:
 # TS: replace vector with Array and map with Map
 # string remains string
 # replace int32 by number
 raise Exception("schema lacks the 'root_name' key")
 if not "types" in schema:
 raise Exception("schema lacks the 'types' key")
 for definedType in schema["types"]:
 CheckTypeSchema(definedType)
-# def CreateAndCacheTypeObject(allTypes : Dict[str,Type], typeDict : Dict)  -> None:
-#   """This does not set the dependentTypes field"""
-#   typeName : str = typeDict['name']
-#   if typeName in allTypes:
-#     raise Exception(f'Type {typeName} is defined more than once!')
-#   else:
-#     typeObject = Type(typeName, typeDict['kind'])
-#     allTypes[typeName] = typeObject
 def EatToken(sentence: str) -> Tuple[str, str]:
 """splits "A,B,C" into "A" and "B,C" where A, B and C are type names
 (including templates) like "int32", "TotoTutu", or
 matches = templateRegex.match(typeName)
 if matches == None:
 return (False, "", [])
 else:
 m = cast(Match[str], matches)
-assert(len(m.groups()) == 2)
+assert len(m.groups()) == 2
-# we need to split with the commas that are outside of the defined types
+# we need to split with the commas that are outside of the
-# simply splitting at commas won't work
+# defined types. Simply splitting at commas won't work
 listOfDependentTypes = SplitListOfTypes(m.group(2))
 return (True, m.group(1), listOfDependentTypes)
 # def GetPrimitiveType(typeName : str) -> Type:
 ancestors: List[str],
 genOrderQueue: List[str],
 structTypes: Dict[str, Dict],
 typeName: str,
 ) -> None:
 if typeName in ancestors:
 raise Exception(
 f"Cyclic dependency chain found: the last of {ancestors} "
 + f"depends on {typeName} that is already in the list."
+)
+if not (typeName in genOrderQueue):
+# if we reach this point, it means the type is NOT a struct or an enum.
+# it is another (non directly user-defined) type that we must parse and
+# create. Let's do it!
+(isTemplate, _, dependentTypeNames) = ParseTemplateType(typeName)
+if isTemplate:
+for dependentTypeName in dependentTypeNames:
+# childAncestors = ancestors.copy()  NO TEMPLATE ANCESTOR!!!
+# childAncestors.append(typeName)
+ProcessTypeTree(
+ancestors, genOrderQueue, structTypes, dependentTypeName
 )
+else:
-if not (typeName in genOrderQueue):
+if typeName in structTypes:
-# if we reach this point, it means the type is NOT a struct or an enum.
+ProcessStructType_DepthFirstRecursive(
-# it is another (non directly user-defined) type that we must parse and
+genOrderQueue, structTypes, structTypes[typeName]
-# create. Let's do it!
-(isTemplate, _, dependentTypeNames) = ParseTemplateType(typeName)
-if isTemplate:
-for dependentTypeName in dependentTypeNames:
-# childAncestors = ancestors.copy()  NO TEMPLATE ANCESTOR!!!
-# childAncestors.append(typeName)
-ProcessTypeTree(
-ancestors, genOrderQueue, structTypes, dependentTypeName
-)
-else:
-if typeName in structTypes:
-ProcessStructType_DepthFirstRecursive(
-genOrderQueue, structTypes, structTypes[typeName]
-)
-def ProcessStructType_DepthFirstRecursive(
-genOrderQueue: List[str], structTypes: Dict[str, Dict], typeDict: Dict) -> None:
-# let's generate the code according to the
-typeName: str = typeDict["name"]
-if typeDict["kind"] != "struct":
-raise Exception(
-f"Unexpected kind '{typeDict['kind']}' for " + "type '{typeName}'"
 )
-typeFields: List[Dict] = typeDict["fields"]
-for typeField in typeFields:
+def ProcessStructType_DepthFirstRecursive(genOrderQueue: List[str], \
-ancestors = [typeName]
+structTypes: Dict[str, Dict], typeDict: Dict) -> None:
-ProcessTypeTree(ancestors, genOrderQueue, structTypes, typeField["type"])
+# let's generate the code according to the
-# now we're pretty sure our dependencies have been processed,
+typeName: str = typeDict["name"]
-# we can start marking our code for generation (it might already have
+if typeDict["kind"] != "struct":
-# been done if someone referenced us earlier)
+raise Exception(
-if not typeName in genOrderQueue:
+f"Unexpected kind '{typeDict['kind']}' for " + "type '{typeName}'"
-genOrderQueue.append(typeName)
+)
+typeFields: List[Dict] = typeDict["fields"]
-def ProcessEnumerationType(
+for typeField in typeFields:
-outputStreams: GeneratedCode, typeDict: Dict) -> None:
+ancestors = [typeName]
-tsText : StringIO = StringIO()
+ProcessTypeTree(ancestors, genOrderQueue, structTypes, typeField["type"])
-cppText : StringIO = StringIO()
+# now we're pretty sure our dependencies have been processed,
+# we can start marking our code for generation (it might already have
+# been done if someone referenced us earlier)
+if not typeName in genOrderQueue:
+genOrderQueue.append(typeName)
+def ProcessEnumerationType(outputStreams: GeneratedCode, typeDict: Dict) -> None:
+tsText: StringIO = StringIO()
+cppText: StringIO = StringIO()
+tsText.write("enum %s\n" % typeDict["name"])
+tsText.write("{\n")
+cppText.write("enum %s\n" % typeDict["name"])
+cppText.write("{\n")
+for i in range(len(typeDict["fields"])):
+field = typeDict["fields"][i]
+name = field["name"]
+tsText.write("    %s" % name)
+if i < len(typeDict["fields"]) - 1:
+tsText.write(",")
+tsText.write("\n")
+cppText.write("    %s" % name)
+if i < len(typeDict["fields"]) - 1:
+cppText.write(",")
+cppText.write("\n")
+tsText.write("};\n\n")
+cppText.write("};\n\n")
+outputStreams.tsEnums.write(tsText.getvalue())
+outputStreams.cppEnums.write(cppText.getvalue())
+def GetSerializationCode(typeName: str,valueName: str, tempName: str)
+if IsPrimitiveType(typeName):
+"""
+json::Value val(objectTypeInt...)
+val.setValue(valueName) <--- val
+"""
+elif IsArray(typeName)
+"""
+{
+json::Value val(objectTypeArray...)
+for(size_t i = 0; i < {fieldName}.size(); ++i)
+{
+json::Value val(objectTypeArray...)
+}
+val.setValue(valueName)
+// <--- the calling code will insert collection/field writing here,
+// like "parent.set("{fieldName}",val) or parent.append(val)
+$collectValue
+}
+"""
+def ProcessStructType(outputStreams: GeneratedCode, typeDict) -> None:
+tsText: StringIO = StringIO()
+cppText: StringIO = StringIO()
+tsText.write("class %s\n" % typeDict["name"])
+tsText.write("{\n")
+cppText.write("struct %s\n" % typeDict["name"])
+cppText.write("{\n")
+"""
-tsText.write("enum %s\n" % typeDict['name'])
+GenerateSerializationCode(typeName,valueName)
-tsText.write("{\n")
+primitives:
-cppText.write("enum %s\n" % typeDict['name'])
+-----------
-cppText.write("{\n")
+int
+jsonValue val(objectInt);
-for i in range(len(typeDict['fields'])):
+val.setValue("$name")
-field = typeDict['fields'][i]
+parent.add(("$name",$name)
-name = field['name']
+double
+...
-tsText.write("    %s" % name)
+string
-if i < len(typeDict['fields'])-1:
+...
-tsText.write(",")
-tsText.write("\n")
+collections:
+-----------
-cppText.write("    %s" % name)
+dict { }
-if i < len(typeDict['fields'])-1:
-cppText.write(",")
-cppText.write("\n")
+serializeValue()
+"""
+for i in range(len(typeDict["fields"])):
+field = typeDict["fields"][i]
+name = field["name"]
+tsType = GetTypeScriptTypeNameFromCanonical(field["type"])
+tsText.write("    public %s %s;\n" % (tsType, name))
+cppType = GetCppTypeNameFromCanonical(field["type"])
+cppText.write("    %s %s;\n" % (cppType, name))
 tsText.write("};\n\n")
 cppText.write("};\n\n")
-outputStreams.tsEnums.write(tsText.getvalue())
-outputStreams.cppEnums.write(cppText.getvalue())
-def ProcessStructType(
-outputStreams: GeneratedCode, typeDict) -> None:
-tsText : StringIO = StringIO()
-cppText : StringIO = StringIO()
-tsText.write("class %s\n" % typeDict['name'])
-tsText.write("{\n")
-cppText.write("struct %s\n" % typeDict['name'])
-cppText.write("{\n")
-for i in range(len(typeDict['fields'])):
-field = typeDict['fields'][i]
-name = field['name']
-tsType = GetTypeScriptTypeNameFromCanonical(field['type'])
-tsText.write("    public %s %s;\n" % (tsType, name))
-cppType = GetCppTypeNameFromCanonical(field['type'])
-cppText.write("    %s %s;\n" % (cppType, name))
-tsText.write("};\n\n")
-cppText.write("};\n\n")
 outputStreams.tsStructs.write(tsText.getvalue())
 outputStreams.cppStructs.write(cppText.getvalue())
 def WritePreambles(rootName: str, outputStreams: GeneratedCode) -> None:
-outputStreams.cppPreamble.write("""// autogenerated by stonegentool on %s for module %s
+outputStreams.cppPreamble.write(
+"""// autogenerated by stonegentool on %s for module %s
 #include <cstdint>
 #include <string>
 #include <vector>
 #include <map>
-""" % (time.ctime(),rootName))
+""" % (time.ctime(), rootName))
-outputStreams.tsPreamble.write("""// autogenerated by stonegentool on %s for module %s
+outputStreams.tsPreamble.write(
-""" % (time.ctime(),rootName))
+"""// autogenerated by stonegentool on %s for module %s
+""" % (time.ctime(), rootName))
 def ProcessSchema(schema: dict) -> Tuple[str, GeneratedCode, List[str]]:
 CheckSchemaSchema(schema)
 rootName: str = schema["root_name"]
 definedTypes: list = schema["types"]
 # this will be filled with the generation queue. That is, the type
 # names in the order where they must be defined.
 genOrderQueue: List = []
 # the struct names are mapped to their JSON dictionary
 structTypes: Dict[str, Dict] = {}
-outputStreams : GeneratedCode = GeneratedCode()
+outputStreams: GeneratedCode = GeneratedCode()
 WritePreambles(rootName, outputStreams)
 # the order here is the generation order
 for definedType in definedTypes:
 if definedType["kind"] == "enum":
 ProcessEnumerationType(outputStreams, definedType)
 for definedType in definedTypes:
 if definedType["kind"] == "struct":
 structTypes[definedType["name"]] = definedType
 # the order here is NOT the generation order: the types
 # will be processed according to their dependency graph
 for definedType in definedTypes:
 if definedType["kind"] == "struct":
 ProcessStructType_DepthFirstRecursive(
 genOrderQueue, structTypes, definedType
 )
 for i in range(len(genOrderQueue)):
 typeName = genOrderQueue[i]
 typeDict = structTypes[typeName]
 ProcessStructType(outputStreams, typeDict)
 return (rootName, outputStreams, genOrderQueue)
 def WriteStreamsToFiles(rootName: str, outputStreams: Dict[str, StringIO]) -> None:
 pass
 if __name__ == "__main__":
 import argparse
 parser = argparse.ArgumentParser(
 usage="""stonegentool.py [-h] [-o OUT_DIR] [-v] input_schemas
 EXAMPLE: python command_gen.py -o "generated_files/" """
 + """ "mainSchema.json,App Specific Commands.json" """
 )
 parser.add_argument("input_schema", type=str, help="path to the schema file")
 parser.add_argument(
 "-o",
 "--out_dir",
 type=str,
 default=".",
 help="""path of the directory where the files
 will be generated. Default is current
 working folder""",
 )
 parser.add_argument(
 "-v",
 "--verbosity",
 action="count",
 default=0,
 help="""increase output verbosity (0 == errors
 only, 1 == some verbosity, 2 == nerd
 mode""",
 )
 args = parser.parse_args()
 inputSchemaFilename = args.input_schema
 outDir = args.out_dir

Mercurial > hg > orthanc-stone

comparison Resources/CodeGeneration/stonegentool.py @ 489:f6b7f113cf27 bgo-commands-codegen