struct-frame 0.0.14__tar.gz → 0.0.16__tar.gz

{struct_frame-0.0.14 → struct_frame-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.14
+Version: 0.0.16
 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

{struct_frame-0.0.14 → struct_frame-0.0.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "struct-frame"
-version = "0.0.14"
+version = "0.0.16"
 authors = [
   { name="Rijesh Augustine", email="rijesh@mylonics.com" },
 ]

{struct_frame-0.0.14 → struct_frame-0.0.16}/src/struct_frame/generate.py

@@ -246,11 +246,13 @@ processed_file = []
 required_file = []
 
 parser = argparse.ArgumentParser(
-    prog='ProgramName',
-    description='What the program does',
-    epilog='Text at the bottom of help')
+    prog='struct_frame',
+    description='Message serialization and header generation program')
 
-parser.add_argument('filename')           # positional argument
+parser.add_argument('filename')
+parser.add_argument('--debug', action='store_true')
+parser.add_argument('--c_path', nargs=1, type=str, default=['c/'])
+parser.add_argument('--ts_path', nargs=1, type=str, default=['ts/'])
 
 
 def parseFile(filename):
@@ -305,11 +307,13 @@ def printPackages():
     for key, value in packages.items():
         print(value)
 
+import os
+import shutil
 
 def generateCFileStrings(path):
     out = {}
     for key, value in packages.items():
-        name = path + value.name + ".sf.h"
+        name = os.path.join(path, value.name + ".sf.h")
         data = ''.join(FileCGen.generate(value))
         out[name] = data
 
@@ -318,15 +322,12 @@ def generateCFileStrings(path):
 def generateTsFileStrings(path):
     out = {}
     for key, value in packages.items():
-        name = path + value.name + ".sf.ts"
+        name = os.path.join(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)
@@ -337,11 +338,10 @@ def main():
         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))
+    print(args.c_path)
+    print(args.ts_path)
+    files = generateCFileStrings(args.c_path[0])
+    files.update(generateTsFileStrings(args.ts_path[0]))
 
     for filename, filedata in files.items():
         dirname = os.path.dirname(filename)
@@ -351,7 +351,12 @@ def main():
         with open(filename , 'w', encoding='utf-8') as f:
                     f.write(filedata)
 
-    #printPackages()
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    shutil.copytree(os.path.join(dir_path,"boilerplate/c"), args.c_path[0], dirs_exist_ok=True)
+    shutil.copytree(os.path.join(dir_path,"boilerplate/ts"), args.ts_path[0], dirs_exist_ok=True)
+    
+    if args.debug:
+        printPackages()
 
 
 if __name__ == '__main__':

{struct_frame-0.0.14/c → struct_frame-0.0.16/tester}/biostream.sf.h

@@ -1,5 +1,5 @@
 /* Automatically generated struct frame header */
-/* Generated by 0.0.1 at Sat Feb  8 11:34:13 2025. */
+/* Generated by 0.0.1 at Sat Feb  8 12:01:15 2025. */
 
 #pragma once
 #pragma pack(1)

struct_frame-0.0.16/tester/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-0.0.16/tester/struct_frame_gen.h

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

struct_frame-0.0.16/tester/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;
+}

struct_frame-0.0.16/tester/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-0.0.14/ts → struct_frame-0.0.16/testerts}/biostream.sf.ts

@@ -1,5 +1,5 @@
 /* Automatically generated struct frame header */
-/* Generated by 0.0.1 at Sat Feb  8 11:34:13 2025. */
+/* Generated by 0.0.1 at Sat Feb  8 12:01:15 2025. */
 
 const typed_struct = require('typed-struct')
 const ExtractType = typeof typed_struct.ExtractType;

struct_frame-0.0.16/testerts/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-0.0.16/testerts/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-0.0.16/testerts/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-0.0.16/testerts/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;
+}