struct-frame 0.0.31__tar.gz → 0.0.42__tar.gz

{struct_frame-0.0.31 → struct_frame-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: struct-frame
-Version: 0.0.31
+Version: 0.0.42
 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.31 → struct_frame-0.0.42}/pyproject.toml

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

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame.h

@@ -0,0 +1,72 @@
+#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 = {0};
+
+  for (int i = 0; i < data_length; i++) {
+    checksum.byte1 += buffer[i];
+    checksum.byte2 += checksum.byte1;
+  }
+  return checksum;
+}
+
+static inline bool msg_encode(msg_encode_buffer* buffer, packet_format_t* format, void* msg, uint8_t msg_id,
+                              uint8_t msg_size) {
+  if (buffer->in_progress) {
+    return false;
+  }
+  buffer->in_progress = true;
+  buffer->size += format->encode(buffer->data, msg_id, (uint8_t*)msg, msg_size);
+  buffer->in_progress = false;
+  return true;
+}
+
+static inline uint8_t* msg_reserve(msg_encode_buffer* buffer, packet_format_t* format, uint8_t msg_id,
+                                   uint8_t msg_size) {
+  if (buffer->in_progress) {
+    return NULL;
+  }
+  buffer->in_progress = true;
+  uint8_t* out = format->encode_reserve(buffer->data, msg_id, msg_size);
+  return out;
+}
+
+static inline bool msg_finish(msg_encode_buffer* buffer, packet_format_t* format, uint8_t msg_size) {
+  if (buffer->in_progress == false) {
+    return false;
+  }
+
+  buffer->size += format->encode_finsish(buffer->data, msg_size);
+  buffer->in_progress = false;
+  return true;
+}
+
+#define MESSAGE_HELPER(funcname, name, msg_size, msg_id)                                                       \
+  static inline bool funcname##_encode(msg_encode_buffer* buffer, packet_format_t* format, name* name##_obj) { \
+    return msg_encode(buffer, format, name##_obj, msg_id, msg_size);                                           \
+  }                                                                                                            \
+  static inline bool funcname##_reserve(msg_encode_buffer* buffer, packet_format_t* format, name** msg) {      \
+    void* ptr = msg_reserve(buffer, format, msg_id, msg_size);                                                 \
+    if (ptr) {                                                                                                 \
+      *msg = (name*)ptr;                                                                                       \
+      return true;                                                                                             \
+    }                                                                                                          \
+    return false;                                                                                              \
+  }                                                                                                            \
+  static inline bool funcname##_finish(msg_encode_buffer* buffer, packet_format_t* format) {                   \
+    return msg_finish(buffer, format, msg_size);                                                               \
+  }                                                                                                            \
+  static inline name funcname##_get_from_buffer(uint8_t* buffer) {                                             \
+    name msg = *(name*)(buffer);                                                                               \
+    return msg;                                                                                                \
+  }                                                                                                            \
+  static inline name funcname##_get(msg_info_t result) {                                                       \
+    name msg = *(name*)(result.msg_loc);                                                                       \
+    return msg;                                                                                                \
+  }                                                                                                            \
+  static inline name* funcname##_get_ref_from_buffer(uint8_t* buffer) { return (name*)(buffer); }              \
+  static inline name* funcname##_get_ref(msg_info_t result) { return (name*)(result.msg_loc); }

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame_cpp.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "struct_frame_parser.h"
+#include "struct_frame_types.h"
+
+class StructFrameDevice : public msg_encode_buffer {
+ public:
+  StructFrameDevice(packet_format_t formats[], packet_definitions_t defines[])
+      : msg_encode_buffer{0, 0, 0},
+        packet_state_{LOOKING_FOR_START_BYTE, 0, formats, defines, nullptr, 0, 0, 0, false, 0} {}
+
+  void RunRx() {
+    GetArray(packet_state_.buffer, packet_state_.buffer_size);
+    if (packet_state_.buffer && packet_state_.buffer_size) {
+      while (!packet_state_.finished) {
+        msg_info_t info = parse_buffer(&packet_state_);
+        if (info.valid) {
+          HandleResult(info);
+        }
+      }
+    }
+  }
+
+  void RunTx() { PutArray(msg_encode_buffer::data, msg_encode_buffer::max_size, msg_encode_buffer::size); }
+
+ protected:
+  void Init() {
+    size_t dummy = 0;
+    PutArray(msg_encode_buffer::data, msg_encode_buffer::max_size, dummy);
+  }
+
+  // Put Array must accept the full buffer of data and returns a pointer to either a new buffer or the same buffer
+  // that is free
+  virtual void PutArray(uint8_t *&buffer, size_t &max_length, size_t &length) = 0;
+
+  // Get array, a pointer to an array and refernce to the array length is pased and mutated by this function
+  virtual void GetArray(uint8_t *&buffer, size_t &length) = 0;
+
+  virtual void HandleResult(msg_info_t info) = 0;
+  packet_state_t packet_state_;
+};

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame_default_frame.h

@@ -0,0 +1,59 @@
+#pragma once
+#include "stdint.h"
+#include "struct_frame.h"
+#include "struct_frame_parser.h"
+#include "struct_frame_types.h"
+
+#define BASIC_FRAME_HEADER_LENGTH 2
+#define BASIC_FRAME_FOOTER_LENGTH 2
+
+bool basic_frame_check_start_bytes(uint8_t c) { return c == 0x90; }
+
+bool basic_frame_process_header_byte(uint8_t c, size_t length) { return length >= BASIC_FRAME_HEADER_LENGTH; }
+
+size_t basic_frame_get_msg_id(uint8_t* data) { return data[1]; }
+
+size_t basic_frame_get_full_packet_length(size_t msg_length) {
+  return msg_length + BASIC_FRAME_HEADER_LENGTH + BASIC_FRAME_FOOTER_LENGTH;
+}
+
+msg_info_t basic_frame_validate_packet(uint8_t* data, size_t packet_length) {
+  size_t msg_size = packet_length - BASIC_FRAME_HEADER_LENGTH - BASIC_FRAME_FOOTER_LENGTH;
+  checksum_t ck = fletcher_checksum_calculation(data + 1, msg_size + 1);
+
+  msg_info_t info = {false, (uint8_t)msg_size, data[1], data + 2};
+  if (ck.byte1 == data[packet_length - 2] && ck.byte2 == data[packet_length - 1]) {
+    info.valid = true;
+  }
+  return info;
+};
+
+uint8_t basic_frame_finish(uint8_t* buffer, uint8_t msg_size) {
+  checksum_t ck = fletcher_checksum_calculation(buffer + 1, msg_size + 1);
+
+  buffer[msg_size + BASIC_FRAME_HEADER_LENGTH] = ck.byte1;
+  buffer[msg_size + BASIC_FRAME_HEADER_LENGTH + 1] = ck.byte2;
+  return msg_size + BASIC_FRAME_HEADER_LENGTH + BASIC_FRAME_FOOTER_LENGTH;
+}
+
+size_t basic_frame_encode(uint8_t* buffer, uint8_t msg_id, uint8_t* msg, uint8_t msg_size) {
+  buffer[0] = 0x90;
+  buffer[1] = msg_id;
+  memcpy(buffer + 2, msg, msg_size);
+  return basic_frame_finish(buffer, msg_size);
+}
+
+uint8_t* basic_frame_reserve(uint8_t* buffer, uint8_t msg_id, uint8_t msg_size) {
+  buffer[0] = 0x90;
+  buffer[1] = msg_id;
+  return buffer + 2;
+}
+
+static packet_format_t default_frame_format = {.check_start_bytes = basic_frame_check_start_bytes,
+                                               .process_header_byte = basic_frame_process_header_byte,
+                                               .get_msg_id = basic_frame_get_msg_id,
+                                               .get_full_packet_length = basic_frame_get_full_packet_length,
+                                               .validate_packet = basic_frame_validate_packet,
+                                               .encode = basic_frame_encode,
+                                               .encode_reserve = basic_frame_reserve,
+                                               .encode_finsish = basic_frame_finish};

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame_gen.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// bool getMessageLength(size_t id, size_t *length) {
+//   *length = 10;
+//   return false;
+// }
+//
+// packet_format_t packetFormats[10];
+//
+// packet_format_t *getPacketFormat(packet_format_t *formats, size_t formats_length, uint8_t c) {
+//   for (int i = 0; i++; i < formats_length) {
+//     if (formats[i].check_start_bytes(c)) {
+//       return &formats[i];
+//     }
+//   }
+//   return NULL;
+// }

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame_parser.h

@@ -0,0 +1,107 @@
+#pragma once
+#include "stdint.h"
+#include "struct_frame_types.h"
+
+// https://github.com/serge-sans-paille/frozen
+
+static inline msg_info_t parse_buffer(packet_state_t *packet_state) {
+  packet_state->state = LOOKING_FOR_START_BYTE;
+  packet_state->finished = false;
+  for (size_t i = packet_state->r_loc; i < packet_state->buffer_size; i++) {
+    uint8_t c = packet_state->buffer[i];
+    switch (packet_state->state) {
+      case LOOKING_FOR_START_BYTE:
+        packet_state->format = packet_state->defines->get_packet_formats(c);
+        if (packet_state->format) {
+          packet_state->packet_start_index = i;
+          if (packet_state->format->process_header_byte(c, true)) {
+            packet_state->state = GETTING_PAYLOAD;
+          } else {
+            packet_state->state = GETTING_HEADER;
+          }
+        }
+        break;
+
+      case GETTING_HEADER:
+        if (packet_state->format->process_header_byte(c, false)) {
+          size_t msg_id = packet_state->format->get_msg_id(packet_state->buffer + packet_state->packet_start_index);
+          size_t length = 0;
+          if (packet_state->defines->get_message_length(msg_id, &length)) {
+            packet_state->packet_size = packet_state->format->get_full_packet_length(length);
+            packet_state->state = GETTING_PAYLOAD;
+          } else {
+            packet_state->state = LOOKING_FOR_START_BYTE;
+          }
+        }
+        break;
+
+      case GETTING_PAYLOAD:
+        if ((packet_state->packet_start_index + packet_state->packet_size) > packet_state->buffer_size) {
+          packet_state->state = LOOKING_FOR_START_BYTE;
+          msg_info_t info = packet_state->format->validate_packet(
+              packet_state->buffer + packet_state->packet_start_index, packet_state->packet_size);
+          packet_state->r_loc += i;
+          return info;
+        } else {
+          packet_state->state = LOOKING_FOR_START_BYTE;
+        }
+
+        break;
+
+      default:
+        break;
+    }
+  }
+  packet_state->finished = true;
+  packet_state->r_loc = 0;
+
+  msg_info_t info = {0, 0, 0, 0};
+  return info;
+}
+
+msg_info_t parse_char(packet_state_t *state, const uint8_t c) {
+  state->buffer[state->buffer_size] = c;
+  state->buffer_size = (state->buffer_size + 1) % state->buffer_max_size;
+
+  switch (state->state) {
+    case LOOKING_FOR_START_BYTE:;
+      state->format = state->defines->get_packet_formats(c);
+      if (state->format) {
+        state->buffer[0] = state->buffer[state->buffer_size];
+        state->buffer_size = 0;
+        if (state->format->process_header_byte(c, true)) {
+          state->state = GETTING_PAYLOAD;
+        } else {
+          state->state = GETTING_HEADER;
+        }
+      }
+      break;
+
+    case GETTING_HEADER:
+      if (state->format->process_header_byte(c, false)) {
+        size_t msg_id = state->format->get_msg_id(state->buffer);
+        size_t length = 0;
+        if (state->defines->get_message_length(msg_id, &length)) {
+          state->packet_size = state->format->get_full_packet_length(length);
+          state->state = GETTING_PAYLOAD;
+        } else {
+          state->state = LOOKING_FOR_START_BYTE;
+        }
+      }
+      break;
+
+    case GETTING_PAYLOAD:
+      if (state->buffer_size >= state->packet_size) {
+        state->state = LOOKING_FOR_START_BYTE;
+        msg_info_t info = state->format->validate_packet(state->buffer, state->buffer_size);
+        return info;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  msg_info_t info = {0, 0, 0, 0};
+  return info;
+}

struct_frame-0.0.42/src/struct_frame/boilerplate/c/struct_frame_types.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include "stdbool.h"
+#include "stdint.h"
+
+// https://github.com/serge-sans-paille/frozen
+// https://www.npmjs.com/package/typed-struct
+
+// #define default_parser {1, 0, 0x90}
+//
+// #define zero_initialized_parser_result {default_parser, 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;
+
+typedef struct msg_info_t {
+  bool valid;
+  uint8_t len;
+  uint8_t msg_id;
+  uint8_t *msg_loc;
+} msg_info_t;
+
+typedef struct _packet_format {
+  bool (*check_start_bytes)(uint8_t);
+  bool (*process_header_byte)(uint8_t, size_t);
+  size_t (*get_msg_id)(uint8_t *data);
+  size_t (*get_full_packet_length)(size_t);
+  struct msg_info_t (*validate_packet)(uint8_t *, size_t);
+  size_t (*encode)(uint8_t *buffer, uint8_t msg_id, uint8_t *msg, uint8_t msg_size);
+  uint8_t *(*encode_reserve)(uint8_t *buffer, uint8_t msg_id, uint8_t msg_size);
+  uint8_t (*encode_finsish)(uint8_t *buffer, uint8_t msg_size);
+
+} packet_format_t;
+
+enum parser_state_enum { LOOKING_FOR_START_BYTE = 0, GETTING_HEADER = 1, GETTING_PAYLOAD = 2 };
+
+typedef struct _definitions {
+  bool (*get_message_length)(size_t, size_t *);
+  packet_format_t *(*get_packet_formats)(uint8_t);
+} packet_definitions_t;
+
+typedef struct packet_state_t {
+  enum parser_state_enum state;
+  size_t packet_size;
+  packet_format_t *format;
+  packet_definitions_t *defines;
+
+  uint8_t *buffer;
+  size_t buffer_size;
+
+  // for parse buffer
+  size_t buffer_max_size;
+  size_t packet_start_index;
+  bool finished;
+  size_t r_loc;
+} packet_state_t;
+
+typedef struct _msg_encode_buffer {
+  uint8_t *data;
+  size_t max_size;
+  size_t size;
+  bool in_progress;
+} msg_encode_buffer;
+
+typedef struct _struct_frame_parse_char_impl {
+  // Used for framing and parsing
+  packet_format_t packet_format;
+  packet_state_t parser_state;
+
+} struct_frame_parse_char_impl;

struct_frame-0.0.42/src/struct_frame/boilerplate/py/struct_frame_parser.py

@@ -0,0 +1,119 @@
+
+from enum import Enum
+
+
+def fletcher_checksum_calculation(buffer, start=0, end=None):
+    if end == None:
+        end = len(buffer)
+
+    byte1 = 0
+    byte2 = 0
+
+    for x in range(start, end):
+        byte1 = (byte1 + buffer[x]) % 256
+        byte2 = (byte2 + byte1) % 256
+
+    return [byte1, byte2]
+
+
+class BasicPacket:
+    start_byte = 0x90
+    header_length = 0
+    footer_length = 0
+
+    desired_packet_length = 0
+    packet = []
+
+    def __init__(self, start_byte=0x90, header_length=2, footer_length=2):
+        self.start_byte = start_byte
+        self.header_length = header_length
+        self.footer_length = footer_length
+
+    def add_header_byte(self, byte, clear=False):
+        if clear:
+            self.packet.clear()
+        self.packet.append(byte)
+        return len(self.packet) >= self.header_length
+
+    def add_packet_byte(self, byte):
+        self.packet.append(byte)
+        return len(self.packet) == self.desired_packet_length
+
+    def get_msg_id(self):
+        return self.packet[1]
+
+    def get_full_packet_length(self, msg_length):
+        self.desired_packet_length = self.header_length + self.footer_length + msg_length
+        return self.desired_packet_length
+
+    def validate_packet(self):
+        checksum = fletcher_checksum_calculation(
+            self.packet, self.header_length - 1, self.desired_packet_length - self.footer_length)
+        return checksum[0] == self.packet[-2] and checksum[1] == self.packet[-1]
+
+    def get_msg_buffer(self):
+        return self.packet[self.header_length:self.desired_packet_length - self.footer_length]
+
+    def encode_msg(self, msg):
+        return self.encode(msg.pack(), msg.msg_id)
+
+    def encode(self, data, msg_id):
+        output = []
+        output.append(self.start_byte)
+        output.append(msg_id)
+        if (len(data)):
+            for b in data:
+                output.append(b)
+        checksum = fletcher_checksum_calculation(data)
+
+        output.append(checksum[0])
+        output.append(checksum[1])
+        return output
+
+
+class ParserState(Enum):
+    LOOKING_FOR_START_BYTE = 0
+    GETTING_HEADER = 1
+    GETTING_PACKET = 2
+
+
+class FrameParser:
+    state = ParserState.LOOKING_FOR_START_BYTE
+    buffer = []
+    packetFormat = None
+    msg_definitions = None
+    msg_id_loc = None
+    msg_type = None
+
+    def __init__(self, packetFormats, msg_definitions):
+        self.packetFormats = packetFormats
+        self.msg_definitions = msg_definitions
+
+    def parse_char(self, c):
+        if self.state == ParserState.LOOKING_FOR_START_BYTE:
+            if c in self.packetFormats:
+                self.packetFormat = self.packetFormats[c]
+                if self.packetFormat.add_header_byte(c, True):
+                    self.state = ParserState.GETTING_PACKET
+                else:
+                    self.state = ParserState.GETTING_HEADER
+
+        elif self.state == ParserState.GETTING_HEADER:
+            if self.packetFormat.add_header_byte(c):
+                msg_id = self.packetFormat.get_msg_id()
+                if msg_id in self.msg_definitions:
+                    self.msg_type = self.msg_definitions[msg_id]
+                    if self.msg_type:
+                        self.packetFormat.get_full_packet_length(
+                            self.msg_type.msg_size)
+                        self.state = ParserState.GETTING_PACKET
+                    else:
+                        self.state = ParserState.LOOKING_FOR_START_BYTE
+
+        elif self.state == ParserState.GETTING_PACKET:
+            if self.packetFormat.add_packet_byte(c):
+                self.state = ParserState.LOOKING_FOR_START_BYTE
+                if self.packetFormat.validate_packet():
+                    return self.msg_type.create_unpack(bytes(self.packetFormat.get_msg_buffer()))
+
+        return False

struct_frame-0.0.42/src/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-0.0.42/src/struct_frame/boilerplate/ts/struct_frame_gen.ts

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

struct_frame-0.0.42/src/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-0.0.42/src/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;
+}