struct-frame 0.0.13__tar.gz → 0.0.15__tar.gz

{struct_frame-0.0.13 → struct_frame-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.13
+Version: 0.0.15
 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
@@ -33,4 +33,4 @@ py -m twine upload dist/*
 py -m pip install --upgrade twine
 
 
-run locally python .\src\struct-frame
+run locally python .\src\main.py

{struct_frame-0.0.13 → struct_frame-0.0.15}/README.md

@@ -18,4 +18,4 @@ py -m twine upload dist/*
 py -m pip install --upgrade twine
 
 
-run locally python .\src\struct-frame
+run locally python .\src\main.py

{struct_frame-0.0.13 → struct_frame-0.0.15}/c/biostream.sf.h

@@ -1,5 +1,5 @@
 /* Automatically generated struct frame header */
-/* Generated by 0.0.1 at Sat Feb  8 11:10:26 2025. */
+/* Generated by 0.0.1 at Sat Feb  8 11:45:44 2025. */
 
 #pragma once
 #pragma pack(1)

{struct_frame-0.0.13 → struct_frame-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "struct-frame"
-version = "0.0.13"
+version = "0.0.15"
 authors = [
   { name="Rijesh Augustine", email="rijesh@mylonics.com" },
 ]
@@ -27,8 +27,8 @@ Issues = "https://github.com/mylonics/struct-frame/issues"
 
 
 [tool.hatch.build.targets.wheel]
-only-include = ["src/struct-frame"]
+only-include = ["src/struct_frame"]
 
 [tool.hatch.build.targets.wheel.sources]
 "src" = ""
-"boilerplate" = "src/struct-frame/boilerplate"
+"boilerplate" = "src/struct_frame/boilerplate"

struct_frame-0.0.15/src/main.py

@@ -0,0 +1,3 @@
+import struct_frame
+
+struct_frame.main()

struct_frame-0.0.15/src/struct_frame/__init__.py

@@ -0,0 +1,8 @@
+from .base import version, NamingStyleC, CamelToSnakeCase, pascalCase
+
+from .c_gen import FileCGen
+from .ts_gen import FileTsGen
+
+from .generate import main
+
+__all__ = ["main", "FileCGen", "FileTsGen", "version", "NamingStyleC", "CamelToSnakeCase", "pascalCase"]

struct_frame-0.0.15/src/struct_frame/__main__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# kate: replace-tabs on; indent-width 4;
+
+
+from struct_frame import main
+
+if __name__ == '__main__':
+    main()

{struct_frame-0.0.13/src/struct-frame → struct_frame-0.0.15/src/struct_frame}/c_gen.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # kate: replace-tabs on; indent-width 4;
 
-from base import version, NamingStyleC, CamelToSnakeCase, pascalCase
+from struct_frame import version, NamingStyleC, CamelToSnakeCase, pascalCase
 import time
 
 StyleC = NamingStyleC()

struct_frame-0.0.13/src/struct-frame/__main__.py → struct_frame-0.0.15/src/struct_frame/generate.py

@@ -2,8 +2,8 @@
 # kate: replace-tabs on; indent-width 4;
 
 
-from c_gen import FileCGen
-from ts_gen import FileTsGen
+from struct_frame import FileCGen
+from struct_frame import FileTsGen
 from proto_schema_parser.parser import Parser
 from proto_schema_parser import ast
 
@@ -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):
@@ -321,11 +323,10 @@ def generateTsFileStrings(path):
         name = path + value.name + ".sf.ts"
         data = ''.join(FileTsGen.generate(value))
         out[name] = data
-
     return out
 
-
 import os
+import shutil
 
 def main():
     args = parser.parse_args()
@@ -337,11 +338,8 @@ 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))
+    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 +349,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.13/src/struct-frame → struct_frame-0.0.15/src/struct_frame}/ts_gen.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # kate: replace-tabs on; indent-width 4;
 
-from base import version, NamingStyleC
+from struct_frame import version, NamingStyleC
 import time
 
 StyleC = NamingStyleC()

struct_frame-0.0.15/tbiostream.sf.ts

@@ -0,0 +1,92 @@
+/* Automatically generated struct frame header */
+/* Generated by 0.0.1 at Sat Feb  8 11:47:03 2025. */
+
+const typed_struct = require('typed-struct')
+const ExtractType = typeof typed_struct.ExtractType;
+const type = typeof typed_struct.ExtractType;
+
+import { struct_frame_buffer } from './struct_frame_types';
+import { msg_encode, msg_reserve, msg_finish } from './struct_frame';
+
+/* Enum definitions */
+export enum biostreamadc_sampling_frequency {
+    FREQ_1000 = 0,
+    FREQ_2000 = 1,
+    FREQ_4000 = 2,
+    FREQ_8000 = 3,
+    FREQ_16000 = 4
+}
+
+//enum before comment
+export enum biostreamtrans_impedance_gain {
+    R_10 = 0,
+    R_100 = 1,
+    R_1K = 2,
+//Enum inside comment
+    R_10K = 3
+}
+
+/* Struct definitions */
+export const biostream_raw_data_t = new typed_struct.Struct('biostream_raw_data_t') 
+    .Float32LE('ref_v')
+    .Float32LE('drn_c')
+    .Float32LE('src_v')
+    .Float32LE('drn_v')
+    .Float32LE('gte_v')
+    .Float32LE('phs_v')
+    .Float32LE('gte_c')
+    .Float32LE('temp')
+    .Float32LE('time')
+    .compile();
+
+export const biostream_raw_data_t_max_size = 36;
+export const RawData_msgid = 1
+export function RawData_encode(buffer: struct_frame_buffer, msg: any) {
+    msg_encode(buffer, msg, RawData_msgid)
+}
+export function RawData_reserve(buffer: struct_frame_buffer) {
+    const msg_buffer = msg_reserve(buffer, RawData_msgid, RawData_max_size);
+    if (msg_buffer){
+        return new RawData(msg_buffer)
+    }
+    return;
+}
+export function RawData_finish(buffer: struct_frame_buffer) {
+    msg_finish(buffer);
+}
+
+
+export const biostream_adc_command_t = new typed_struct.Struct('biostream_adc_command_t') 
+    .Boolean8('enable')
+    .biostream_adc_sampling_frequency('samplig_freq')
+    .biostream_uint8('over_sampling_rate')
+    .biostream_trans_impedance_gain('drain_res')
+    .biostream_trans_impedance_gain('gate_res')
+    .compile();
+
+export const biostream_adc_command_t_max_size = 5;
+export const AdcCommand_msgid = 112
+export function AdcCommand_encode(buffer: struct_frame_buffer, msg: any) {
+    msg_encode(buffer, msg, AdcCommand_msgid)
+}
+export function AdcCommand_reserve(buffer: struct_frame_buffer) {
+    const msg_buffer = msg_reserve(buffer, AdcCommand_msgid, AdcCommand_max_size);
+    if (msg_buffer){
+        return new AdcCommand(msg_buffer)
+    }
+    return;
+}
+export function AdcCommand_finish(buffer: struct_frame_buffer) {
+    msg_finish(buffer);
+}
+
+
+
+export function get_message_length(msg_id : number){
+ switch (msg_id)
+ {
+  case raw_data_t_msgid: return raw_data_t_max_size;
+  case adc_command_t_msgid: return adc_command_t_max_size;
+  default: break;
+ } return 0;
+}

struct_frame-0.0.15/tester/biostream.sf.h

@@ -0,0 +1,68 @@
+/* Automatically generated struct frame header */
+/* Generated by 0.0.1 at Sat Feb  8 11:54:37 2025. */
+
+#pragma once
+#pragma pack(1)
+#include "struct_frame.h"
+/* Enum definitions */
+typedef enum BiostreamAdcSamplingFrequency {
+    ADC_SAMPLING_FREQUENCY_FREQ_1000 = 0,
+    ADC_SAMPLING_FREQUENCY_FREQ_2000 = 1,
+    ADC_SAMPLING_FREQUENCY_FREQ_4000 = 2,
+    ADC_SAMPLING_FREQUENCY_FREQ_8000 = 3,
+    ADC_SAMPLING_FREQUENCY_FREQ_16000 = 4
+} BiostreamAdcSamplingFrequency;
+typedef uint8_t BiostreamAdcSamplingFrequency_t;
+
+//enum before comment
+typedef enum BiostreamTransImpedanceGain {
+    TRANS_IMPEDANCE_GAIN_R_10 = 0,
+    TRANS_IMPEDANCE_GAIN_R_100 = 1,
+    TRANS_IMPEDANCE_GAIN_R_1K = 2,
+//Enum inside comment
+    TRANS_IMPEDANCE_GAIN_R_10K = 3
+} BiostreamTransImpedanceGain;
+typedef uint8_t BiostreamTransImpedanceGain_t;
+
+/* Struct definitions */
+typedef struct BiostreamRawdata {
+    float refV;
+    float drnC;
+    float srcV;
+    float drnV;
+    float gteV;
+    float phsV;
+    float gteC;
+    float temp;
+    float time;
+} BiostreamRawdata;
+
+#define BIOSTREAM_RAW_DATA_MAX_SIZE 36;
+#define BIOSTREAM_RAW_DATA_MSG_ID 1
+MESSAGE_HELPER(biostream_raw_data, BiostreamRawdata, 36, 1);
+
+
+
+typedef struct BiostreamAdccommand {
+    bool enable;
+    BiostreamAdcSamplingFrequency_t sampligFreq;
+    uint8_t overSamplingRate;
+    BiostreamTransImpedanceGain_t drainRes;
+    BiostreamTransImpedanceGain_t gateRes;
+} BiostreamAdccommand;
+
+#define BIOSTREAM_ADC_COMMAND_MAX_SIZE 5;
+#define BIOSTREAM_ADC_COMMAND_MSG_ID 112
+MESSAGE_HELPER(biostream_adc_command, BiostreamAdccommand, 5, 112);
+
+
+
+
+uint8_t get_message_length(uint8_t msg_id){
+ switch (msg_id)
+ {
+  case BIOSTREAM_RAW_DATA_MSG_ID: return BIOSTREAM_RAW_DATA_MAX_SIZE;
+  case BIOSTREAM_ADC_COMMAND_MSG_ID: return BIOSTREAM_ADC_COMMAND_MAX_SIZE;
+  default: break;
+ } return 0;
+}

{struct_frame-0.0.13/ts → struct_frame-0.0.15/tester}/biostream.sf.ts

@@ -1,5 +1,5 @@
 /* Automatically generated struct frame header */
-/* Generated by 0.0.1 at Sat Feb  8 11:10:26 2025. */
+/* Generated by 0.0.1 at Sat Feb  8 11:54:37 2025. */
 
 const typed_struct = require('typed-struct')
 const ExtractType = typeof typed_struct.ExtractType;

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

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

struct_frame-0.0.15/tester/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.15/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.15/tester/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.15/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.15/tester/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-0.0.15/ts/biostream.sf.ts

@@ -0,0 +1,92 @@
+/* Automatically generated struct frame header */
+/* Generated by 0.0.1 at Sat Feb  8 11:45:44 2025. */
+
+const typed_struct = require('typed-struct')
+const ExtractType = typeof typed_struct.ExtractType;
+const type = typeof typed_struct.ExtractType;
+
+import { struct_frame_buffer } from './struct_frame_types';
+import { msg_encode, msg_reserve, msg_finish } from './struct_frame';
+
+/* Enum definitions */
+export enum biostreamadc_sampling_frequency {
+    FREQ_1000 = 0,
+    FREQ_2000 = 1,
+    FREQ_4000 = 2,
+    FREQ_8000 = 3,
+    FREQ_16000 = 4
+}
+
+//enum before comment
+export enum biostreamtrans_impedance_gain {
+    R_10 = 0,
+    R_100 = 1,
+    R_1K = 2,
+//Enum inside comment
+    R_10K = 3
+}
+
+/* Struct definitions */
+export const biostream_raw_data_t = new typed_struct.Struct('biostream_raw_data_t') 
+    .Float32LE('ref_v')
+    .Float32LE('drn_c')
+    .Float32LE('src_v')
+    .Float32LE('drn_v')
+    .Float32LE('gte_v')
+    .Float32LE('phs_v')
+    .Float32LE('gte_c')
+    .Float32LE('temp')
+    .Float32LE('time')
+    .compile();
+
+export const biostream_raw_data_t_max_size = 36;
+export const RawData_msgid = 1
+export function RawData_encode(buffer: struct_frame_buffer, msg: any) {
+    msg_encode(buffer, msg, RawData_msgid)
+}
+export function RawData_reserve(buffer: struct_frame_buffer) {
+    const msg_buffer = msg_reserve(buffer, RawData_msgid, RawData_max_size);
+    if (msg_buffer){
+        return new RawData(msg_buffer)
+    }
+    return;
+}
+export function RawData_finish(buffer: struct_frame_buffer) {
+    msg_finish(buffer);
+}
+
+
+export const biostream_adc_command_t = new typed_struct.Struct('biostream_adc_command_t') 
+    .Boolean8('enable')
+    .biostream_adc_sampling_frequency('samplig_freq')
+    .biostream_uint8('over_sampling_rate')
+    .biostream_trans_impedance_gain('drain_res')
+    .biostream_trans_impedance_gain('gate_res')
+    .compile();
+
+export const biostream_adc_command_t_max_size = 5;
+export const AdcCommand_msgid = 112
+export function AdcCommand_encode(buffer: struct_frame_buffer, msg: any) {
+    msg_encode(buffer, msg, AdcCommand_msgid)
+}
+export function AdcCommand_reserve(buffer: struct_frame_buffer) {
+    const msg_buffer = msg_reserve(buffer, AdcCommand_msgid, AdcCommand_max_size);
+    if (msg_buffer){
+        return new AdcCommand(msg_buffer)
+    }
+    return;
+}
+export function AdcCommand_finish(buffer: struct_frame_buffer) {
+    msg_finish(buffer);
+}
+
+
+
+export function get_message_length(msg_id : number){
+ switch (msg_id)
+ {
+  case raw_data_t_msgid: return raw_data_t_max_size;
+  case adc_command_t_msgid: return adc_command_t_max_size;
+  default: break;
+ } return 0;
+}

struct_frame-0.0.13/src/struct-frame/__init__.py

@@ -1,6 +0,0 @@
-from base import version, NamingStyleC, CamelToSnakeCase, pascalCase
-
-from c_gen import FileCGen
-from ts_gen import FileTsGen
-
-__all__ = ["FileCGen", "FileTsGen", "version", "NamingStyleC", "CamelToSnakeCase", "pascalCase"]