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

comparison Resources/CodeGeneration/stonegentool.py @ 472:3db3289e1c25 bgo-commands-codegen

Ongoing codegen work

author	bgo-osimis
date	Wed, 13 Feb 2019 06:46:36 +0100
parents	125c19b294e3
children	628941d63b8c

comparison

equal deleted inserted replaced

-:125c19b294e3
+:3db3289e1c25
-from typing import List,Dict
+from typing import List,Dict,Set
 import sys
 import json
 import re
+"""
+1         2         3         4         5         6         7
+12345678901234567890123456789012345678901234567890123456789012345678901234567890
+"""
 def LoadSchema(file_path : str):
 with open(file_path, 'r') as fp:
 obj = json.load(fp)
 return obj
-class Type:
+# class Type:
-def __init__(self, canonicalTypeName:str, kind:str):
+#   def __init__(self, canonicalTypeName:str, kind:str):
-allowedTypeKinds = ["primitive","enum","struct","collection"]
+#     allowedTypeKinds = ["primitive","enum","struct","collection"]
-"""dependent type is the list of canonical types this type depends on.
+#     """dependent type is the list of canonical types this type depends on.
-For instance, vector<map<string,int32>> depends on map<string,int32>
+#        For instance, vector<map<string,int32>> depends on map<string,int32>
-that, in turn, depends on string and int32 that, in turn, depend on
+#        that, in turn, depends on string and int32 that, in turn, depend on
-nothing"""
+#        nothing"""
-self.canonicalTypeName = canonicalTypeName
+#     self.canonicalTypeName = canonicalTypeName
-assert(kind in allowedTypeKinds)
+#     assert(kind in allowedTypeKinds)
-def setDependentTypes(self, dependentTypes:List[Type]) -> None:
+#   def setDependentTypes(self, dependentTypes:List[Type]) -> None:
-self.dependentTypes = dependentTypes
+#     self.dependentTypes = dependentTypes
-def getDependentTypes(self) -> List[Type]:
+#   def getDependentTypes(self) -> List[Type]:
-return self.dependentTypes
+#     return self.dependentTypes
-def getCppTypeName(self) -> str:
+def GetCppTypeNameFromCanonical(canonicalTypeName : str) -> str:
-# C++: prefix map vector and string with std::map, std::vector and std::string
+# 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 = self.canonicalTypeName.replace("map","std::map")
+retVal : str = canonicalTypeName.replace("map","std::map")
-retVal : str = self.canonicalTypeName.replace("vector","std::vector")
+retVal : str = canonicalTypeName.replace("vector","std::vector")
-retVal : str = self.canonicalTypeName.replace("int32","int32_t")
+retVal : str = canonicalTypeName.replace("int32","int32_t")
-retVal : str = self.canonicalTypeName.replace("float32","float")
+retVal : str = canonicalTypeName.replace("float32","float")
-retVal : str = self.canonicalTypeName.replace("float64","double")
+retVal : str = canonicalTypeName.replace("float64","double")
 return retVal
-def getTypeScriptTypeName(self) -> str:
+def GetTypeScriptTypeNameFromCanonical(canonicalTypeName : str) -> str:
 # 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 = self.canonicalTypeName.replace("map","Map")
+retVal : str = canonicalTypeName.replace("map","Map")
-retVal : str = self.canonicalTypeName.replace("vector","Array")
+retVal : str = canonicalTypeName.replace("vector","Array")
-retVal : str = self.canonicalTypeName.replace("int32","number")
+retVal : str = canonicalTypeName.replace("int32","number")
-retVal : str = self.canonicalTypeName.replace("float32","number")
+retVal : str = canonicalTypeName.replace("float32","number")
-retVal : str = self.canonicalTypeName.replace("float64","number")
+retVal : str = canonicalTypeName.replace("float64","number")
-retVal : str = self.canonicalTypeName.replace("bool","boolean")
+retVal : str = canonicalTypeName.replace("bool","boolean")
 return retVal
-class Schema:
+# class Schema:
-def __init__(self, root_prefix : str, defined_types : List[Type]):
+#   def __init__(self, root_prefix : str, defined_types : List[Type]):
-self.rootName : str = root_prefix
+#     self.rootName : str = root_prefix
-self.definedTypes : str = defined_types
+#     self.definedTypes : str = defined_types
 def CheckTypeSchema(definedType : Dict) -> None:
 allowedDefinedTypeKinds = ["enum","struct"]
 if not definedType.has_key('name'):
 raise Exception("type lacks the 'name' key")
 name = definedType['name']
 if not definedType.has_key('kind'):
 raise Exception(f"type {name} lacks the 'kind' key")
 kind = definedType['kind']
 if not (kind in allowedDefinedTypeKinds):
-raise Exception(f"type {name} : kind {kind} is not allowed. It must be one of {allowedDefinedTypeKinds}")
+raise Exception(f"type {name} : kind {kind} is not allowed. " +
+f"It must be one of {allowedDefinedTypeKinds}")
 if not definedType.has_key('fields'):
 raise Exception("type {name} lacks the 'fields' key")
 # generic check on all kinds of types
 # fields in struct must have types
 if kind == 'struct':
 for field in fields:
 fieldName = field['name']
 if not field.has_key('type'):
-raise Exception(f"field {fieldName} in type {name} lacks the 'type' key")
+raise Exception(f"field {fieldName} in type {name} "
++ "lacks the 'type' key")
 def CheckSchemaSchema(schema : Dict) -> None:
 if not schema.has_key('root_name'):
 raise Exception("schema lacks the 'root_name' key")
 if not schema.has_key('types'):
 raise Exception("schema lacks the 'types' key")
 for definedType in schema['types']:
 CheckTypeSchema(definedType)
-def CreateAndCacheTypeObject(allTypes : Dict[str,Type], typeDict : Dict) -> None:
+# def CreateAndCacheTypeObject(allTypes : Dict[str,Type], typeDict : Dict)  -> None:
-"""This does not set the dependentTypes field"""
+#   """This does not set the dependentTypes field"""
-typeName : str = typeDict['name']
+#   typeName : str = typeDict['name']
-if allTypes.has_key(typeName):
+#   if allTypes.has_key(typeName):
-raise Exception(f'Type {typeName} is defined more than once!')
+#     raise Exception(f'Type {typeName} is defined more than once!')
-else:
+#   else:
-typeObject = Type(typeName, typeDict['kind'])
+#     typeObject = Type(typeName, typeDict['kind'])
-allTypes[typeName] = typeObject
+#     allTypes[typeName] = typeObject
 def EatToken(sentence : str) -> (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
 "map<map<int32,vector<string>>,map<string,int32>>" """
-token = []
 if sentence.count('<') != sentence.count('>'):
-raise Exception(f"Error in the partial template type list {sentence}. The number of < and > do not match!")
+raise Exception(f"Error in the partial template type list {sentence}."
++ " The number of < and > do not match!")
 # the template level we're currently in
 templateLevel = 0
 for i in len(sentence):
 if (sentence[i] == ",") and (templateLevel == 0):
 while stillStuffToEat:
 firstToken,restOfString = EatToken(restOfString)
 tokenList.append(firstToken)
 return tokenList
-templateRegex = re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>")
+templateRegex = \
+re.compile(r"([a-zA-Z0-9_]*[a-zA-Z0-9_]*)<([a-zA-Z0-9_,:<>]+)>")
 def ParseTemplateType(typeName) -> (bool,str,List[str]):
 """ 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,"","")"""
 # we need to split with the commas that are outside of the defined types
 # simply splitting at commas won't work
 listOfDependentTypes = SplitListOfTypes(matches.group(2))
 return (True,matches.group(1),listOfDependentTypes)
-def GetPrimitiveType(typeName : str) -> Type:
-if allTypes.has_key(typeName):
+# def GetPrimitiveType(typeName : str) -> Type:
-return allTypes[typeName]
+#   if allTypes.has_key(typeName):
-else:
+#     return allTypes[typeName]
-primitiveTypes = ['int32', 'float32', 'float64', 'string']
+#   else:
-if not (typeName in primitiveTypes):
+#     primitiveTypes = ['int32', 'float32', 'float64', 'string']
-raise Exception(f"Type {typeName} is unknown.")
+#     if not (typeName in primitiveTypes):
-typeObject = Type(typeName,'primitive')
+#       raise Exception(f"Type {typeName} is unknown.")
-# there are no dependent types in a primitive type --> Type object
+#     typeObject = Type(typeName,'primitive')
-# constrution is finished at this point
+#     # there are no dependent types in a primitive type --> Type object
-allTypes[typeName] = typeObject
+#     # constrution is finished at this point
-return typeObject
+#     allTypes[typeName] = typeObject
+#     return typeObject
 def ProcessTypeTree(
 ancestors : List[str]
-, generationQueue : 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} depends on {typeName} that is already in the list.")
+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 generationQueue):
+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
+# it is another (non directly user-defined) type that we must parse and
-# let's do it
+# create. Let's do it!
-dependentTypes = []
+(isTemplate,_,parameters) = ParseTemplateType(typeName)
-(isTemplate,templateType,parameters) = ParseTemplateType(typeName)
 if isTemplate:
 dependentTypeNames : List[str] = SplitListOfTypes(parameters)
 for dependentTypeName in dependentTypeNames:
 # childAncestors = ancestors.copy()  NO TEMPLATE ANCESTOR!!!
 # childAncestors.append(typeName)
-ProcessTypeTree(ancestors, processedTypes, structTypes, dependentTypeName)
+ProcessTypeTree(ancestors, genOrderQueue,
+structTypes, dependentTypeName)
 else:
 if structTypes.has_key(typeName):
-ProcesStructType_DepthFirstRecursive(generationQueue, structTypes,
+ProcessStructType_DepthFirstRecursive(genOrderQueue, structTypes,
 structTypes[typeName])
-def ProcesStructType_DepthFirstRecursive(
+def ProcessStructType_DepthFirstRecursive(
-generationQueue : List[str], structTypes : Dict[str,Dict]
+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:
 ancestors = [typeName]
-ProcessTypeTree(ancestors, generationQueue
+ProcessTypeTree(ancestors, genOrderQueue
 , structTypes, typeField['name'])
 # now we're pretty sure our dependencies have been processed,
 # we can start marking our code for generation
-generationQueue.append(typeName)
+genOrderQueue.append(typeName)
+def ProcessEnumerationType(processedTypes, definedType) -> None:
+print(f"About to process enumeration: {definedType['name']}")
 def ProcessSchema(schema : dict) -> None:
 CheckSchemaSchema(schema)
 rootName : str = schema['root_name']
 definedTypes : list = schema['types']
-# mark already processed types
+print(f"Processing schema. rootName = f{rootName}")
-processedTypes : set[str] = set()
+# this will be filled with the generation queue. That is, the type
+# names in the order where they must be defined.
+genOrderQueue : Set = set()
 # the struct names are mapped to their JSON dictionary
 structTypes : Dict[str,Dict] = {}
 # the order here is the generation order
 for definedType in definedTypes:
 if definedType['kind'] == 'enum':
-ProcessEnumerationType(processedTypes, definedType);
+ProcessEnumerationType(genOrderQueue, 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':
 structTypes[definedType['name']] = definedType
-ProcesStructType_DepthFirstRecursive(processedTypes,structTypes,definedType)
+ProcessStructType_DepthFirstRecursive(genOrderQueue,structTypes,
+definedType)
+print(f"genOrderQueue = {genOrderQueue}")
 if __name__ == '__main__':
 import argparse
-parser = argparse.ArgumentParser(usage = """stonegentool.py [-h] [-o OUT_DIR] [-v] input_schemas
+parser = argparse.ArgumentParser(
-EXAMPLE: python command_gen.py -o "generated_files/" "mainSchema.json,App Specific Commands.json" """)
+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

Mercurial > hg > orthanc-stone

comparison Resources/CodeGeneration/stonegentool.py @ 472:3db3289e1c25 bgo-commands-codegen