struct-frame 0.0.11__py3-none-any.whl

struct-frame/boilerplate/c/struct_frame_types.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "stdbool.h"
+#include "stdint.h"
+
+typedef struct _msg_id_len_t {
+  bool valid;
+  uint8_t len;
+  uint8_t msg_id;
+} msg_id_len_t;
+
+typedef struct _parser_functions_t {
+  bool (*get_msg_id_len)(msg_id_len_t *, uint8_t);
+  bool (*validate_packet)(uint8_t *, msg_id_len_t *);
+} parser_functions_t;
+
+typedef struct _struct_frame_config {
+  uint8_t has_crc;
+  uint8_t has_len;
+  uint8_t start_byte;
+  parser_functions_t *parser_funcs;
+} struct_frame_config;
+
+enum ParserState { LOOKING_FOR_START_BYTE = 0, GETTING_LENGTH_MSG_AND_ID = 1, GETTING_PAYLOAD = 2 };
+
+typedef struct _struct_frame_buffer {
+  // Used for framing and parsing
+  struct_frame_config config;
+  uint8_t *data;
+  size_t max_size;
+  size_t size;
+  bool in_progress;
+
+  // Used for framing
+  size_t crc_start_loc;
+
+  // Used for parsing
+  enum ParserState state;
+  size_t payload_len;
+  msg_id_len_t msg_id_len;
+
+} struct_buffer;
+
+typedef struct _buffer_parser_result_t {
+  struct_frame_config config;
+  bool found;
+  bool valid;
+  uint8_t *msg_loc;
+  size_t r_loc;
+  bool finished;
+  msg_id_len_t msg_id_len;
+} buffer_parser_result_t;
+
+// https://github.com/serge-sans-paille/frozen
+// https://www.npmjs.com/package/typed-struct
+
+#define default_parser {0, 0, 0x90}
+
+#define zero_initialized_parser_result {default_parser, false, false, 0, 0, false, {0, 0}};
+
+#define CREATE_DEFAULT_STRUCT_BUFFER(name, size) \
+  uint8_t name##_buffer[size];                   \
+  struct_buffer name = {                         \
+      default_parser, name##_buffer, size, 0, false, 0, LOOKING_FOR_START_BYTE, 0, {false, 0, 0}}
+
+typedef struct checksum_t {
+  uint8_t byte1;
+  uint8_t byte2;
+} checksum_t;

struct-frame/boilerplate/ts/struct_frame.ts

@@ -0,0 +1,65 @@
+import { Struct } from 'typed-struct';
+import * as sf_types from './struct_frame_types';
+
+function fletcher_checksum_calculation(buffer: Uint8Array, data_length: number): sf_types.checksum_t {
+    const checksum: sf_types.checksum_t = { byte1: 0, byte2: 0 };
+
+    for (let i = 0; i < data_length; i++) {
+        checksum.byte1 += buffer[i];
+        checksum.byte2 += checksum.byte1;
+    }
+    return checksum;
+}
+
+export function msg_encode(buffer: sf_types.struct_frame_buffer, msg: any, msgid: number) {
+    buffer.data[buffer.size++] = buffer.config.start_byte;
+    buffer.crc_start_loc = buffer.size;
+    buffer.data[buffer.size++] = msgid;
+
+    if (buffer.config.has_len) {
+        buffer.data[buffer.size++] = msg.getSize();
+    }
+    const rawData = Struct.raw(msg);
+    for (let i = 0; i < rawData.length; i++) {
+        buffer.data[buffer.size++] = rawData[i]
+    }
+
+    if (buffer.config.has_crc) {
+        const crc = fletcher_checksum_calculation(buffer.data.slice(buffer.crc_start_loc), buffer.crc_start_loc + rawData.length);
+        buffer.data[buffer.size++] = crc.byte1;
+        buffer.data[buffer.size++] = crc.byte2;
+    }
+}
+
+export function msg_reserve(buffer: sf_types.struct_frame_buffer, msg_id: number, msg_size: number) {
+    throw new Error('Function Unimplemented');
+
+    if (buffer.in_progress) {
+        return;
+    }
+    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++] = msg_size;
+    }
+
+    const ret = Buffer.from(buffer.data, buffer.size, msg_size);
+    buffer.size += msg_size;
+    return ret;
+}
+
+
+
+export function msg_finish(buffer: sf_types.struct_frame_buffer) {
+    throw new Error('Function Unimplemented');
+
+    if (buffer.config.has_crc) {
+        const crc = fletcher_checksum_calculation(buffer.data.slice(buffer.crc_start_loc), buffer.crc_start_loc - buffer.size);
+        buffer.data[buffer.size++] = crc.byte1;
+        buffer.data[buffer.size++] = crc.byte2;
+        buffer.size += 2
+    }
+    buffer.in_progress = false;
+}                                                                      

struct-frame/boilerplate/ts/struct_frame_gen.ts

@@ -0,0 +1,7 @@
+
+import * as bs from './biostream.sf';
+
+export function get_message_length(msg_id: number) {
+  console.log(msg_id)
+  return bs.get_message_length(msg_id);
+}

struct-frame/boilerplate/ts/struct_frame_parser.ts

@@ -0,0 +1,98 @@
+import { get_message_length } from './struct_frame_gen';
+import * as sf_types from './struct_frame_types';
+
+function parse_default_format_validate(buffer: Uint8Array, msg_id_len: sf_types.msg_id_len_t): boolean {
+  return true;
+}
+
+function parse_default_format_char_for_len_id(c: number, msg_id_len: sf_types.msg_id_len_t): boolean {
+  msg_id_len.msg_id = c;
+  msg_id_len.len = get_message_length(c);
+  return true;
+}
+
+const default_parser_functions: sf_types.parser_functions_t = { get_msg_id_len: parse_default_format_char_for_len_id, validate_packet: parse_default_format_validate };
+
+function parse_char_for_start_byte(config: sf_types.struct_frame_config, c: number): sf_types.parser_functions_t | undefined {
+  if (config.start_byte == c) {
+    return default_parser_functions;
+  }
+  return;
+}
+
+export function parse_char(pb: sf_types.struct_frame_buffer, c: number): boolean {
+  let parse_func_ptr: sf_types.parser_functions_t | undefined = undefined;
+  switch (pb.state) {
+    case sf_types.ParserState.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 = sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID;
+      }
+      break;
+
+    case sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID:
+      if (pb.config.parser_funcs && pb.config.parser_funcs.get_msg_id_len(c, pb.msg_id_len)) {
+        pb.state = sf_types.ParserState.GETTING_PAYLOAD;
+        pb.size = 0;
+      }
+      break;
+
+    case sf_types.ParserState.GETTING_PAYLOAD:
+      pb.data[pb.size] = c;
+      pb.size++;
+      if (pb.size >= pb.msg_id_len.len) {
+        pb.msg_data = Buffer.from(pb.data, 0, pb.size)
+        pb.state = sf_types.ParserState.LOOKING_FOR_START_BYTE;
+        if (pb.config.parser_funcs) {
+          return pb.config.parser_funcs.validate_packet(pb.data, pb.msg_id_len);
+        }
+        return false;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  return false;
+}
+
+export function parse_buffer(buffer: Uint8Array, size: number, parser_result: sf_types.buffer_parser_result_t): boolean {
+  let state: sf_types.ParserState = sf_types.ParserState.LOOKING_FOR_START_BYTE;
+  let parse_func_ptr: sf_types.parser_functions_t | undefined;
+  for (let i = parser_result.r_loc; i < size; i++) {
+    switch (state) {
+      case sf_types.ParserState.LOOKING_FOR_START_BYTE:
+        parse_func_ptr = parse_char_for_start_byte(parser_result.config, buffer[i]);
+        if (parse_func_ptr) {
+          state = sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID;
+        }
+        break;
+
+      case sf_types.ParserState.GETTING_LENGTH_MSG_AND_ID:
+        if (parse_func_ptr && parse_func_ptr.get_msg_id_len(buffer[i], parser_result.msg_id_len)) {
+          state = sf_types.ParserState.GETTING_PAYLOAD;
+        }
+        break;
+
+      case sf_types.ParserState.GETTING_PAYLOAD:
+        parser_result.msg_data = Buffer.from(buffer, i, (i + parser_result.msg_id_len.len));
+        parser_result.r_loc = i + parser_result.msg_id_len.len;
+        parser_result.found = true;
+        if (parse_func_ptr && parse_func_ptr.validate_packet(parser_result.msg_data, parser_result.msg_id_len)) {
+          parser_result.valid = true;
+          return true;
+        }
+        else {
+          parser_result.valid = false;
+          return true;
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+  return false;
+}

struct-frame/boilerplate/ts/struct_frame_types.ts

@@ -0,0 +1,80 @@
+
+export class msg_id_len_t {
+  valid = false;
+  len = 0;
+  msg_id = 0;
+}
+
+export type GetMsgIdLenType = (c: number, msg_id_len: msg_id_len_t) => boolean;
+export type ValidatePacketType = (buffer: Uint8Array, msg_id_len: msg_id_len_t) => boolean;
+
+export interface parser_functions_t {
+  get_msg_id_len: GetMsgIdLenType;
+  validate_packet: ValidatePacketType;
+}
+
+export interface struct_frame_config {
+  has_crc: number;
+  has_len: number;
+  start_byte: number;
+  parser_funcs?: parser_functions_t;
+}
+
+export enum ParserState {
+  LOOKING_FOR_START_BYTE = 0,
+  GETTING_LENGTH_MSG_AND_ID = 1,
+  GETTING_PAYLOAD = 2
+};
+
+export const basic_frame_config: struct_frame_config = { has_crc: 0, has_len: 0, start_byte: 0x90 };
+
+export class struct_frame_buffer {
+  // Used for framing and parsing
+  config: struct_frame_config = basic_frame_config;
+  data: Uint8Array;
+  size = 0;
+  in_progress = false;
+
+  // Used for framing
+  crc_start_loc = 0;
+
+  // Used for parsing
+  state: ParserState = ParserState.LOOKING_FOR_START_BYTE;
+  payload_len = 0;
+  msg_id_len: msg_id_len_t = new msg_id_len_t();
+  msg_data: Buffer = Buffer.allocUnsafe(0);
+
+  constructor(public max_size: number, buffer?: Uint8Array) {
+    if (buffer) {
+      this.data = buffer;
+    } else {
+      this.data = new Uint8Array(max_size);
+    }
+  }
+}
+
+export class buffer_parser_result_t {
+  config: struct_frame_config = basic_frame_config;
+  found = false;
+  valid = false;
+  msg_data: Buffer = Buffer.allocUnsafe(0);
+  r_loc = 0;
+  finished = false;
+  msg_id_len: msg_id_len_t = new msg_id_len_t();
+}
+
+// https://github.com/serge-sans-paille/frozen
+// https://www.npmjs.com/package/typed-struct
+
+//#define default_parser { 0, 0, 0x90 }
+//
+//#define zero_initialized_parser_result { default_parser, false, false, 0, 0, false, { 0, 0} };
+//
+//#define CREATE_DEFAULT_STRUCT_BUFFER(name, size) \
+//  uint8_t name##_buffer[size]; \
+//  struct_buffer name = { default_parser, name##_buffer, size, 0, 0, false, 0, 0, 0, 0, NULL }
+
+export interface checksum_t {
+  byte1: number;
+  byte2: number;
+}

struct-frame/c_gen.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+from .base import version, NamingStyleC, CamelToSnakeCase, pascalCase
+import time
+
+StyleC = NamingStyleC()
+
+c_types = {"uint8": "uint8_t",
+           "int8": "int8_t",
+           "uint16": "uint16_t",
+           "int16": "int16_t",
+           "uint32": "uint32_t",
+           "int32": "int32_t",
+           "bool": "bool",
+           "float": "float",
+           "double": "double"}
+
+
+class EnumCGen():
+    @staticmethod
+    def generate(field):
+        leading_comment = field.comments
+
+        result = ''
+        if leading_comment:
+            for c in leading_comment:
+                result = '%s\n' % c
+        
+        enumName = '%s%s' % (pascalCase(field.package), field.name)
+        result += 'typedef enum %s' % (enumName)
+
+        result += ' {\n'
+
+        enum_length = len(field.data)
+        enum_values = []
+        for index, (d) in enumerate(field.data):
+            leading_comment = field.data[d][1]
+
+            if leading_comment:
+                for c in leading_comment:
+                    enum_values.append(c)
+
+            comma = ","
+            if index == enum_length - 1:
+                # last enum member should not end with a comma
+                comma = ""
+
+            enum_value = "    %s_%s = %d%s" % (CamelToSnakeCase(field.name).upper(),StyleC.enum_entry(d), field.data[d][0], comma)
+            
+            enum_values.append(enum_value)
+
+        result += '\n'.join(enum_values)
+        result += '\n}'
+
+        result += ' %s;\n' % (enumName)
+
+        result += 'typedef uint8_t %s_t;' % (enumName)
+        return result
+
+
+class FieldCGen():
+    @staticmethod
+    def generate(field):
+        result = ''
+
+        var_name = field.name
+        type_name = field.fieldType 
+        if type_name in c_types:
+            type_name = 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, "")
+
+        leading_comment = field.comments
+        if leading_comment:
+            for c in leading_comment:
+                result = c + "\n" + result
+
+        return result
+
+
+class MessageCGen():
+    @staticmethod
+    def generate(msg):
+        leading_comment = msg.comments
+
+        result = ''
+        if leading_comment:
+            for c in msg.comments:
+                result = '%s\n' % c
+
+        
+        structName = '%s%s' % (pascalCase(msg.package), msg.name.title())
+        result += 'typedef struct %s {' % structName
+
+        result += '\n'
+
+        size = 1
+        if not msg.fields:
+            # Empty structs are not allowed in C standard.
+            # Therefore add a dummy field if an empty message occurs.
+            result += '    char dummy_field;'
+        else:
+            size = msg.size
+        
+        result += '\n'.join([FieldCGen.generate(f) for key, f in msg.fields.items()])
+        result += '\n}'
+        result += ' %s;\n\n' % structName
+        
+        defineName = '%s_%s' % (CamelToSnakeCase(msg.package).upper(), CamelToSnakeCase(msg.name).upper())
+        result += '#define %s_MAX_SIZE %d;\n' % (defineName, size)
+
+        if msg.id:
+            result += '#define %s_MSG_ID %d\n' % (defineName, msg.id)
+
+        
+        funcName = defineName.lower()
+        result += 'MESSAGE_HELPER(%s, %s, %d, %d);\n\n' % (funcName, structName,
+                                                       size, msg.id)
+
+        return result + '\n'
+    
+    @staticmethod
+    def get_initializer(msg, null_init):
+        if not msg.fields:
+            return '{0}'
+
+        parts = []
+        for field in msg.fields:
+            parts.append(field.get_initializer(null_init))
+        return '{' + ', '.join(parts) + '}'
+
+
+class FileCGen():
+    @staticmethod
+    def generate(package):
+        yield '/* Automatically generated struct frame header */\n'
+        yield '/* Generated by %s at %s. */\n\n' % (version, time.asctime())
+
+        yield '#pragma once\n'
+        yield '#pragma pack(1)\n'
+
+        yield '#include "struct_frame.h"\n'
+
+        #include additional header files if available in the future
+
+        if package.enums:
+            yield '/* Enum definitions */\n'
+            for key, enum in package.enums.items():
+                yield EnumCGen.generate(enum) + '\n\n'
+
+        if package.messages:
+            yield '/* Struct definitions */\n'
+            # Need to sort messages to make sure dependecies are properly met
+
+            for key, msg in package.sortedMessages().items():
+                yield MessageCGen.generate(msg) + '\n'
+            yield '\n'
+
+        # Add default initializers if needed
+        #if package.messages:
+        #    yield '/* Initializer values for message structs */\n'
+        #    for key, msg in package.messages.items():
+        #        identifier = '%s_%s_init_default' % (package.name, StyleC.struct_name(msg.name))
+        #        yield '#define %-40s %s\n' % (identifier, MessageCGen.get_initializer(msg, False))
+        #    for key, msg in package.messages.items():
+        #        identifier = '%s_%s_init_zero' % (package.name, StyleC.struct_name(msg.name))
+        #        yield '#define %-40s %s\n' % (identifier, msg.get_initializer(True))
+        #    yield '\n'
+
+        if package.messages:
+            yield 'uint8_t get_message_length(uint8_t msg_id){\n switch (msg_id)\n {\n'
+            for key, msg in package.sortedMessages().items():
+                name = '%s_%s' % (CamelToSnakeCase(msg.package).upper(), CamelToSnakeCase(msg.name).upper())
+                yield '  case %s_MSG_ID: return %s_MAX_SIZE;\n' % (name, name)
+
+            yield '  default: break;\n } return 0;\n}'
+            yield '\n'
+

struct-frame/ts_gen.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+from .base import version, NamingStyleC
+import time
+
+StyleC = NamingStyleC()
+
+ts_types = {
+    "int8_t":     'Int8',
+    "uint8_t":    'UInt8',
+    "int16_t":    'Int16LE',
+    "uint16_t":   'UInt16LE',
+    "bool":     'Boolean8',
+    "double":   'Float64LE',
+    "float":    'Float32LE',
+    "int32_t":  'Int32LE',
+    "uint32_t": 'UInt32LE',
+    "uint64_t": 'BigInt64LE',
+    "int64_t":  'BigUInt64LE',
+}
+
+class EnumTsGen():
+    @staticmethod
+    def generate(field, packageName):
+        leading_comment = field.comments
+        result = ''
+        if leading_comment:
+            for c in leading_comment:
+                result = '%s\n' % c
+
+        result += 'export enum %s%s' % (packageName, StyleC.enum_name(field.name))
+
+        result += ' {\n'
+
+        enum_length = len(field.data)
+        enum_values = []
+        for index, (d) in enumerate(field.data):
+            leading_comment = field.data[d][1]
+
+            if leading_comment:
+                for c in leading_comment:
+                    enum_values.append(c)
+
+            comma = ","
+            if index == enum_length - 1:
+                # last enum member should not end with a comma
+                comma = ""
+
+            enum_value = "    %s = %d%s" % (
+                StyleC.enum_entry(d), field.data[d][0], comma)
+           
+            enum_values.append(enum_value)
+
+        result += '\n'.join(enum_values)
+        result += '\n}'
+
+        return result
+
+
+class FieldTsGen():
+    @staticmethod
+    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)
+        else:
+            result += '    .%s(\'%s\')' % (type_name, var_name)
+
+        leading_comment = field.comments
+        if leading_comment:
+            for c in leading_comment:
+                result = c + "\n" + result
+
+        return result
+
+
+# ---------------------------------------------------------------------------
+#                   Generation of messages (structures)
+# ---------------------------------------------------------------------------
+
+
+class MessageTsGen():
+    @staticmethod
+    def generate(msg, packageName):
+        leading_comment = msg.comments
+
+        result = ''
+        if leading_comment:
+            for c in msg.comments:
+                result = '%s\n' % c
+                
+        struct_name = '%s_%s' % (packageName, StyleC.type_name(msg.name))
+        result += 'export const %s = new typed_struct.Struct(\'%s\') ' % (
+            struct_name, struct_name)
+
+        result += '\n'
+
+        size = 1
+        if not msg.fields:
+            # Empty structs are not allowed in C standard.
+            # Therefore add a dummy field if an empty message occurs.
+            result += '    .UInt8(\'dummy_field\');'
+        else:
+            size = msg.size
+
+        result += '\n'.join([FieldTsGen.generate(f, packageName) for key, f in msg.fields.items()])
+        result += '\n    .compile();\n\n'
+
+        result += 'export const %s_max_size = %d;\n' % (struct_name, size)
+
+        if msg.id:
+            result += 'export const %s_msgid = %d\n' % (msg.name, msg.id)
+
+            result += 'export function %s_encode(buffer: struct_frame_buffer, msg: any) {\n' % (
+                msg.name)
+            result += '    msg_encode(buffer, msg, %s_msgid)\n}\n' % (msg.name)
+
+            result += 'export function %s_reserve(buffer: struct_frame_buffer) {\n' % (
+                msg.name)
+            result += '    const msg_buffer = msg_reserve(buffer, %s_msgid, %s_max_size);\n' % (
+                msg.name, msg.name)
+            result += '    if (msg_buffer){\n'
+            result += '        return new %s(msg_buffer)\n    }\n    return;\n}\n' % (
+                msg.name)
+
+            result += 'export function %s_finish(buffer: struct_frame_buffer) {\n' % (
+                msg.name)
+            result += '    msg_finish(buffer);\n}\n'
+        return result + '\n'
+
+    @staticmethod
+    def get_initializer(msg, null_init):
+        if not msg.fields:
+            return '{0}'
+
+        parts = []
+        for field in msg.fields:
+            parts.append(field.get_initializer(null_init))
+        return '{' + ', '.join(parts) + '}'
+    
+
+class FileTsGen():
+    @staticmethod
+    def generate(package):
+        yield '/* Automatically generated struct frame header */\n'
+        yield '/* Generated by %s at %s. */\n\n' % (version, time.asctime())
+
+        yield 'const typed_struct = require(\'typed-struct\')\n'
+        yield 'const ExtractType = typeof typed_struct.ExtractType;\n'
+        yield 'const type = typeof typed_struct.ExtractType;\n\n'
+
+        yield "import { struct_frame_buffer } from './struct_frame_types';\n"
+
+        yield "import { msg_encode, msg_reserve, msg_finish } from './struct_frame';\n\n"
+
+        #include additional header files here if available in the future
+        
+        if package.enums:
+            yield '/* Enum definitions */\n'
+            for key, enum in package.enums.items():
+                yield EnumTsGen.generate(enum, package.name) + '\n\n'
+
+        if package.messages:
+            yield '/* Struct definitions */\n'
+            for key, msg in package.sortedMessages().items():
+                yield MessageTsGen.generate(msg, package.name) + '\n'
+            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():
+                name = StyleC.type_name(msg.name)
+                yield '  case %s_msgid: return %s_max_size;\n' % (name, name)
+
+            yield '  default: break;\n } return 0;\n}'
+            yield '\n'