struct-frame 0.0.27__py3-none-any.whl → 0.0.30__py3-none-any.whl

struct_frame/c_gen.py

@@ -17,6 +17,7 @@ c_types = {"uint8": "uint8_t",
            "double": "double",
            "uint64": 'uint64_t',
            "int64":  'int64_t',
+           "string": "char",  # Add string type support
            }
 
 
@@ -60,6 +61,16 @@ class EnumCGen():
         result += ' %s;\n' % (enumName)
 
         result += 'typedef uint8_t %s_t;' % (enumName)
+
+        # Add module-prefixed enum constants for compatibility
+        result += '\n\n/* Enum constants with module prefix */\n'
+        module_prefix = CamelToSnakeCase(field.package).upper()
+        for d in field.data:
+            # Use the already correct enum constant name
+            enum_constant = f"{CamelToSnakeCase(field.name).upper()}_{StyleC.enum_entry(d)}"
+            module_constant = f"{module_prefix}_{enum_constant}"
+            result += f'#define {module_constant:<35} {enum_constant}\n'
+
         return result
 
 
@@ -67,18 +78,70 @@ class FieldCGen():
     @staticmethod
     def generate(field):
         result = ''
-
         var_name = field.name
         type_name = field.fieldType
+
+        # Handle basic type resolution
         if type_name in c_types:
-            type_name = c_types[type_name]
+            base_type = c_types[type_name]
         else:
-            type_name = '%s%s' % (pascalCase(field.package), type_name)
             if field.isEnum:
-                type_name = '%s_t' % type_name
-
-        result += '    %s %s%s;' % (type_name, var_name, "")
+                base_type = '%s%s_t' % (pascalCase(field.package), type_name)
+            else:
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                # String arrays need both array size and individual string size
+                if field.size_option is not None:
+                    # Fixed string array: size_option strings, each element_size chars
+                    declaration = f"char {var_name}[{field.size_option}][{field.element_size}];"
+                    comment = f"  // Fixed string array: {field.size_option} strings, each max {field.element_size} chars"
+                elif field.max_size is not None:
+                    # Variable string array: count byte + max_size strings of element_size chars each
+                    declaration = f"struct {{ uint8_t count; char data[{field.max_size}][{field.element_size}]; }} {var_name};"
+                    comment = f"  // Variable string array: up to {field.max_size} strings, each max {field.element_size} chars"
+                else:
+                    declaration = f"char {var_name}[1][1];"  # Fallback
+                    comment = "  // String array (error in size specification)"
+            else:
+                # Non-string arrays
+                if field.size_option is not None:
+                    # Fixed array: always exact size
+                    declaration = f"{base_type} {var_name}[{field.size_option}];"
+                    comment = f"  // Fixed array: always {field.size_option} elements"
+                elif field.max_size is not None:
+                    # Variable array: count byte + max elements
+                    declaration = f"struct {{ uint8_t count; {base_type} data[{field.max_size}]; }} {var_name};"
+                    comment = f"  // Variable array: up to {field.max_size} elements"
+                else:
+                    declaration = f"{base_type} {var_name}[1];"  # Fallback
+                    comment = "  // Array (error in size specification)"
+
+            result += f"    {declaration}{comment}"
+
+        # Handle regular strings
+        elif field.fieldType == "string":
+            if field.size_option is not None:
+                # Fixed string: exactly size_option characters
+                declaration = f"char {var_name}[{field.size_option}];"
+                comment = f"  // Fixed string: exactly {field.size_option} chars"
+            elif field.max_size is not None:
+                # Variable string: length byte + max characters
+                declaration = f"struct {{ uint8_t length; char data[{field.max_size}]; }} {var_name};"
+                comment = f"  // Variable string: up to {field.max_size} chars"
+            else:
+                declaration = f"char {var_name}[1];"  # Fallback
+                comment = "  // String (error in size specification)"
+
+            result += f"    {declaration}{comment}"
+
+        # Handle regular fields
+        else:
+            result += f"    {base_type} {var_name};"
 
+        # Add leading comments
         leading_comment = field.comments
         if leading_comment:
             for c in leading_comment:

struct_frame/generate.py

@@ -10,6 +10,7 @@ from struct_frame import FilePyGen
 from struct_frame import FileGqlGen
 from proto_schema_parser.parser import Parser
 from proto_schema_parser import ast
+from proto_schema_parser.ast import FieldCardinality
 
 import argparse
 
@@ -27,7 +28,8 @@ default_types = {
     "float": {"size": 4},
     "double": {"size": 8},
     "int64": {"size": 8},
-    "uint64": {"size": 8}
+    "uint64": {"size": 8},
+    "string": {"size": 4}  # Variable length, estimated size for length prefix
 }
 
 
@@ -80,14 +82,78 @@ class Field:
         self.comments = comments
         self.package = package
         self.isEnum = False
+        self.flatten = False
+        self.is_array = False
+        self.size_option = None   # Fixed size using [size=X]
+        self.max_size = None      # Variable size using [max_size=X]
+        # Element size for repeated string arrays [element_size=X]
+        self.element_size = None
 
     def parse(self, field):
         self.name = field.name
         self.fieldType = field.type
+
+        # Check if this is a repeated field (array)
+        if hasattr(field, 'cardinality') and field.cardinality == FieldCardinality.REPEATED:
+            self.is_array = True
+
         if self.fieldType in default_types:
             self.isDefaultType = True
             self.size = default_types[self.fieldType]["size"]
             self.validated = True
+
+        try:
+            if hasattr(field, 'options') and field.options:
+                # options is typically a list of ast.Option
+                for opt in field.options:
+                    oname = getattr(opt, 'name', None)
+                    ovalue = getattr(opt, 'value', None)
+                    if not oname:
+                        continue
+                    lname = str(oname).strip()
+                    # Support unqualified and a couple of qualified names
+                    if lname in ('flatten', '(sf.flatten)', '(struct_frame.flatten)'):
+                        sval = str(ovalue).strip().lower()
+                        if sval in ('true', '1', 'yes', 'on') or ovalue is True:
+                            self.flatten = True
+                    elif lname in ('size', '(sf.size)', '(struct_frame.size)'):
+                        # Fixed size for arrays or strings
+                        try:
+                            self.size_option = int(ovalue)
+                            if self.size_option <= 0 or self.size_option > 255:
+                                print(
+                                    f"Invalid size {self.size_option} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+                    elif lname in ('max_size', '(sf.max_size)', '(struct_frame.max_size)'):
+                        # Variable size for arrays or strings
+                        try:
+                            self.max_size = int(ovalue)
+                            if self.max_size <= 0 or self.max_size > 255:
+                                print(
+                                    f"Invalid max_size {self.max_size} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid max_size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+                    elif lname in ('element_size', '(sf.element_size)', '(struct_frame.element_size)'):
+                        # Individual element size for repeated string arrays
+                        try:
+                            self.element_size = int(ovalue)
+                            if self.element_size <= 0 or self.element_size > 255:
+                                print(
+                                    f"Invalid element_size {self.element_size} for field {self.name}, must be 1-255")
+                                return False
+                        except (ValueError, TypeError):
+                            print(
+                                f"Invalid element_size value {ovalue} for field {self.name}, must be an integer")
+                            return False
+        except Exception:
+            pass
         return True
 
     def validate(self, currentPackage, packages):
@@ -100,8 +166,8 @@ class Field:
             if ret:
                 if ret.validate(currentPackage, packages):
                     self.isEnum = ret.isEnum
-                    self.validate = True
-                    self.size = ret.size
+                    self.validated = True
+                    base_size = ret.size
                 else:
                     print(
                         f"Failed to validate Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
@@ -110,6 +176,77 @@ class Field:
                 print(
                     f"Failed to find Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
                 return False
+        else:
+            base_size = self.size
+
+        # Calculate size for arrays and strings
+        if self.is_array:
+            if self.fieldType == "string":
+                # String arrays need both array size AND individual element size
+                if self.element_size is None:
+                    print(
+                        f"String array field {self.name} missing required element_size option")
+                    return False
+
+                if self.size_option is not None:
+                    # Fixed string array: size_option strings, each element_size bytes
+                    self.size = self.size_option * self.element_size
+                elif self.max_size is not None:
+                    # Variable string array: 1 byte count + max_size strings of element_size bytes each
+                    self.size = 1 + (self.max_size * self.element_size)
+                else:
+                    print(
+                        f"String array field {self.name} missing required size or max_size option")
+                    return False
+            else:
+                # Non-string arrays
+                if self.size_option is not None:
+                    # Fixed array: always full, no count byte needed
+                    self.size = base_size * self.size_option
+                elif self.max_size is not None:
+                    # Variable array: 1 byte for count + max space
+                    self.size = 1 + (base_size * self.max_size)
+                else:
+                    print(
+                        f"Array field {self.name} missing required size or max_size option")
+                    return False
+        elif self.fieldType == "string":
+            if self.size_option is not None:
+                # Fixed string: exactly size_option characters
+                self.size = self.size_option
+            elif self.max_size is not None:
+                # Variable string: 1 byte length + max characters
+                self.size = 1 + self.max_size
+            else:
+                print(
+                    f"String field {self.name} missing required size or max_size option")
+                return False
+        else:
+            self.size = base_size
+
+        # Debug output
+        array_info = ""
+        if self.is_array:
+            if self.fieldType == "string":
+                # String arrays show both array size and individual element size
+                if self.size_option is not None:
+                    array_info = f", fixed_string_array size={self.size_option}, element_size={self.element_size}"
+                elif self.max_size is not None:
+                    array_info = f", bounded_string_array max_size={self.max_size}, element_size={self.element_size}"
+            else:
+                # Regular arrays
+                if self.size_option is not None:
+                    array_info = f", fixed_array size={self.size_option}"
+                elif self.max_size is not None:
+                    array_info = f", bounded_array max_size={self.max_size}"
+        elif self.fieldType == "string":
+            # Regular strings
+            if self.size_option is not None:
+                array_info = f", fixed_string size={self.size_option}"
+            elif self.max_size is not None:
+                array_info = f", variable_string max_size={self.max_size}"
+        print(
+            f"  Field {self.name}: type={self.fieldType}, is_array={self.is_array}{array_info}, calculated_size={self.size}")
 
         return True
 
@@ -117,8 +254,21 @@ class Field:
         output = ""
         for c in self.comments:
             output = output + c + "\n"
+        array_info = ""
+        if self.is_array:
+            if self.size_option is not None:
+                array_info = f", Array[size={self.size_option}]"
+            elif self.max_size is not None:
+                array_info = f", Array[max_size={self.max_size}]"
+            else:
+                array_info = ", Array[no size specified]"
+        elif self.fieldType == "string":
+            if self.size_option is not None:
+                array_info = f", String[size={self.size_option}]"
+            elif self.max_size is not None:
+                array_info = f", String[max_size={self.max_size}]"
         output = output + \
-            f"Field: {self.name}, Type:{self.fieldType}, Size:{self.size}"
+            f"Field: {self.name}, Type:{self.fieldType}, Size:{self.size}{array_info}"
         return output
 
 
@@ -167,6 +317,44 @@ class Message:
                 return False
             self.size = self.size + value.size
 
+        # Flatten collision detection: if a field is marked as flatten and is a message,
+        # ensure none of the child field names collide with fields in this message.
+        parent_field_names = set(self.fields.keys())
+        for key, value in self.fields.items():
+            if getattr(value, 'flatten', False):
+                # Only meaningful for non-default, non-enum message types
+                if value.isDefaultType or value.isEnum:
+                    # Flatten has no effect on primitives/enums; skip
+                    continue
+                child = currentPackage.findFieldType(value.fieldType)
+                if not child or getattr(child, 'isEnum', False) or not hasattr(child, 'fields'):
+                    # Unknown or non-message type; skip
+                    continue
+                for ck in child.fields.keys():
+                    if ck in parent_field_names:
+                        print(
+                            f"Flatten collision in Message {self.name}: field '{key}.{ck}' collides with existing field '{ck}'.")
+                        return False
+
+        # Array validation
+        for key, value in self.fields.items():
+            if value.is_array:
+                # All arrays must have size or max_size specified
+                if value.size_option is None and value.max_size is None:
+                    print(
+                        f"Array field {key} in Message {self.name}: must specify size or max_size option")
+                    return False
+            elif value.fieldType == "string":
+                # Strings must have size or max_size specified
+                if value.size_option is None and value.max_size is None:
+                    print(
+                        f"String field {key} in Message {self.name}: must specify size or max_size option")
+                    return False
+            elif value.max_size is not None or value.size_option is not None or value.element_size is not None:
+                print(
+                    f"Field {key} in Message {self.name}: size/max_size/element_size options can only be used with repeated fields or strings")
+                return False
+
         self.validated = True
         return True
 
@@ -358,11 +546,17 @@ def main():
         print("Select at least one build argument")
         return
 
+    valid = False
     try:
-        validatePackages()
+        valid = validatePackages()
     except RecursionError as err:
         print(
             f'Recursion Error. Messages most likely have a cyclical dependancy. Check Message: {recErrCurrentMessage} and Field: {recErrCurrentField}')
+        return
+
+    if not valid:
+        print("Validation failed; aborting code generation.")
+        return
 
     files = {}
     if (args.build_c):

struct_frame/gql_gen.py

@@ -17,6 +17,7 @@ gql_types = {
     "bool": "Boolean",
     "float": "Float",
     "double": "Float",
+    "string": "String",
 }
 
 
@@ -79,24 +80,81 @@ class FieldGqlGen:
     @staticmethod
     def type_name(field):
         t = field.fieldType
-        if t in gql_types:
-            return gql_types[t]
-        return f"{pascalCase(field.package)}{t}"
+        base_type = gql_types.get(t, f"{pascalCase(field.package)}{t}")
+
+        # Handle arrays
+        if getattr(field, 'is_array', False):
+            # Arrays in GraphQL are represented as [Type!]! for non-null arrays of non-null elements
+            # or [Type] for nullable arrays, etc. We'll use [Type!]! as the standard
+            return f"[{base_type}!]!"
+
+        return base_type
 
     @staticmethod
-    def generate(field):
+    def generate(field, name_override=None):
         lines = []
-        if field.comments:
-            desc = _single_quote_line(field.comments)
+
+        # Generate clean comments with size information, preferring our generated descriptions over proto comments
+        if getattr(field, 'is_array', False):
+            # Array field - use our size descriptions
+            if getattr(field, 'size_option', None) is not None:
+                # Fixed array
+                if field.fieldType == "string":
+                    comment_lines = [
+                        f"Fixed string array: {field.size_option} strings, each {getattr(field, 'element_size', 'N/A')} chars"]
+                else:
+                    comment_lines = [
+                        f"Fixed array: always {field.size_option} elements"]
+            else:
+                # Variable array
+                if field.fieldType == "string":
+                    comment_lines = [
+                        f"Variable string array: up to {getattr(field, 'max_size', 'N/A')} strings, each max {getattr(field, 'element_size', 'N/A')} chars"]
+                else:
+                    comment_lines = [
+                        f"Variable array: up to {getattr(field, 'max_size', 'N/A')} elements"]
+        elif field.fieldType == "string":
+            # Non-array string field
+            if getattr(field, 'size_option', None) is not None:
+                comment_lines = [
+                    f"Fixed string: exactly {field.size_option} characters"]
+            elif getattr(field, 'max_size', None) is not None:
+                comment_lines = [
+                    f"Variable string: up to {field.max_size} characters"]
+            else:
+                comment_lines = field.comments[:] if field.comments else []
+        else:
+            # Regular field - use original comments
+            comment_lines = field.comments[:] if field.comments else []
+
+        if comment_lines:
+            desc = _single_quote_line(comment_lines)
             if desc:
                 lines.append(f"  {desc}")
-        lines.append(f"  {field.name}: {FieldGqlGen.type_name(field)}")
+
+        fname = name_override if name_override else field.name
+        lines.append(f"  {fname}: {FieldGqlGen.type_name(field)}")
         return '\n'.join(lines)
 
+    @staticmethod
+    def generate_flattened_children(field, package, parent_msg):
+        # Expand a message-typed field into its child fields.
+        # If a child field name collides, raise an error and fail generation.
+        t = field.fieldType
+        child_msg = package.messages.get(t)
+        if not child_msg:
+            # Fallback to normal generation if unknown
+            return [FieldGqlGen.generate(field)]
+
+        out_lines = []
+        for ck, cf in child_msg.fields.items():
+            out_lines.append(FieldGqlGen.generate(cf, name_override=ck))
+        return out_lines
+
 
 class MessageGqlGen:
     @staticmethod
-    def generate(msg):
+    def generate(package, msg):
         lines = []
         if msg.comments:
             desc = _triple_quote_block(msg.comments)
@@ -108,7 +166,11 @@ class MessageGqlGen:
             lines.append("  _empty: Boolean")
         else:
             for key, f in msg.fields.items():
-                lines.append(FieldGqlGen.generate(f))
+                if getattr(f, 'flatten', False) and f.fieldType not in gql_types:
+                    lines.extend(
+                        FieldGqlGen.generate_flattened_children(f, package, msg))
+                else:
+                    lines.append(FieldGqlGen.generate(f))
         lines.append("}\n")
         return '\n'.join(lines)
 
@@ -132,7 +194,7 @@ class FileGqlGen:
             if not first_block:
                 yield '\n'
             first_block = False
-            yield MessageGqlGen.generate(msg).rstrip() + '\n'
+            yield MessageGqlGen.generate(package, msg).rstrip() + '\n'
 
         # Root Query type
         if package.messages:

struct_frame/py_gen.py

@@ -17,6 +17,7 @@ py_types = {"uint8": "uint8",
             "double": "float64",
             "uint64": 'uint64',
             "int64":  'int64',
+            "string": "str",  # Add string type support
             }
 
 
@@ -58,14 +59,51 @@ class FieldPyGen():
 
         var_name = field.name
         type_name = field.fieldType
+
+        # Handle basic type resolution
         if type_name in py_types:
-            type_name = py_types[type_name]
+            base_type = py_types[type_name]
         else:
-            type_name = '%s%s' % (pascalCase(field.package), type_name)
             if field.isEnum:
-                type_name = 'uint8 #%s' % type_name
+                # For enums, use the full enum class name for better type safety
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+            else:
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                # String arrays require both array size and individual element size
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed string array size={field.size_option}, each max {field.element_size} chars"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded string array max_size={field.max_size}, each max {field.element_size} chars"
+                else:
+                    type_annotation = f"list[{base_type}]  # String array"
+            else:
+                # Non-string arrays
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed array size={field.size_option}"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded array max_size={field.max_size}"
+                else:
+                    type_annotation = f"list[{base_type}]  # Array"
+        # Handle strings with size info
+        elif field.fieldType == "string":
+            if field.size_option is not None:
+                # Fixed string - exact length
+                type_annotation = f"str  # Fixed string size={field.size_option}"
+            elif field.max_size is not None:
+                # Variable string - up to max length
+                type_annotation = f"str  # Variable string max_size={field.max_size}"
+            else:
+                # Fallback (shouldn't happen with validation)
+                type_annotation = "str  # String"
+        else:
+            # Regular field
+            type_annotation = base_type
 
-        result += '    %s: %s' % (var_name, type_name)
+        result += '    %s: %s' % (var_name, type_annotation)
 
         leading_comment = field.comments
         if leading_comment:
@@ -86,7 +124,7 @@ class MessagePyGen():
                 result = '#%s\n' % c
 
         structName = '%s%s' % (pascalCase(msg.package), msg.name)
-        result += 'class %s(Structured):\n' % structName
+        result += 'class %s(Structured, byte_order=ByteOrder.LE, byte_order_mode=ByteOrderMode.OVERRIDE):\n' % structName
         result += '    msg_size = %s\n' % msg.size
         if msg.id != None:
             result += '    msg_id = %s\n' % msg.id
@@ -103,15 +141,31 @@ class MessagePyGen():
         result += f'        return out'
 
         result += '\n\n    def to_dict(self, include_name = True, include_id = True):\n'
-        result += f'        out = {{'
+        result += '        out = {}\n'
+        # Handle all field types including arrays
         for key, f in msg.fields.items():
-            result += f' "{key}" : self.{key}{"" if f.isDefaultType | f.isEnum else ".to_dict(False, False)"  }, '
-        result += f'}}\n'
-        result += f'        if include_name:\n'
+            if f.is_array:
+                if f.isDefaultType or f.isEnum or f.fieldType == "string":
+                    # Array of primitives, enums, or strings
+                    result += f'        out["{key}"] = self.{key}\n'
+                else:
+                    # Array of nested messages - convert each element
+                    result += f'        out["{key}"] = [item.to_dict(False, False) for item in self.{key}]\n'
+            elif f.isDefaultType or f.isEnum or f.fieldType == "string":
+                # Regular primitive, enum, or string field
+                result += f'        out["{key}"] = self.{key}\n'
+            else:
+                # Nested message field
+                if getattr(f, 'flatten', False):
+                    # Merge nested dict into parent
+                    result += f'        out.update(self.{key}.to_dict(False, False))\n'
+                else:
+                    result += f'        out["{key}"] = self.{key}.to_dict(False, False)\n'
+        result += '        if include_name:\n'
         result += f'            out["name"] = "{msg.name}"\n'
-        result += f'        if include_id:\n'
+        result += '        if include_id:\n'
         result += f'            out["msg_id"] = "{msg.id}"\n'
-        result += f'        return out\n'
+        result += '        return out\n'
 
         return result
 

struct_frame/ts_gen.py

@@ -18,6 +18,23 @@ ts_types = {
     "uint32": 'UInt32LE',
     "uint64": 'BigInt64LE',
     "int64":  'BigUInt64LE',
+    "string":   'String',
+}
+
+# TypeScript type mappings for array declarations
+ts_array_types = {
+    "int8":     'number',
+    "uint8":    'number',
+    "int16":    'number',
+    "uint16":   'number',
+    "bool":     'boolean',
+    "double":   'number',
+    "float":    'number',
+    "int32":    'number',
+    "uint32":   'number',
+    "uint64":   'bigint',
+    "int64":    'bigint',
+    "string":   'string',
 }
 
 
@@ -65,18 +82,66 @@ class FieldTsGen():
     def generate(field, packageName):
         result = ''
         isEnum = False
-#        isEnum = field.pbtype in ('ENUM', 'UENUM')
         var_name = StyleC.var_name(field.name)
         type_name = field.fieldType
-        if type_name in ts_types:
-            type_name = ts_types[type_name]
-        else:
-            type_name = '%s_%s' % (packageName, StyleC.struct_name(type_name))
 
-        if isEnum:
-            result += '    .UInt8(\'%s\', typed<%s>())' % (var_name, type_name)
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed string array: string[size] -> Array<string> with fixed length
+                    result += f'    // Fixed string array: {field.size_option} strings, each exactly {field.element_size} chars\n'
+                    result += f'    .Array(\'{var_name}\', \'String\', {field.size_option})'
+                else:  # Variable size array [max_size=X]
+                    # Variable string array: string[max_size=X, element_size=Y] -> Array<string> with count
+                    result += f'    // Variable string array: up to {field.max_size} strings, each max {field.element_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'String\', {field.max_size})'
+            else:
+                # Regular type arrays
+                if type_name in ts_types:
+                    base_type = ts_types[type_name]
+                else:
+                    base_type = f'{packageName.lower()}_{StyleC.struct_name(type_name).lower()}'
+
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed array: type[size] -> Array<type> with fixed length
+                    # For fixed arrays, size_option contains the exact size
+                    array_size = field.size_option
+                    result += f'    // Fixed array: always {array_size} elements\n'
+                    result += f'    .Array(\'{var_name}\', \'{base_type}\', {array_size})'
+                else:  # Variable size array [max_size=X]
+                    # Variable array: type[max_size=X] -> count + Array<type>
+                    max_count = field.max_size  # For variable arrays, max_size is the maximum count
+                    result += f'    // Variable array: up to {max_count} elements\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'{base_type}\', {max_count})'
         else:
-            result += '    .%s(\'%s\')' % (type_name, var_name)
+            # Non-array fields (existing logic)
+            if field.fieldType == "string":
+                if hasattr(field, 'size_option') and field.size_option is not None:
+                    # Fixed string: string[size] -> fixed length string
+                    result += f'    // Fixed string: exactly {field.size_option} chars\n'
+                    result += f'    .String(\'{var_name}\', {field.size_option})'
+                elif hasattr(field, 'max_size') and field.max_size is not None:
+                    # Variable string: string[max_size=X] -> length + data
+                    result += f'    // Variable string: up to {field.max_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_length\')\n'
+                    result += f'    .String(\'{var_name}_data\', {field.max_size})'
+                else:
+                    # Default string handling (should not occur with new parser)
+                    result += f'    .String(\'{var_name}\')'
+            else:
+                # Regular types
+                if type_name in ts_types:
+                    type_name = ts_types[type_name]
+                else:
+                    type_name = f'{packageName}_{StyleC.struct_name(type_name)}'
+
+                if isEnum:
+                    result += f'    .UInt8(\'{var_name}\', typed<{type_name}>())'
+                else:
+                    result += f'    .{type_name}(\'{var_name}\')'
 
         leading_comment = field.comments
         if leading_comment:
@@ -182,11 +247,14 @@ class FileTsGen():
             yield '\n'
 
         if package.messages:
-            yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
-            for key, msg in package.sortedMessages().items():
-
-                package_msg_name = '%s_%s' % (package.name, msg.name)
-                yield '  case %s_msgid: return %s_max_size;\n' % (package_msg_name, package_msg_name)
-
-            yield '  default: break;\n } return 0;\n}'
+            # Only generate get_message_length if there are messages with IDs
+            messages_with_id = [
+                msg for key, msg in package.sortedMessages().items() if msg.id]
+            if messages_with_id:
+                yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
+                for msg in messages_with_id:
+                    package_msg_name = '%s_%s' % (package.name, msg.name)
+                    yield '  case %s_msgid: return %s_max_size;\n' % (package_msg_name, package_msg_name)
+
+                yield '  default: break;\n } return 0;\n}'
             yield '\n'

struct_frame-0.0.30.dist-info/METADATA

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: struct-frame
+Version: 0.0.30
+Summary: A framework for serializing data with headers
+Project-URL: Homepage, https://github.com/mylonics/struct-frame
+Project-URL: Issues, https://github.com/mylonics/struct-frame/issues
+Author-email: Rijesh Augustine <rijesh@mylonics.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: proto-schema-parser>=1.4.5
+Requires-Dist: structured-classes>=3.1.0
+Description-Content-Type: text/markdown
+
+
+# Struct Frame
+
+A multi-language code generation framework that converts Protocol Buffer (.proto) files into serialization/deserialization code for C, TypeScript, Python, and GraphQL. It provides framing and parsing utilities for structured message communication.
+
+## Quick Start
+
+### Installation
+```bash
+# Install Python dependencies
+pip install proto-schema-parser structured-classes
+
+# Install Node.js dependencies (for TypeScript)
+npm install
+```
+
+### Basic Usage
+```bash
+# Generate code for all languages
+PYTHONPATH=src python3 src/main.py examples/myl_vehicle.proto --build_c --build_ts --build_py --build_gql
+
+# Run comprehensive test suite
+python test_all.py
+
+# Generated files will be in the generated/ directory
+```
+
+### Test Suite
+
+The project includes a comprehensive test suite that validates code generation, compilation, and serialization across all supported languages:
+
+```bash
+# Run all tests
+python test_all.py
+
+# Run with verbose output
+python tests/run_tests.py --verbose
+
+# Skip specific languages
+python tests/run_tests.py --skip-ts --skip-c
+
+# Generate code only (no compilation/execution)
+python tests/run_tests.py --generate-only
+```
+
+See `tests/README.md` for detailed test documentation.
+
+### Language-Specific Examples
+
+#### Python
+```bash
+python src/main.py examples/myl_vehicle.proto --build_py
+# Use generated Python classes directly
+```
+
+#### TypeScript
+```bash
+python src/main.py examples/myl_vehicle.proto --build_ts
+npx tsc examples/index.ts --outDir generated/
+node generated/examples/index.js
+```
+
+#### C
+```bash
+python src/main.py examples/myl_vehicle.proto --build_c
+gcc examples/main.c -I generated/c -o main
+./main
+```
+
+#### GraphQL
+```bash
+python src/main.py examples/myl_vehicle.proto --build_gql
+# Use generated .graphql schema files
+```
+
+## Feature Compatibility Matrix
+
+| Feature | C | TypeScript | Python | GraphQL | Status |
+|---------|---|------------|--------|---------|--------|
+| **Core Types** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **String** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Enums** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Nested Messages** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Message IDs** | ✓ | ✓ | ✓ | N/A | Stable |
+| **Message Serialization** | ✓ | ✓ | ✓ | N/A | Stable |
+| **Flatten** | N/A | N/A | ✓ | ✓ | Partial |
+| **Arrays** | ✓ | ✓ | ✓ | ✓ | Stable |
+
+**Legend:**
+- **✓** - Feature works as documented
+- **Partial** - Basic functionality works, some limitations  
+- **✗** - Feature not yet available
+- **N/A** - Not applicable for this language
+
+## Project Structure
+
+- `src/struct_frame/` - Core code generation framework
+  - `generate.py` - Main parser and validation logic
+  - `*_gen.py` - Language-specific code generators
+  - `boilerplate/` - Runtime libraries for each language
+- `examples/` - Example .proto files and usage demos
+  - `main.c` - C API demonstration (encoding/decoding, parsing)
+  - `index.ts` - TypeScript API demonstration (similar functionality)  
+  - `*.proto` - Protocol Buffer definitions for examples
+- `generated/` - Output directory for generated code (git-ignored)
+
+## Protocol Buffer Schema Reference
+
+### Supported Data Types
+
+| Type | Size (bytes) | Description | Range/Notes |
+|------|--------------|-------------|-------------|
+| **Integers** |
+| `int8` | 1 | Signed 8-bit integer | -128 to 127 |
+| `uint8` | 1 | Unsigned 8-bit integer | 0 to 255 |
+| `int16` | 2 | Signed 16-bit integer | -32,768 to 32,767 |
+| `uint16` | 2 | Unsigned 16-bit integer | 0 to 65,535 |
+| `int32` | 4 | Signed 32-bit integer | -2.1B to 2.1B |
+| `uint32` | 4 | Unsigned 32-bit integer | 0 to 4.3B |
+| `int64` | 8 | Signed 64-bit integer | Large integers |
+| `uint64` | 8 | Unsigned 64-bit integer | Large positive integers |
+| **Floating Point** |
+| `float` | 4 | Single precision (IEEE 754) | 7 decimal digits |
+| `double` | 8 | Double precision (IEEE 754) | 15-17 decimal digits |
+| **Other** |
+| `bool` | 1 | Boolean value | `true` or `false` |
+| `string` | Variable | UTF-8 encoded string | Length-prefixed |
+| `EnumType` | 1 | Custom enumeration | Defined in .proto |
+| `MessageType` | Variable | Nested message | User-defined structure |
+
+> **Note:** All types use little-endian byte order for cross-platform compatibility.
+
+### Array Support
+
+Arrays (repeated fields) support all data types - primitives, enums, and messages across all target languages.
+
+| Array Type | Syntax | Memory Usage | Use Case |
+|------------|--------|--------------|----------|
+| **Fixed** | `repeated type field = N [size=X];` | `sizeof(type) * X` | Matrices, buffers (always full) |  
+| **Bounded** | `repeated type field = N [max_size=X];` | 1 byte (count) + `sizeof(type) * X` | Dynamic lists with limits |
+| **String Arrays** | `repeated string field = N [max_size=X, element_size=Y];` | 1 byte (count) + `X * Y` bytes | Text collections with size limits |
+
+```proto
+message ArrayExample {
+  repeated float matrix = 1 [size=9];                        // 3x3 matrix (always 9 elements)
+  repeated string names = 2 [max_size=10, element_size=32];  // Up to 10 strings, each max 32 chars
+  repeated int32 values = 3 [max_size=100];                  // Up to 100 integers (variable count)
+}
+```
+
+**Generated Output** (all languages now supported):
+- **Python**: `matrix: list[float]`, `names: list[str]`, `values: list[int]`
+- **C**: `float matrix[9]`, `struct { uint8_t count; char data[10][32]; } names`
+- **TypeScript**: `Array('matrix', 'Float32LE', 9)`, `Array('names_data', 'String', 10)`  
+- **GraphQL**: `matrix: [Float!]!`, `names: [String!]!`, `values: [Int!]!`
+
+> **Important**: String arrays require both `max_size` (or `size`) AND `element_size` parameters because they are "arrays of arrays" - you need to specify both how many strings AND the maximum size of each individual string. This ensures predictable memory layout and prevents buffer overflows.
+
+### String Type
+
+Strings are a special case of bounded character arrays with built-in UTF-8 encoding and null-termination handling across all target languages.
+
+| String Type | Syntax | Memory Usage | Use Case |
+|-------------|--------|--------------|----------|
+| **Fixed String** | `string field = N [size=X];` | `X` bytes | Fixed-width text fields |
+| **Variable String** | `string field = N [max_size=X];` | 1 byte (length) + `X` bytes | Text with known maximum length |
+
+```proto
+message StringExample {
+  string device_name = 1 [size=16];              // Exactly 16 characters (pad with nulls)
+  string description = 2 [max_size=256];         // Up to 256 characters (length-prefixed)
+  string error_msg = 3 [max_size=128];           // Up to 128 characters for error messages
+}
+```
+
+**String Benefits:**
+- **Simplified Schema**: No need to specify `repeated uint8` for text data
+- **Automatic Encoding**: UTF-8 encoding/decoding handled by generators  
+- **Null Handling**: Proper null-termination and padding for fixed strings
+- **Type Safety**: Clear distinction between binary data and text
+- **Cross-Language**: Consistent string handling across C, TypeScript, and Python
+
+### Message Options
+
+**Message ID (`msgid`)** - Required for serializable messages:
+```proto
+message MyMessage {
+  option msgid = 42;  // Must be unique within package (0-65535)
+  string content = 1;
+}
+```
+
+### Field Options
+
+**Flatten (`flatten=true`)** - Merge nested message fields into parent:
+```proto
+message Position {
+  double lat = 1;
+  double lon = 2;
+}
+
+message Status {
+  Position pos = 1 [flatten=true];  // lat, lon become direct fields  
+  float battery = 2;
+}
+```
+
+**Array Options** - Control array behavior:
+```proto
+message Data {
+  repeated int32 fixed_buffer = 1 [size=256];                       // Always 256 integers  
+  repeated int32 var_buffer = 2 [max_size=256];                     // Up to 256 integers
+  repeated string messages = 3 [max_size=10, element_size=64];      // Up to 10 strings, each max 64 chars
+  string device_name = 4 [size=32];                                 // Always 32 characters
+  string description = 5 [max_size=256];                            // Up to 256 characters
+}
+```
+
+## Complete Example
+
+```proto
+package sensor_system;
+
+enum SensorType {
+  TEMPERATURE = 0;
+  HUMIDITY = 1;
+  PRESSURE = 2;
+}
+
+message Position {
+  double lat = 1;
+  double lon = 2;
+  float alt = 3;
+}
+
+message SensorReading {
+  option msgid = 1;
+  
+  uint32 device_id = 1;
+  int64 timestamp = 2;
+  SensorType type = 3;
+  
+  // Device name (fixed 16-character string)  
+  string device_name = 4 [size=16];
+  
+  // Sensor location (flattened)
+  Position location = 5 [flatten=true];
+  
+  // Measurement values (up to 8 readings)
+  repeated float values = 6 [max_size=8];
+  
+  // Calibration matrix (always 3x3 = 9 elements)
+  repeated float calibration = 7 [size=9];
+  
+  // Error message (up to 128 characters)
+  string error_msg = 8 [max_size=128];
+  
+  bool valid = 9;
+}
+
+message DeviceStatus {
+  option msgid = 2;
+  
+  uint32 device_id = 1;
+  repeated SensorReading recent_readings = 2 [max_size=10];
+  float battery_level = 3;
+}
+```
+
+## Schema Validation Rules
+
+- **Message IDs**: Must be unique within package (0-65535)
+- **Field numbers**: Must be unique within message  
+- **Array requirements**: All `repeated` fields must specify `[size=X]` (fixed) or `[max_size=X]` (bounded)
+- **String requirements**: All `string` fields must specify `[size=X]` (fixed) or `[max_size=X]` (variable)
+- **String array requirements**: `repeated string` fields must specify both array size AND `[element_size=Y]`
+- **Flatten constraints**: No field name collisions after flattening
+- **Size limits**: Arrays limited to 255 elements maximum
+
+## Code Generation
+
+```bash
+# Generate all languages
+python src/main.py schema.proto --build_c --build_ts --build_py --build_gql
+
+# Language-specific paths
+python src/main.py schema.proto --build_py --py_path output/python/
+python src/main.py schema.proto --build_c --c_path output/c/
+python src/main.py schema.proto --build_ts --ts_path output/typescript/
+python src/main.py schema.proto --build_gql --gql_path output/graphql/
+```
+
+## Additional Documentation
+
+- **[Array Implementation Guide](ARRAY_IMPLEMENTATION.md)** - Comprehensive documentation of array features, syntax, and generated code examples across all languages

struct_frame-0.0.30.dist-info/RECORD

@@ -0,0 +1,12 @@
+struct_frame/__init__.py,sha256=m9hfIbcgCYvt-fIeYrJRQyk6I7rq35jSdZIhrMmZntg,374
+struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
+struct_frame/base.py,sha256=1Z_0vMkwz0X8r2hIVLv5yuhwwD929LwNMzVKBqFxxac,2012
+struct_frame/c_gen.py,sha256=4verO94bPBgxOGb4lkhal2RLWI_308ywbV0-54Mxz64,9539
+struct_frame/generate.py,sha256=8YL4MJ--vvOsv5MFqGjKSATSulanEqX_Qf0Jew6x7UU,23416
+struct_frame/gql_gen.py,sha256=jDLsyZJmfpVBpdXE06mixZ3D01NAmRioGJqk_FoQt90,7543
+struct_frame/py_gen.py,sha256=EQqw8u2o-FszROviQyQCpF45bbx0KqjdqVBefpyDqH4,7932
+struct_frame/ts_gen.py,sha256=glT9eA--j_8vaR8tHQ0ekDg7udIVgE9FGA4MGAwiCsA,10103
+struct_frame-0.0.30.dist-info/METADATA,sha256=j4JF0HSUrtNg8lzW6q8skpYXSKsQDG3ne7kKQd_fkXA,10831
+struct_frame-0.0.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+struct_frame-0.0.30.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
+struct_frame-0.0.30.dist-info/RECORD,,

struct_frame-0.0.27.dist-info/METADATA

@@ -1,62 +0,0 @@
-Metadata-Version: 2.4
-Name: struct-frame
-Version: 0.0.27
-Summary: A framework for serializing data with headers
-Project-URL: Homepage, https://github.com/mylonics/struct-frame
-Project-URL: Issues, https://github.com/mylonics/struct-frame/issues
-Author-email: Rijesh Augustine <rijesh@mylonics.com>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: proto-schema-parser>=1.4.5
-Requires-Dist: structured-classes>=3.1.0
-Description-Content-Type: text/markdown
-
-
-# Struct Frame
-
-A framework for serializing data with headers
-
-## Quick Start
-
-### Python Usage
-```bash
-# Install dependencies
-pip install -e .
-
-# Generate code from proto file
-python src/main.py examples/myl_vehicle.proto --build_c --build_ts --build_py
-
-# Generated files will be in the generated/ directory
-```
-
-### TypeScript Example
-```bash
-# Install TypeScript dependencies
-npm i -D typescript typed-struct @types/node
-
-# Generate TypeScript code first
-python src/main.py examples/myl_vehicle.proto --build_ts
-
-# Compile and run the example
-npx tsc examples/index.ts --outDir generated/
-node generated/examples/index.js
-```
-
-### C Example
-```bash
-# Generate C code first  
-python src/main.py examples/myl_vehicle.proto --build_c
-
-# Compile the C example
-gcc examples/main.c -I generated/c -o main
-./main
-```
-
-## Project Structure
-
-- `src/` - Source code for the struct-frame library
-- `examples/` - Example usage and demo files
-- `generated/` - Generated output files (ignored by git)

struct_frame-0.0.27.dist-info/RECORD

@@ -1,12 +0,0 @@
-struct_frame/__init__.py,sha256=m9hfIbcgCYvt-fIeYrJRQyk6I7rq35jSdZIhrMmZntg,374
-struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
-struct_frame/base.py,sha256=1Z_0vMkwz0X8r2hIVLv5yuhwwD929LwNMzVKBqFxxac,2012
-struct_frame/c_gen.py,sha256=RFzEx0EuMoxBwdRi3O1NZGJ4iw3c3h7g8rRU3zD2ubU,5997
-struct_frame/generate.py,sha256=rfz7d0w37UWs0qlylOhYgD3k0GVmBoaZAGWQp_HUmHc,13131
-struct_frame/gql_gen.py,sha256=6-zaocD3qgPQyovjAihxl3DJZ9OHXM225VvO5KQmtkI,4488
-struct_frame/py_gen.py,sha256=7kvMsWPxAyLzTQg_BRj3g-yICH-6ilIGxMABEQdLayQ,4980
-struct_frame/ts_gen.py,sha256=qdJgAMxL2lV_WmGZErjHpgukYHNNpKpECarXdfmngEI,6266
-struct_frame-0.0.27.dist-info/METADATA,sha256=LwhsBrTZ0SQOMrMbHgWguP3d796SfASF8QwTe_y9cjU,1578
-struct_frame-0.0.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-struct_frame-0.0.27.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
-struct_frame-0.0.27.dist-info/RECORD,,