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

comparison Resources/CodeGeneration/stonegentool.py @ 496:8b6ceae45ba0 bgo-commands-codegen

Finished (untested) C++, html, typescript, tsc & browserify production.

author	bgo-osimis
date	Sat, 23 Feb 2019 15:04:29 +0100
parents	fc17251477d6
children	ce49eae4c887

comparison

equal deleted inserted replaced

-:6405435480ae
+:8b6ceae45ba0
 import yaml
 import re
 import os
 import sys
 from jinja2 import Template
-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
 self.tsEnums = StringIO()
 self.tsStructs = StringIO()
 self.tsDispatcher = StringIO()
 self.tsHandler = StringIO()
-def FlattenToFiles(self, outputDir: str):
+def FlattenToFiles(self, outputDir):
 raise NotImplementedError()
 class JsonHelpers:
 """A set of utilities to perform JSON operations"""
 fileContent = fp.read()
 fileContent = JsonHelpers.removeCommentsFromJsonContent(fileContent)
 return json.loads(fileContent)
-def LoadSchemaFromJson(filePath: str):
+def LoadSchemaFromJson(filePath):
 return JsonHelpers.loadJsonWithComments(filePath)
-def CanonToCpp(canonicalTypename: str) -> str:
+def CanonToCpp(canonicalTypename):
 # C++: prefix map vector and string with std::map, std::vector and
 # std::string
 # replace int32 by int32_t
 # replace float32 by float
 # replace float64 by double
-retVal: str = canonicalTypename
+retVal = canonicalTypename
 retVal = retVal.replace("map", "std::map")
 retVal = retVal.replace("vector", "std::vector")
 retVal = retVal.replace("string", "std::string")
 retVal = retVal.replace("int32", "int32_t")
 retVal = retVal.replace("float32", "float")
 retVal = retVal.replace("float64", "double")
 return retVal
-def CanonToTs(canonicalTypename: str) -> str:
+def CanonToTs(canonicalTypename):
 # TS: replace vector with Array and map with Map
 # string remains string
 # replace int32 by number
 # replace float32 by number
 # replace float64 by number
-retVal: str = canonicalTypename
+retVal = canonicalTypename
 retVal = retVal.replace("map", "Map")
 retVal = retVal.replace("vector", "Array")
 retVal = retVal.replace("int32", "number")
 retVal = retVal.replace("float32", "number")
 retVal = retVal.replace("float64", "number")
 retVal = retVal.replace("bool", "boolean")
 return retVal
-def NeedsTsConstruction(enums: Dict, tsType: str):
+def NeedsTsConstruction(enums, tsType):
 if tsType == 'boolean':
 return False
 elif tsType == 'number':
 return False
 elif tsType == 'string':
 templateFile = open(templateFileName, "r")
 templateFileContents = templateFile.read()
 return MakeTemplate(templateFileContents)
 templateFile.close()
-def EatToken(sentence: str) -> Tuple[str, str]:
+def EatToken(sentence):
 """splits "A,B,C" into "A" and "B,C" where A, B and C are type names
 (including templates) like "int32", "TotoTutu", or
 "map<map<int32,vector<string>>,map<string,int32>>" """
 if sentence.count("<") != sentence.count(">"):
 raise Exception(
-f"Error in the partial template type list {sentence}."
+"Error in the partial template type list " + str(sentence) + "."
 + " The number of < and > do not match!"
 )
 # the template level we're currently in
 templateLevel = 0
 elif sentence[i] == ">":
 templateLevel -= 1
 return (sentence, "")
-def SplitListOfTypes(typename: str) -> List[str]:
+def SplitListOfTypes(typename):
 """Splits something like
 vector<string>,int32,map<string,map<string,int32>>
 in:
 - vector<string>
 - int32
 map<string,map<string,int32>>
 This is not possible with a regex so
 """
-stillStuffToEat: bool = True
+stillStuffToEat = True
 tokenList = []
 restOfString = typename
 while stillStuffToEat:
 firstToken, restOfString = EatToken(restOfString)
 tokenList.append(firstToken)
 templateRegex = \
 re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>")
-def ParseTemplateType(typename) -> Tuple[bool, str, List[str]]:
+def ParseTemplateType(typename):
 """ If the type is a template like "SOMETHING<SOME<THING,EL<SE>>>",
 then it returns (true,"SOMETHING","SOME<THING,EL<SE>>")
 otherwise it returns (false,"","")"""
 # let's remove all whitespace from the type
 typename = "".join(typename.split())
 matches = templateRegex.match(typename)
 if matches == None:
 return (False, "", [])
 else:
-m = cast(Match[str], matches)
+m = matches
 assert len(m.groups()) == 2
 # we need to split with the commas that are outside of the
 # defined types. Simply splitting at commas won't work
 listOfDependentTypes = SplitListOfTypes(m.group(2))
 return (True, m.group(1), listOfDependentTypes)
 def ComputeOrderFromTypeTree(
-ancestors: List[str],
+ancestors,
-genOrder: List[str],
+genOrder,
-shortTypename: str, schema: Dict[str, Dict]) -> None:
+shortTypename, schema):
 if shortTypename in ancestors:
 raise Exception(
-f"Cyclic dependency chain found: the last of {ancestors} "
+"Cyclic dependency chain found: the last of " + str(ancestors) +
-+ f"depends on {shortTypename} that is already in the list."
++ " depends on " + str(shortTypename) + " that is already in the list."
 )
 if not (shortTypename in genOrder):
 (isTemplate, _, dependentTypenames) = ParseTemplateType(shortTypename)
 if isTemplate:
 else:
 # If it is not template, we are only interested if it is a
 # dependency that we must take into account in the dep graph,
 # i.e., a struct.
 if IsShortStructType(shortTypename, schema):
-struct:Dict = schema[GetLongTypename(shortTypename, schema)]
+struct = schema[GetLongTypename(shortTypename, schema)]
 # The keys in the struct dict are the member names
 # The values in the struct dict are the member types
 for field in struct.keys():
 # we fill the chain of dependent types (starting here)
 ancestors.append(shortTypename)
 # +-----------------------+
 # |   Utility functions   |
 # +-----------------------+
-def IsShortStructType(typename: str, schema: Dict[str, Dict]) -> bool:
+def IsShortStructType(typename, schema):
 fullStructName = "struct " + typename
 return (fullStructName in schema)
-def GetLongTypename(shortTypename: str, schema: Dict):
+def GetLongTypename(shortTypename, schema):
 if shortTypename.startswith("enum "):
 raise RuntimeError('shortTypename.startswith("enum "):')
-enumName: str = "enum " + shortTypename
+enumName = "enum " + shortTypename
 isEnum = enumName in schema
 if shortTypename.startswith("struct "):
 raise RuntimeError('shortTypename.startswith("struct "):')
-structName: str = "struct " + shortTypename
+structName = "struct " + shortTypename
 isStruct = ("struct " + shortTypename) in schema
 if isEnum and isStruct:
 raise RuntimeError('Enums and structs cannot have the same name')
 if isEnum:
 return enumName
 if isStruct:
 return structName
-def IsTypename(fullName: str) -> bool:
+def IsTypename(fullName):
 return (fullName.startswith("enum ") or fullName.startswith("struct "))
-def IsEnumType(fullName: str) -> bool:
+def IsEnumType(fullName):
 return fullName.startswith("enum ")
-def IsStructType(fullName: str) -> bool:
+def IsStructType(fullName):
 return fullName.startswith("struct ")
-def GetShortTypename(fullTypename: str) -> str:
+def GetShortTypename(fullTypename):
 if fullTypename.startswith("struct "):
 return fullTypename[7:]
 elif fullTypename.startswith("enum"):
 return fullTypename[5:]
 else:
 raise RuntimeError \
 ('fullTypename should start with either "struct " or "enum "')
-def CheckSchemaSchema(schema: Dict) -> None:
+def CheckSchemaSchema(schema):
 if not "rootName" in schema:
 raise Exception("schema lacks the 'rootName' key")
 for name in schema.keys():
 if (not IsEnumType(name)) and (not IsStructType(name)) and \
 (name != 'rootName'):
 raise RuntimeError \
-(f'Type "{name}" should start with "enum " or "struct "')
+('Type "' + str(name) + '" should start with "enum " or "struct "')
 # TODO: check enum fields are unique (in whole namespace)
 # TODO: check struct fields are unique (in each struct)
 # TODO: check that in the source schema, there are spaces after each colon
 # +-----------------------+
 # | Main processing logic |
 # +-----------------------+
-def ComputeRequiredDeclarationOrder(schema: dict) -> List[str]:
+def ComputeRequiredDeclarationOrder(schema):
 # sanity check
 CheckSchemaSchema(schema)
 # we traverse the type dependency graph and we fill a queue with
 # the required struct types, in a bottom-up fashion, to compute
 # The genOrder list contains the struct full names in the order
 # where they must be defined.
 # We do not care about the enums here... They do not depend upon
 # anything and we'll handle them, in their original declaration
 # order, at the start
-genOrder: List = []
+genOrder = []
 for fullName in schema.keys():
 if IsStructType(fullName):
-realName: str = GetShortTypename(fullName)
+realName = GetShortTypename(fullName)
-ancestors: List[str] = []
+ancestors = []
 ComputeOrderFromTypeTree(ancestors, genOrder, realName, schema)
 return genOrder
-def ProcessSchema(schema: dict, genOrder: List[str]) -> Dict:
+def ProcessSchema(schema, genOrder):
 # sanity check
 CheckSchemaSchema(schema)
 # let's doctor the schema to clean it up a bit
 # order DOES NOT matter for enums, even though it's a list
-enums: List[Dict] = []
+enums = []
 for fullName in schema.keys():
 if IsEnumType(fullName):
 # convert "enum Toto" to "Toto"
-typename:str = GetShortTypename(fullName)
+typename = GetShortTypename(fullName)
 enum = {}
 enum['name'] = typename
 assert(type(schema[fullName]) == list)
 enum['fields'] = schema[fullName] # must be a list
 enums.append(enum)
 #       "someOtherMember22":"vector<Message1>"
 #     }
 #   }
 # ]
-structs: List[Dict] = []
+structs = []
 for i in range(len(genOrder)):
 # this is already the short name
 typename = genOrder[i]
 fieldDict = schema["struct " + typename]
 struct = {}
 schema = yaml.load(schemaText)
 return schema
 def GetTemplatingDictFromSchemaFilename(fn):
 obj = LoadSchema(fn)
-genOrder: str = ComputeRequiredDeclarationOrder(obj)
+genOrder = ComputeRequiredDeclarationOrder(obj)
 templatingDict = ProcessSchema(obj, genOrder)
 return templatingDict
 # +-----------------------+
 # |      ENTRY POINT      |
 args = parser.parse_args()
 schemaFile = args.input_schema
 outDir = args.out_dir
-tdico: Dict = GetTemplatingDictFromSchemaFilename(schemaFile)
+tdico = GetTemplatingDictFromSchemaFilename(schemaFile)
 tsTemplateFile = \
 os.path.join(os.path.dirname(__file__), 'template.in.ts')
 template = MakeTemplateFromFile(tsTemplateFile)
-renderedTsCode: str = template.render(**tdico)
+renderedTsCode = template.render(**tdico)
 outputTsFile = os.path.join( \
-outDir,f"{tdico['rootName']}_generated.ts")
+outDir,str(tdico['rootName']) + "_generated.ts")
 with open(outputTsFile,"wt",encoding='utf8') as outFile:
 outFile.write(renderedTsCode)
 cppTemplateFile = \
 os.path.join(os.path.dirname(__file__), 'template.in.h')
 template = MakeTemplateFromFile(cppTemplateFile)
-renderedCppCode: str = template.render(**tdico)
+renderedCppCode = template.render(**tdico)
 outputCppFile = os.path.join( \
-outDir,f"{tdico['rootName']}_generated.hpp")
+outDir, str(tdico['rootName']) + "_generated.hpp")
 with open(outputCppFile,"wt",encoding='utf8') as outFile:
 outFile.write(renderedCppCode)
 # def GenEnumDecl(genc: GenCode, fullName: str, schema: Dict) -> None:
 #   """Writes the enumerations in genc"""
 #   enumDict:Dict=schema[fullName]
 #   # jinja2 template

Mercurial > hg > orthanc-stone

comparison Resources/CodeGeneration/stonegentool.py @ 496:8b6ceae45ba0 bgo-commands-codegen