struct-frame 0.0.11__py3-none-any.whl

struct-frame/__init__.py

@@ -0,0 +1,3 @@
+#from .ast import Field, FieldCardinality, Message, Option
+#from .parser import Parser
+#__all__ = ["Parser", "Message", "Field", "Option", "FieldCardinality"]

struct-frame/__main__.py

@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+
+from .c_gen import FileCGen
+from .ts_gen import FileTsGen
+from proto_schema_parser.parser import Parser
+from proto_schema_parser import ast
+
+import argparse
+
+recErrCurrentField = ""
+recErrCurrentMessage = ""
+
+default_types = {
+    "uint8": {"size": 1},
+    "int8": {"size": 1},
+    "uint16": {"size": 2},
+    "int16": {"size": 2},
+    "uint32": {"size": 4},
+    "int32": {"size": 4},
+    "bool": {"size": 1},
+    "float": {"size": 4},
+    "double": {"size": 8}
+}
+
+
+class Enum:
+    def __init__(self, package, comments):
+        self.name = None
+        self.data = {}
+        self.size = 1
+        self.comments = comments
+        self.package = package
+        self.isEnum = True
+
+    def parse(self, enum):
+        self.name = enum.name
+        comments = []
+        for e in enum.elements:
+            if type(e) == ast.Comment:
+                comments.append(e.text)
+            else:
+                if e.name in self.data:
+                    print(f"Enum Field Redclaration")
+                    return False
+                self.data[e.name] = (e.number, comments)
+                comments = []
+
+        return True
+
+    def validate(self, currentPackage, packages):
+        return True
+
+    def __str__(self):
+        output = ""
+        for c in self.comments:
+            output = output + c + "\n"
+
+        output = output + f"Enum: {self.name}\n"
+
+        for key, value in self.data.items():
+            output = output + f"Key: {key}, Value: {value}" + "\n"
+        return output
+
+
+class Field:
+    def __init__(self, package, comments):
+        self.name = None
+        self.fieldType = None
+        self.isDefaultType = False
+        self.size = 0
+        self.validated = False
+        self.comments = comments
+        self.package = package
+        self.isEnum = False
+
+    def parse(self, field):
+        self.name = field.name
+        self.fieldType = field.type
+        if self.fieldType in default_types:
+            self.isDefaultType = True
+            self.size = default_types[self.fieldType]["size"]
+            self.validated = True
+        return True
+
+    def validate(self, currentPackage, packages):
+
+        global recErrCurrentField
+        recErrCurrentField = self.name
+        if not self.validated:
+            ret = currentPackage.findFieldType(self.fieldType)
+
+            if ret:
+                if ret.validate(currentPackage, packages):
+                    self.isEnum = ret.isEnum
+                    self.validate = True
+                    self.size = ret.size
+                else:
+                    print(
+                        f"Failed to validate Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
+                    return False
+            else:
+                print(
+                    f"Failed to find Field: {self.name} of Type: {self.fieldType} in Package: {currentPackage.name}")
+                return False
+
+        return True
+
+    def __str__(self):
+        output = ""
+        for c in self.comments:
+            output = output + c + "\n"
+        output = output + \
+            f"Field: {self.name}, Type:{self.fieldType}, Size:{self.size}"
+        return output
+
+
+class Message:
+    def __init__(self, package, comments):
+        self.id = None
+        self.size = 0
+        self.name = None
+        self.fields = {}
+        self.validated = False
+        self.comments = comments
+        self.package = package
+        self.isEnum = False
+
+    def parse(self, msg):
+        self.name = msg.name
+        comments = []
+        for e in msg.elements:
+            if type(e) == ast.Option:
+                if e.name == "msgid":
+                    if self.id:
+                        raise Exception(f"Redefinition of msg_id for {e.name}")
+                    self.id = e.value
+            elif type(e) == ast.Comment:
+                comments.append(e.text)
+            elif type(e) == ast.Field:
+                if e.name in self.fields:
+                    print(f"Field Redclaration")
+                    return False
+                self.fields[e.name] = Field(self.package, comments)
+                comments = []
+                if not self.fields[e.name].parse(e):
+                    return False
+        return True
+
+    def validate(self, currentPackage, packages):
+        if self.validated:
+            return True
+
+        global recErrCurrentMessage
+        recErrCurrentMessage = self.name
+        for key, value in self.fields.items():
+            if not value.validate(currentPackage, packages):
+                print(
+                    f"Failed To validate Field: {key}, in Message {self.name}\n")
+                return False
+            self.size = self.size + value.size
+
+        self.validated = True
+        return True
+
+    def __str__(self):
+        output = ""
+        for c in self.comments:
+            output = output + c + "\n"
+        output = output + \
+            f"Message: {self.name}, Size: {self.size}, ID: {self.id}\n"
+
+        for key, value in self.fields.items():
+            output = output + value.__str__() + "\n"
+        return output
+
+
+class Package:
+    def __init__(self, name):
+        self.name = name
+        self.enums = {}
+        self.messages = {}
+
+    def addEnum(self, enum, comments):
+        self.comments = comments
+        if enum.name in self.enums:
+            print(f"Enum Redclaration")
+            return False
+        self.enums[enum.name] = Enum(self.name, comments)
+        return self.enums[enum.name].parse(enum)
+
+    def addMessage(self, message, comments):
+        if message.name in self.messages:
+            print(f"Message Redclaration")
+            return False
+        self.messages[message.name] = Message(self.name, comments)
+        return self.messages[message.name].parse(message)
+
+    def validatePackage(self, allPackages):
+        names = []
+        for key, value in self.enums.items():
+            if value.name in names:
+                print(
+                    f"Name collision with Enum and Message: {value.name} in Packaage {self.name}")
+                return False
+            names.append(value.name)
+        for key, value in self.messages.items():
+            if value.name in names:
+                print(
+                    f"Name collision with Enum and Message: {value.name} in Packaage {self.name}")
+                return False
+            names.append(value.name)
+
+        for key, value in self.messages.items():
+            if not value.validate(self, allPackages):
+                print(
+                    f"Failed To validate Message: {key}, in Package {self.name}\n")
+                return False
+
+        return True
+
+    def findFieldType(self, name):
+        for key, value in self.enums.items():
+            if value.name == name:
+                return value
+
+        for key, value in self.messages.items():
+            if value.name == name:
+                return value
+
+    def sortedMessages(self):
+        # Need to sort messages to ensure no out of order dependencies.
+        return self.messages
+
+    def __str__(self):
+        output = "Package: " + self.name + "\n"
+        for key, value in self.enums.items():
+            output = output + value.__str__() + "\n"
+        for key, value in self.messages.items():
+            output = output + value.__str__() + "\n"
+        return output
+
+packages = {}
+processed_file = []
+required_file = []
+
+parser = argparse.ArgumentParser(
+    prog='ProgramName',
+    description='What the program does',
+    epilog='Text at the bottom of help')
+
+parser.add_argument('filename')           # positional argument
+
+
+def parseFile(filename):
+    processed_file.append(filename)
+    with open(filename, "r") as f:
+        result = Parser().parse(f.read())
+
+        foundPackage = False
+        package_name = ""
+        comments = []
+
+        for e in result.file_elements:
+            if (type(e) == ast.Package):
+                if foundPackage:
+                    print(
+                        f"Multiple Package declaration found in file {filename} - {package_name}")
+                    return False
+                foundPackage = True
+                package_name = e.name
+                if package_name not in packages:
+                    packages[package_name] = Package(package_name)
+                packages
+
+            elif (type(e) == ast.Enum):
+                if not packages[package_name].addEnum(e, comments):
+                    print(
+                        f"Enum Error in Package: {package_name}  FileName: {filename} EnumName: {e.name}")
+                    return False
+                comments = []
+
+            elif (type(e) == ast.Message):
+                if not packages[package_name].addMessage(e, comments):
+                    print(
+                        f"Message Error in Package: {package_name}  FileName: {filename} MessageName: {e.name}")
+                    return False
+                comments = []
+
+            elif (type(e) == ast.Comment):
+                comments.append(e.text)
+
+
+def validatePackages():
+    for key, value in packages.items():
+        if not value.validatePackage(packages):
+            print(f"Failed To Validate Package: {key}")
+            return False
+
+    return True
+
+
+def printPackages():
+    for key, value in packages.items():
+        print(value)
+
+
+def generateCFileStrings(path):
+    out = {}
+    for key, value in packages.items():
+        name = path + value.name + ".sf.h"
+        data = ''.join(FileCGen.generate(value))
+        out[name] = data
+
+    return out
+
+def generateTsFileStrings(path):
+    out = {}
+    for key, value in packages.items():
+        name = path + value.name + ".sf.ts"
+        data = ''.join(FileTsGen.generate(value))
+        out[name] = data
+
+    return out
+
+
+import os
+
+def main():
+    args = parser.parse_args()
+    parseFile(args.filename)
+
+    try:
+        validatePackages()
+    except RecursionError as err:
+        print(
+            f'Recursion Error. Messages most likely have a cyclical dependancy. Check Message: {recErrCurrentMessage} and Field: {recErrCurrentField}')
+
+    cpath = "c/"
+    files = generateCFileStrings(cpath)
+
+    tspath ="ts/"
+    files.update(generateTsFileStrings(tspath))
+
+    for filename, filedata in files.items():
+        dirname = os.path.dirname(filename)
+        if dirname and not os.path.exists(dirname):
+            os.makedirs(dirname)
+
+        with open(filename , 'w', encoding='utf-8') as f:
+                    f.write(filedata)
+
+    #printPackages()
+
+
+if __name__ == '__main__':
+    main()

struct-frame/base.py

@@ -0,0 +1,80 @@
+
+import re
+
+version = "0.0.1"
+
+class NamingStyle:
+    def enum_name(self, name):
+        return "_%s" % (name)
+
+    def struct_name(self, name):
+        return "_%s" % (name)
+
+    def union_name(self, name):
+        return "_%s" % (name)
+
+    def type_name(self, name):
+        return "%s" % (name)
+
+    def define_name(self, name):
+        return "%s" % (name)
+
+    def var_name(self, name):
+        return "%s" % (name)
+
+    def enum_entry(self, name):
+        return "%s" % (name)
+
+    def func_name(self, name):
+        return "%s" % (name)
+
+    def bytes_type(self, struct_name, name):
+        return "%s_%s_t" % (struct_name, name)
+
+
+class NamingStyleC(NamingStyle):
+    def enum_name(self, name):
+        return self.underscore(name)
+
+    def struct_name(self, name):
+        return self.underscore(name)
+
+    def union_name(self, name):
+        return self.underscore(name)
+
+    def type_name(self, name):
+        return "%s_t" % self.underscore(name)
+
+    def define_name(self, name):
+        return self.underscore(name).upper()
+
+    def var_name(self, name):
+        return self.underscore(name)
+
+    def enum_entry(self, name):
+        return self.underscore(name).upper()
+
+    def func_name(self, name):
+        return self.underscore(name)
+
+    def bytes_type(self, struct_name, name):
+        return "%s_%s_t" % (self.underscore(struct_name), self.underscore(name))
+
+    def underscore(self, word):
+        word = str(word)
+        word = re.sub(r"([A-Z]+)([A-Z][a-z])", r'\1_\2', word)
+        word = re.sub(r"([a-z\d])([A-Z])", r'\1_\2', word)
+        word = word.replace("-", "_")
+        return word.lower()
+    
+def camelCase(st):
+    output = ''.join(x for x in st.title() if x.isalnum())
+    return output[0].lower() + output[1:]
+
+def pascalCase(st):
+    return ''.join(x for x in st.title() if x.isalnum())
+
+pattern = re.compile(r'(?<!^)(?=[A-Z])')
+
+def CamelToSnakeCase(data):
+    return pattern.sub('_', data).lower()

struct-frame/boilerplate/c/struct_frame.h

@@ -0,0 +1,103 @@
+#pragma once
+#include "stdbool.h"
+#include "stdint.h"
+#include "string.h"
+#include "struct_frame_types.h"
+
+static inline struct checksum_t fletcher_checksum_calculation(uint8_t *buffer, uint8_t data_length)
+{
+  checksum_t checksum;
+
+  for (int i = 0; i < data_length; i++)
+  {
+    checksum.byte1 += buffer[i];
+    checksum.byte2 += checksum.byte1;
+  }
+  return checksum;
+}
+
+static inline void msg_encode(struct_buffer *buffer, void *msg_buffer, uint8_t msg_id, uint8_t size)
+{
+  buffer->data[buffer->size++] = buffer->config.start_byte;
+  buffer->crc_start_loc = buffer->size;
+  buffer->data[buffer->size++] = msg_id;
+
+  if (buffer->config.has_len)
+  {
+    buffer->data[buffer->size++] = size;
+  }
+  memcpy(buffer->data + buffer->size, (uint8_t *)msg_buffer, size);
+  buffer->size += size;
+  if (buffer->config.has_crc)
+  {
+    checksum_t crc = fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc,
+                                                   buffer->crc_start_loc - buffer->size);
+    buffer->data[buffer->size++] = crc.byte1;
+    buffer->data[buffer->size++] = crc.byte2;
+  }
+}
+
+static inline void *msg_reserve(struct_buffer *buffer, uint8_t msg_id, uint8_t size)
+{
+  if (buffer->in_progress)
+  {
+    return 0;
+  }
+  buffer->in_progress = true;
+  buffer->data[buffer->size++] = buffer->config.start_byte;
+
+  buffer->data[buffer->size++] = msg_id;
+  if (buffer->config.has_len)
+  {
+    buffer->data[buffer->size++] = size;
+  }
+
+  void *out = &buffer->data[buffer->size];
+  buffer->size += size;
+
+  return out;
+}
+
+static inline void msg_finish(struct_buffer *buffer)
+{
+  if (buffer->config.has_crc)
+  {
+    checksum_t crc = fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc,
+                                                   buffer->crc_start_loc - buffer->size);
+    buffer->data[buffer->size++] = crc.byte1;
+    buffer->data[buffer->size++] = crc.byte2;
+  }
+  buffer->in_progress = false;
+}
+
+#define MESSAGE_HELPER(funcname, name, msg_size, msg_id)                                    \
+  static inline void funcname##_encode(struct_buffer *buffer, name *name##_obj)                    \
+  {                                                                                         \
+    msg_encode(buffer, name##_obj, msg_id, msg_size);                                       \
+  }                                                                                         \
+  static inline bool funcname##_reserve(struct_buffer *buffer, name **msg)                         \
+  {                                                                                         \
+    void *ptr = msg_reserve(buffer, msg_id, msg_size);                                      \
+    if (ptr)                                                                                \
+    {                                                                                       \
+      *msg = (name *)ptr;                                                                   \
+      return true;                                                                          \
+    }                                                                                       \
+    return false;                                                                           \
+  }                                                                                         \
+  static inline void funcname##_finish(struct_buffer *buffer) { msg_finish(buffer); }              \
+  static inline name funcname##_get(struct_buffer *buffer)                                         \
+  {                                                                                         \
+    name msg = *(name *)(buffer->data);                                                     \
+    return msg;                                                                             \
+  }                                                                                         \
+  static inline name funcname##_get_from_buffer_result(buffer_parser_result_t result)              \
+  {                                                                                         \
+    name msg = *(name *)(result.msg_loc);                                                   \
+    return msg;                                                                             \
+  }                                                                                         \
+  static inline name *funcname##_get_ref(struct_buffer *buffer) { return (name *)(buffer->data); } \
+  static inline name *funcname##_get_ref_from_buffer_result(buffer_parser_result_t result)         \
+  {                                                                                         \
+    return (name *)(result.msg_loc);                                                        \
+  }

struct-frame/boilerplate/c/struct_frame_gen.h

@@ -0,0 +1,2 @@
+#pragma once
+#include "myl_vehicle.sf.h"

struct-frame/boilerplate/c/struct_frame_parser.h

@@ -0,0 +1,101 @@
+#pragma once
+#include "stdint.h"
+#include "struct_frame_gen.h"
+#include "struct_frame_types.h"
+
+// https://github.com/serge-sans-paille/frozen
+
+static inline bool parse_default_format_validate(uint8_t *data, msg_id_len_t *msg_id_len) {
+  (void)data;
+  (void)msg_id_len;
+  return true;
+}
+
+static inline bool parse_default_format_char_for_len_id(msg_id_len_t *msg_id_len, const uint8_t c) {
+  msg_id_len->msg_id = c;
+  msg_id_len->len = get_message_length(c);
+  return true;
+}
+
+parser_functions_t default_parser_functions = {parse_default_format_char_for_len_id,
+                                                      parse_default_format_validate};
+
+static inline parser_functions_t *parse_char_for_start_byte(const struct_frame_config config,
+                                                     const uint8_t c) {
+  if (config.start_byte == c) {
+    return &default_parser_functions;
+  }
+  return NULL;
+}
+
+static inline bool parse_char(struct_buffer *pb, uint8_t c) {
+  parser_functions_t *parse_func_ptr = NULL;
+  switch (pb->state) {
+    case LOOKING_FOR_START_BYTE:
+      parse_func_ptr = parse_char_for_start_byte(pb->config, c);
+      if (parse_func_ptr) {
+        pb->config.parser_funcs = parse_func_ptr;
+        pb->state = GETTING_LENGTH_MSG_AND_ID;
+      }
+      break;
+
+    case GETTING_LENGTH_MSG_AND_ID:
+      if (pb->config.parser_funcs->get_msg_id_len(&pb->msg_id_len, c)) {
+        pb->state = GETTING_PAYLOAD;
+        pb->size = 0;
+      }
+      break;
+
+    case GETTING_PAYLOAD:
+      pb->data[pb->size++] = c;
+      if (pb->size >= pb->msg_id_len.len) {
+        pb->state = LOOKING_FOR_START_BYTE;
+        return pb->config.parser_funcs->validate_packet(pb->data, &pb->msg_id_len);
+      }
+
+      break;
+
+    default:
+      break;
+  }
+
+  return false;
+}
+
+static inline bool parse_buffer(uint8_t *buffer, size_t size, buffer_parser_result_t *parser_result) {
+  enum ParserState state = LOOKING_FOR_START_BYTE;
+  parser_functions_t *parse_func_ptr;
+  for (size_t i = parser_result->r_loc; i < size; i++) {
+    switch (state) {
+      case LOOKING_FOR_START_BYTE:
+        parse_func_ptr = parse_char_for_start_byte(parser_result->config, buffer[i]);
+        if (parse_func_ptr) {
+          state = GETTING_LENGTH_MSG_AND_ID;
+        }
+        break;
+
+      case GETTING_LENGTH_MSG_AND_ID:
+        if (parse_func_ptr->get_msg_id_len(&parser_result->msg_id_len, buffer[i])) {
+          state = GETTING_PAYLOAD;
+        }
+        break;
+
+      case GETTING_PAYLOAD:
+        parser_result->msg_loc = buffer + i;
+        parser_result->r_loc = i + parser_result->msg_id_len.len;
+        parser_result->found = true;
+        if (parse_func_ptr->validate_packet(parser_result->msg_loc, &parser_result->msg_id_len)) {
+          parser_result->valid = true;
+          return true;
+        } else {
+          parser_result->valid = false;
+          return true;
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+  return false;
+}