bsm 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7267b067dccaa3052d254696bbd5071b6a65a6bbf3bcab98bdecba5bc717dbdd
-  data.tar.gz: 7b0f6874144a06c0a8a8240a6b854edb046f68cf7dff8086460c7124ba6b98af
+  metadata.gz: 0f86f5bdcd9b98750e22cff1c56e95f64f45e4bd89daaedc11fccfffb5657bf4
+  data.tar.gz: 966a4663e01a1d395110583be23eec8a89936e9b6bbc13114cf516b98372728c
 SHA512:
-  metadata.gz: 4d89405622e5bd6829c86e1e021b3191d974f09c7f4d3c35e34d42479b5b6094178f1de67da63c2dea6cf0e847988f27e1bd896f97bf106a20843d64558b7a08
-  data.tar.gz: 83d68e3f8b5312cb0bcdc4b3d95f916de59c54d9f17bf478aa9cf6fbd364b1b9780d612c1db67f8e267edc4478cc292275a80a71a535efd241405cc98d577b54
+  metadata.gz: e0012606b0e0ec82f03fbe23cda9b73d856746def0863290b72e62bdb493414b3ceb3d652ca8c9979dcc3cf9aa080d60b02568039fdc40a0af04f72b684156d1
+  data.tar.gz: 4921666d0a125c739bcd5f13bc85190200f41feaa7de7712626312ce545465f0874d0703c94e24fff634ee498e3336b8a7f0e0b3499c2b2ddaaf402752ae185a

data/Gemfile

@@ -1,6 +1,18 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bsm.gemspec
 gemspec
 
-gem 'markspec', path: '/Users/davidsiaw/work/markspec'
+# Specify development dependencies here and not in the gemspec
+gem 'markspec'
+gem 'rake'
+gem 'rake-compiler'
+gem 'rspec'
+gem 'rubocop'
+gem 'rubocop-rake'
+gem 'rubocop-rspec'
+gem 'rubocop-yard'
+gem 'yard'
+gem 'yard-rspec'

data/bsm.gemspec

@@ -1,37 +1,38 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'bsm/version'
+# frozen_string_literal: true
+
+require_relative 'lib/bsm/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'bsm'
   spec.version       = Bsm::VERSION
   spec.authors       = ['David Siaw']
-  spec.email         = ['dsiaw@degica.com']
+  spec.email         = ['874280+davidsiaw@users.noreply.github.com']
 
-  spec.summary       = 'a short summary'
-  spec.description   = 'a longer description'
-  spec.homepage      = 'https://github.org/davidsiaw/bsm'
+  spec.summary       = 'Write binary files in a human-readable way'
+  spec.description   = 'Bsm converts literate text (semicolon-prefixed lines of hex, ' \
+                       'strings, bitfields) into binary. Backed by the native bsm2 library.'
+  spec.homepage      = 'https://github.com/davidsiaw/bsm'
   spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0')
 
-  if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
 
-    spec.metadata['homepage_uri'] = spec.homepage
-    spec.metadata['source_code_uri'] = 'https://github.org/davidsiaw/bsm'
-    spec.metadata['changelog_uri'] = 'https://github.org/davidsiaw/bsm'
-  else
-    raise 'RubyGems 2.0 or newer is required to protect against ' \
-      'public gem pushes.'
-  end
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/davidsiaw/bsm'
+  spec.metadata['changelog_uri'] = 'https://github.com/davidsiaw/bsm'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
-  spec.files         = Dir['{exe,lib}/**/*'] + %w[Gemfile bsm.gemspec]
+  # bsm2 is vendored as a git submodule and built from source at install time
+  # by ext/bsm/internal/extconf.rb. Ship the source + build files so the gem
+  # is self-contained. Exclude ext build artifacts (mkmf output) from the gem.
+  spec.files = (Dir['{exe,lib,ext}/**/*'] +
+               Dir['bsm2/src/**/*'] +
+               %w[Gemfile bsm.gemspec bsm2/Makefile]).reject do |f|
+    f =~ %r{^ext/.*\.(o|so|bundle)$} ||
+      f =~ %r{^ext/.*/(Makefile|mkmf\.log)$}
+  end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
   spec.extensions    = %w[ext/bsm/internal/extconf.rb]
-
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rake-compiler'
-  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/bsm2/Makefile

@@ -0,0 +1,104 @@
+SRC_DIR := src
+BSMSRC_DIR := src/bsm2
+MSBSRC_DIR := src/msb2
+OBJ_DIR := obj
+BSMOBJ_DIR := obj/bsm2
+MSBOBJ_DIR := obj/msb2
+LIB_DIR := lib
+BIN_DIR := bin
+
+EXE := $(BIN_DIR)/bsm2
+MSBEXE := $(BIN_DIR)/msb2
+LIB := $(LIB_DIR)/libbsm2.a
+CAPITEST := $(BIN_DIR)/c_api_test
+EMPTYTEST := $(BIN_DIR)/empty_out_test
+
+# Library sources (top-level src/*.cpp) — no main, no I/O
+LIB_SRC := $(wildcard $(SRC_DIR)/*.cpp)
+LIB_OBJ := $(patsubst $(SRC_DIR)/%.cpp, $(OBJ_DIR)/%.o, $(LIB_SRC))
+
+# bsm2 executable main
+BSMSRC := $(wildcard $(BSMSRC_DIR)/*.cpp)
+BSMOBJ := $(patsubst $(BSMSRC_DIR)/%.cpp, $(BSMOBJ_DIR)/%.o, $(BSMSRC))
+
+# msb2 executable (standalone, no lib dependency)
+MSBSRC := $(wildcard $(MSBSRC_DIR)/*.cpp)
+MSBOBJ := $(patsubst $(MSBSRC_DIR)/%.cpp, $(MSBOBJ_DIR)/%.o, $(MSBSRC))
+
+CPPFLAGS := -Isrc -MMD -MP -std=c++17
+CFLAGS   := -Wall -Wpedantic -fPIC
+LDFLAGS  :=
+LDLIBS   :=
+
+PREFIX  ?= /usr/local
+BINDIR  ?= $(PREFIX)/bin
+INSTALL ?= install
+
+all: $(EXE) $(MSBEXE)
+
+libbsm2: $(LIB)
+
+$(LIB): $(LIB_OBJ) | $(LIB_DIR)
+	$(AR) rcs $@ $^
+
+# bsm2: main.o linked against libbsm2
+$(EXE): $(BSMOBJ) $(LIB) | $(BIN_DIR)
+	$(CXX) $(LDFLAGS) $(BSMOBJ) -L$(LIB_DIR) -lbsm2 $(LDLIBS) -o $@
+
+# msb2: standalone, does not use libbsm2
+$(MSBEXE): $(MSBOBJ) | $(BIN_DIR)
+	$(CXX) $(LDFLAGS) $^ $(LDLIBS) -o $@
+
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp | $(OBJ_DIR)
+	$(CXX) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
+
+$(BSMOBJ_DIR)/%.o: $(BSMSRC_DIR)/%.cpp | $(BSMOBJ_DIR)
+	$(CXX) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
+
+$(MSBOBJ_DIR)/%.o: $(MSBSRC_DIR)/%.cpp | $(MSBOBJ_DIR)
+	$(CXX) $(CPPFLAGS) $(CFLAGS) -c $< -o $@
+
+$(BIN_DIR) $(OBJ_DIR) $(BSMOBJ_DIR) $(MSBOBJ_DIR) $(LIB_DIR):
+	mkdir -p $@
+
+.PHONY: clean format test test-c-api memtest install uninstall libbsm2
+
+install: all
+	$(INSTALL) -d $(DESTDIR)$(BINDIR)
+	$(INSTALL) -m 755 $(EXE) $(DESTDIR)$(BINDIR)/bsm2
+	$(INSTALL) -m 755 $(MSBEXE) $(DESTDIR)$(BINDIR)/msb2
+
+uninstall:
+	$(RM) $(DESTDIR)$(BINDIR)/bsm2 $(DESTDIR)$(BINDIR)/msb2
+
+# C tests: C sources linked against libbsm2 (g++ driver for libstdc++)
+# Built with -g -O0 so valgrind reports are meaningful.
+$(CAPITEST): test/c_api_test.c $(LIB) | $(BIN_DIR)
+	$(CC) -Isrc -g -O0 -MMD -MP -c $< -o $(OBJ_DIR)/c_api_test.o
+	$(CXX) $(LDFLAGS) $(OBJ_DIR)/c_api_test.o -L$(LIB_DIR) -lbsm2 $(LDLIBS) -o $@
+
+$(EMPTYTEST): test/empty_out_test.c $(LIB) | $(BIN_DIR)
+	$(CC) -Isrc -g -O0 -MMD -MP -c $< -o $(OBJ_DIR)/empty_out_test.o
+	$(CXX) $(LDFLAGS) $(OBJ_DIR)/empty_out_test.o -L$(LIB_DIR) -lbsm2 $(LDLIBS) -o $@
+
+test-c-api: $(CAPITEST) $(EMPTYTEST)
+	./$(CAPITEST)
+	./$(EMPTYTEST)
+
+# Valgrind memory check of the C API tests. Requires valgrind on PATH.
+VALGRIND := valgrind --leak-check=full --show-leak-kinds=all --error-exitcode=99
+
+memtest: $(CAPITEST) $(EMPTYTEST)
+	$(VALGRIND) ./$(CAPITEST)
+	$(VALGRIND) ./$(EMPTYTEST)
+
+test: $(EXE) test-c-api
+	PATH="$(HOME)/.local/share/mise/installs/ruby/3.3.5/bin:$$PATH" markspec
+
+format:
+	uncrustify -c uncrustify.cfg src/*.cpp src/*.h src/bsm2/*.cpp src/msb2/*.cpp --replace --no-backup
+
+clean:
+	@$(RM) -rv $(BIN_DIR) $(OBJ_DIR) $(LIB_DIR)
+
+-include $(LIB_OBJ:.o=.d) $(BSMOBJ:.o=.d) $(MSBOBJ:.o=.d)

data/bsm2/src/bsm2/main.cpp

@@ -0,0 +1,50 @@
+#include "error_info.h"
+#include "processor.h"
+#include <iostream>
+#include <memory>
+#include <string>
+
+static void report_error(ErrorInfo const &e)
+{
+  std::cerr << "BSM: Error at line " << e.line_number << " and column "
+            << e.column << std::endl
+            << "---" << std::endl;
+  std::cerr << e.line_text << std::endl;
+
+  for (unsigned i = 0; i < e.column; i++)
+  {
+    std::cerr << " ";
+  }
+
+  std::cerr << "^";
+
+  for (unsigned i = 0; i < e.char_length; i++)
+  {
+    std::cerr << "~";
+  }
+
+  std::cerr << " " << e.message << std::endl;
+}
+
+int main()
+{
+  std::unique_ptr<Processor> p = std::make_unique<Processor>();
+
+  while (std::cin)
+  {
+    std::string input_line;
+    std::getline(std::cin, input_line);
+
+    ErrorInfo error = {};
+    std::string output = p->lex_line(input_line, &error);
+    std::cout << output;
+
+    if (error.line_number > 0)
+    {
+      report_error(error);
+      return EXIT_FAILURE;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}

data/bsm2/src/c_api.cpp

@@ -0,0 +1,127 @@
+#include "c_api.h"
+#include "error_info.h"
+#include "processor.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <new>
+#include <string>
+
+struct bsm2_processor
+{
+  Processor impl;
+};
+
+struct bsm2_error
+{
+  std::string message;
+  std::string line_text;
+  unsigned line_number;
+  unsigned column;
+  unsigned char_length;
+};
+
+bsm2_processor* bsm2_new(void)
+{
+  bsm2_processor* p =
+    static_cast<bsm2_processor*>(std::malloc(sizeof(bsm2_processor)));
+  if (!p)
+  {
+    return nullptr;
+  }
+  new (&p->impl) Processor();
+  return p;
+}
+
+void bsm2_free(bsm2_processor* p)
+{
+  if (!p)
+  {
+    return;
+  }
+  p->impl.~Processor();
+  std::free(p);
+}
+
+char* bsm2_convert_line(bsm2_processor* p, const char* line, size_t len,
+                        size_t* out_len, bsm2_error** err)
+{
+  if (err)
+  {
+    *err = nullptr;
+  }
+  if (!p || !line)
+  {
+    return nullptr;
+  }
+
+  ErrorInfo info = {};
+  std::string input(line, len);
+  std::string out = p->impl.lex_line(input, &info);
+
+  if (info.line_number > 0)
+  {
+    if (err)
+    {
+      bsm2_error* e = new (std::nothrow) bsm2_error();
+      if (e)
+      {
+        e->message = info.message;
+        e->line_text = info.line_text;
+        e->line_number = info.line_number;
+        e->column = info.column;
+        e->char_length = info.char_length;
+        *err = e;
+      }
+    }
+    return nullptr;
+  }
+
+  size_t n = out.size();
+  if (out_len)
+  {
+    *out_len = n;
+  }
+  // Always hand back a non-NULL buffer on success so callers can distinguish
+  // success-with-empty-output from error (NULL + *err set).
+  char* buf = static_cast<char*>(std::malloc(n ? n : 1));
+  if (!buf)
+  {
+    return nullptr;
+  }
+  if (n)
+  {
+    std::memcpy(buf, out.data(), n);
+  }
+  return buf;
+}
+
+const char* bsm2_error_message(bsm2_error* e)
+{
+  return e ? e->message.c_str() : "";
+}
+
+unsigned bsm2_error_line(bsm2_error* e)
+{
+  return e ? e->line_number : 0;
+}
+
+unsigned bsm2_error_column(bsm2_error* e)
+{
+  return e ? e->column : 0;
+}
+
+unsigned bsm2_error_length(bsm2_error* e)
+{
+  return e ? e->char_length : 0;
+}
+
+const char* bsm2_error_line_text(bsm2_error* e)
+{
+  return e ? e->line_text.c_str() : "";
+}
+
+void bsm2_error_free(bsm2_error* e)
+{
+  delete e;
+}

data/bsm2/src/c_api.h

@@ -0,0 +1,41 @@
+#ifndef BSM2_C_API_H
+#define BSM2_C_API_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Opaque handle: one conversion session. The internal line counter
+ * accumulates across calls, so feed lines in order. */
+typedef struct bsm2_processor bsm2_processor;
+
+/* Opaque error. Heap-allocated by bsm2_convert_line on failure; caller frees
+ * with bsm2_error_free(). Pure data — the caller owns presentation. */
+typedef struct bsm2_error bsm2_error;
+
+bsm2_processor* bsm2_new(void);
+void bsm2_free(bsm2_processor* p);
+
+/* Feed one raw line, including its leading ';' (the ';' convention lives in
+ * the library; non-';' lines are ignored and yield empty output).
+ *
+ * On success: returns a malloc'd buffer of *out_len bytes (caller frees with
+ * free(); always non-NULL even when *out_len == 0). *err is set to NULL.
+ * On error:  returns NULL and sets *err (caller frees with bsm2_error_free()).*/
+char* bsm2_convert_line(bsm2_processor* p, const char* line, size_t len,
+                        size_t* out_len, bsm2_error** err);
+
+const char* bsm2_error_message(bsm2_error* e);
+unsigned bsm2_error_line(bsm2_error* e);
+unsigned bsm2_error_column(bsm2_error* e);
+unsigned bsm2_error_length(bsm2_error* e);
+const char* bsm2_error_line_text(bsm2_error* e);
+void bsm2_error_free(bsm2_error* e);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BSM2_C_API_H */

data/bsm2/src/converter.h

@@ -0,0 +1,58 @@
+#ifndef CONVERTER_H
+#define CONVERTER_H
+
+#include <string>
+#include <sstream>
+
+class Converter
+{
+public:
+  Converter()
+  {
+  }
+
+  ~Converter()
+  {
+  }
+
+  char convert_hexpair(const std::string& yytext)
+  {
+    int chr = stoi(std::string(yytext), nullptr, 16);
+    return static_cast<char>(chr);
+  }
+
+  char convert_quotechar(const std::string& yytext)
+  {
+    return yytext[1];
+  }
+
+  std::string convert_doublequote(const std::string& yytext)
+  {
+    std::stringstream result;
+
+    for (uint i = 1; i < yytext.length() - 1; i++)
+    {
+      result << yytext[i];
+    }
+
+    return result.str();
+  }
+
+  unsigned char convert_bindigits(const std::string& yytext)
+  {
+    unsigned char c = 0;
+
+    for (uint i = 1; i < yytext.length() - 1; i++)
+    {
+      if (yytext[i] == '1')
+      {
+        c += 1 << (8-i);
+      }
+    }
+
+    return c;
+  }
+
+};
+
+#endif // CONVERTER_H

data/bsm2/src/error_info.h

@@ -0,0 +1,15 @@
+#ifndef ERROR_H
+#define ERROR_H
+
+#include <string>
+
+struct ErrorInfo
+{
+  unsigned line_number;
+  unsigned column;
+  unsigned char_length;
+  std::string line_text;
+  std::string message;
+};
+
+#endif // ERROR_H

data/bsm2/src/lexer.cpp

@@ -0,0 +1,276 @@
+#include "lexer.h"
+#include <cctype>
+#include <string>
+
+static char to_char(int c)
+{
+  return static_cast<char>(c);
+}
+
+static char hex_to_byte(char hi, char lo)
+{
+  auto nibble = [](char c) -> int
+                {
+                  if (c >= '0' && c <= '9')
+                    return c - '0';
+
+                  if (c >= 'a' && c <= 'f')
+                    return c - 'a' + 10;
+
+                  if (c >= 'A' && c <= 'F')
+                    return c - 'A' + 10;
+
+                  return -1;
+                };
+  int hi_val = nibble(hi);
+  int lo_val = nibble(lo);
+
+  if (hi_val < 0 || lo_val < 0)
+    return to_char(-1);
+
+  return to_char((hi_val << 4) | lo_val);
+}
+
+static char read_single_char(std::string const &token)
+{
+  return to_char(token[1]);
+}
+
+static std::string read_double_string(std::string const &token)
+{
+  return token.substr(1, token.size() - 2);
+}
+
+static bool is_whitespace(char c)
+{
+  return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+static char read_bitfield(std::string const &token)
+{
+  unsigned char value = 0;
+
+  for (size_t i = 1; i <= 8; i++)
+  {
+    if (token[i] == '1')
+    {
+      value |= (1u << (8 - i));
+    }
+  }
+
+  return to_char(value);
+}
+
+Lexer::Lexer(std::string const &input, unsigned line_number,
+             std::string const &line_text)
+  : input(input), m_pos(0), m_column(1), m_line_number(line_number),
+
+  m_line_text(line_text)
+{
+}
+
+size_t Lexer::pos() const
+{
+  return m_pos;
+}
+
+size_t Lexer::size() const
+{
+  return input.size();
+}
+
+bool Lexer::consume()
+{
+  if (m_pos >= input.size())
+  {
+    return true;
+  }
+
+  m_error_line = m_line_number;
+  m_error_line_text = m_line_text;
+  char c = current_char();
+  return dispatch(c, m_column);
+}
+
+unsigned Lexer::error_line_number() const
+{
+  return m_error_line;
+}
+
+unsigned Lexer::error_column() const
+{
+  return m_error_column;
+}
+
+unsigned Lexer::error_length() const
+{
+  return m_error_length;
+}
+
+std::string const &Lexer::error_line_text() const
+{
+  return m_error_line_text;
+}
+
+std::string const &Lexer::error_message() const
+{
+  return m_error_message;
+}
+
+bool Lexer::fail(unsigned column, unsigned length, std::string const &message)
+{
+  m_error_column = column;
+  m_error_length = length;
+  m_error_message = message;
+  return false;
+}
+
+std::string const &Lexer::result() const
+{
+  return m_result;
+}
+
+char Lexer::current_char() const
+{
+  return input[m_pos];
+}
+
+bool Lexer::dispatch(char c, unsigned error_column)
+{
+  if (is_whitespace(c))
+
+  {
+    skip_whitespace();
+    return true;
+  }
+
+  if (std::isxdigit(c))
+
+  {
+    return consume_hex_pair(error_column);
+  }
+
+  if (c == '\'')
+  {
+    return consume_single_char(error_column);
+  }
+
+  if (c == '"')
+  {
+    return consume_double_string(error_column);
+  }
+
+  if (c == '<')
+  {
+    return consume_bitfield(error_column);
+  }
+
+  return fail(error_column, 1, "unrecognized character");
+}
+
+void Lexer::skip_whitespace()
+{
+  m_pos++;
+  m_column++;
+
+  while (m_pos < input.size())
+  {
+    char c = input[m_pos];
+
+    if (is_whitespace(c))
+
+    {
+      m_pos++;
+      m_column++;
+    }
+
+    else
+    {
+      break;
+    }
+  }
+}
+
+bool Lexer::consume_hex_pair(unsigned error_column)
+{
+  if (m_pos + 1 < input.size() && std::isxdigit(input[m_pos + 1]))
+  {
+    char first = input[m_pos];
+    char second = input[m_pos + 1];
+    m_pos += 2;
+    m_column += 2;
+    m_result += hex_to_byte(first, second);
+    return true;
+  }
+
+  else
+  {
+    return fail(error_column, 1, "hex byte needs two hex digits");
+  }
+}
+
+bool Lexer::consume_single_char(unsigned error_column)
+{
+  if (m_pos + 2 < input.size() && input[m_pos + 2] == '\'')
+  {
+    size_t token_start = m_pos;
+    m_pos += 3;
+    m_column += 3;
+    std::string token(input, token_start, 3);
+
+    m_result += read_single_char(token);
+    return true;
+  }
+
+  else
+  {
+    return fail(error_column, 1,
+                "single quotes must hold exactly one character");
+  }
+}
+
+bool Lexer::consume_double_string(unsigned error_column)
+{
+  size_t token_start = m_pos;
+  size_t close = input.find('"', m_pos + 1);
+
+  if (close == std::string::npos)
+  {
+    return fail(error_column, 1,
+                "string has no closing quote on this line");
+  }
+
+  m_pos = close + 1;
+  m_column += close - token_start + 1;
+  std::string token(input, token_start, close - token_start + 1);
+
+  m_result += read_double_string(token);
+  return true;
+}
+
+bool Lexer::consume_bitfield(unsigned error_column)
+{
+  if (m_pos + 9 >= input.size() || input[m_pos + 9] != '>')
+  {
+    return fail(error_column, 1,
+                "bitfield must be exactly 8 bits closed by '>' on the same line");
+  }
+
+  for (size_t i = 0; i < 8; i++)
+  {
+    char b = input[m_pos + 1 + i];
+
+    if (b != '0' && b != '1' && b != '.')
+    {
+      return fail(error_column + 1 + i, 1, "bitfield bits must be 0, 1, or .");
+    }
+  }
+
+  size_t token_start = m_pos;
+  m_pos += 10;
+  m_column += 10;
+  std::string token(input, token_start, 10);
+
+  m_result += read_bitfield(token);
+  return true;
+}

data/bsm2/src/lexer.h

@@ -0,0 +1,59 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include "error_info.h"
+#include <string>
+
+class Lexer
+{
+  std::string const &input;
+  size_t m_pos;
+  unsigned m_column;
+  unsigned m_error_line;
+  unsigned m_error_column;
+  unsigned m_error_length;
+  std::string m_error_line_text;
+  std::string m_error_message;
+  std::string m_result;
+  unsigned m_line_number;
+  std::string m_line_text;
+
+public:
+  Lexer(std::string const &input, unsigned line_number,
+        std::string const &line_text);
+
+  size_t pos() const;
+
+  size_t size() const;
+
+  bool consume();
+
+  unsigned error_line_number() const;
+
+  unsigned error_column() const;
+
+  unsigned error_length() const;
+
+  std::string const &error_line_text() const;
+  std::string const &error_message() const;
+  std::string const &result() const;
+
+private:
+  char current_char() const;
+
+  bool fail(unsigned column, unsigned length, std::string const &message);
+
+  bool dispatch(char c, unsigned error_column);
+
+  void skip_whitespace();
+
+  bool consume_hex_pair(unsigned error_column);
+
+  bool consume_single_char(unsigned error_column);
+
+  bool consume_double_string(unsigned error_column);
+
+  bool consume_bitfield(unsigned error_column);
+};
+
+#endif // LEXER_H

data/bsm2/src/msb2/README.md

@@ -0,0 +1,2 @@
+# MSB2 convert binary file to bsm2 format
+

data/bsm2/src/msb2/main.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+
+int main()
+{
+  int bytecount = 0;
+
+  std::cout << ";";
+
+  do
+  {
+    unsigned char c = std::cin.get();
+
+    if (!std::cin.good())
+    {
+      break;
+    }
+
+    std::cout << " " << std::setw(2) << std::setfill('0') << std::hex << (int)c;
+    bytecount++;
+
+    if (bytecount % 16 == 0)
+    {
+      std::cout << "\n;";
+    }
+
+    else if (bytecount % 4 == 0)
+    {
+      std::cout << " ";
+    }
+  }
+  while (std::cin.good());
+
+  std::cout << "\nTotal bytes: " << bytecount << std::endl;
+
+  return EXIT_SUCCESS;
+}

data/bsm2/src/processor.cpp

@@ -0,0 +1,31 @@
+#include "processor.h"
+#include "lexer.h"
+#include <string>
+
+std::string Processor::lex_line(std::string const &input, ErrorInfo *out_error)
+{
+  curline++;
+
+  if (input.length() == 0 || input[0] != ';')
+  {
+    return "";
+  }
+
+  std::string const rest = input.substr(1);
+  Lexer l(rest, curline, input);
+
+  while (l.pos() < l.size())
+  {
+    if (!l.consume())
+    {
+      out_error->line_number = l.error_line_number();
+      out_error->column = l.error_column();
+      out_error->char_length = l.error_length();
+      out_error->line_text = l.error_line_text();
+      out_error->message = l.error_message();
+      return "";
+    }
+  }
+
+  return l.result();
+}

data/bsm2/src/processor.h

@@ -0,0 +1,23 @@
+#ifndef PROCESSOR_H
+#define PROCESSOR_H
+
+#include "lexer.h"
+#include <string>
+
+class Processor
+{
+  unsigned curline;
+
+public:
+  Processor() : curline(0)
+  {
+  }
+
+  ~Processor()
+  {
+  }
+
+  std::string lex_line(std::string const &input, ErrorInfo *out_error);
+};
+
+#endif // PROCESSOR_H

data/exe/bsm

@@ -1,14 +1,10 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'bsm/bsm_parse'
 require 'json'
+require 'bsm'
 
-ast = JSON.parse(Bsm::BsmParse::compile_to_ast(ARGF.read))
+content = ARGF.to_a.join("\n")
+gen = Bsm::Generator.new
 
-result = ''
-
-ast['hexlits'].each do |chr|
-  result << chr['_token'].to_i(16)
-end
-
-print result
+print gen.generate(content)

data/ext/bsm/internal/bsm.c

@@ -0,0 +1,119 @@
+#include "c_api.h"
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <string.h>
+
+static VALUE mBsm;
+static VALUE cGenerator;
+static VALUE eInvalidInput;
+
+struct generator_wrapper
+{
+  bsm2_processor* proc;
+};
+
+static void generator_free(void* ptr);
+
+static const rb_data_type_t generator_data_type = {
+  "Bsm/GeneratorInternal",
+  {NULL, generator_free, NULL},
+  NULL,
+  NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static void generator_free(void* ptr)
+{
+  struct generator_wrapper* w = (struct generator_wrapper*)ptr;
+  if (w)
+  {
+    if (w->proc)
+    {
+      bsm2_free(w->proc);
+    }
+    xfree(w);
+  }
+}
+
+static VALUE generator_alloc(VALUE klass)
+{
+  struct generator_wrapper* w;
+  VALUE obj = TypedData_Make_Struct(
+    klass, struct generator_wrapper, &(generator_data_type), w);
+  w->proc = bsm2_new();
+  if (!w->proc)
+  {
+    rb_raise(eInvalidInput, "bsm2_new failed");
+  }
+  return obj;
+}
+
+static VALUE generator_generate_raw(VALUE self, VALUE input)
+{
+  struct generator_wrapper* w;
+  TypedData_Get_Struct(self, struct generator_wrapper, &generator_data_type, w);
+
+  input = rb_String(input);
+
+  /* Iterate over lines, feeding each to bsm2_convert_line, concatenating
+   * the returned bytes into one binary String. */
+  VALUE result = rb_str_new_literal("");
+  rb_enc_associate(result, rb_ascii8bit_encoding());
+
+  char* cstr = StringValuePtr(input);
+  long total = RSTRING_LEN(input);
+  long line_start = 0;
+
+  for (long i = 0; i <= total; i++)
+  {
+    if (i == total || cstr[i] == '\n')
+    {
+      long line_len = i - line_start;
+      const char* line = cstr + line_start;
+
+      size_t out_len = 0;
+      bsm2_error* err = NULL;
+      char* out = bsm2_convert_line(w->proc, line, (size_t)line_len,
+                                    &out_len, &err);
+      if (!out)
+      {
+        if (err)
+        {
+          VALUE msg = rb_str_new_cstr(bsm2_error_message(err));
+          VALUE exc = rb_funcall(eInvalidInput, rb_intern("new"), 1, msg);
+          rb_iv_set(exc, "@line", UINT2NUM(bsm2_error_line(err)));
+          rb_iv_set(exc, "@column", UINT2NUM(bsm2_error_column(err)));
+          rb_iv_set(exc, "@length", UINT2NUM(bsm2_error_length(err)));
+          rb_iv_set(exc, "@line_text",
+                    rb_str_new_cstr(bsm2_error_line_text(err)));
+          bsm2_error_free(err);
+          rb_exc_raise(exc);
+        }
+        rb_raise(eInvalidInput, "bsm2_convert_line failed");
+      }
+
+      if (out_len)
+      {
+        rb_str_cat(result, out, (long)out_len);
+      }
+      free(out);
+
+      line_start = i + 1;
+    }
+  }
+
+  return result;
+}
+
+void Init_internal(void)
+{
+  mBsm = rb_define_module("Bsm");
+  eInvalidInput =
+    rb_define_class_under(mBsm, "InvalidInput", rb_eStandardError);
+  cGenerator =
+    rb_define_class_under(mBsm, "GeneratorInternal", rb_cObject);
+
+  rb_define_alloc_func(cGenerator, generator_alloc);
+  rb_define_method(cGenerator, "generate_raw", generator_generate_raw, 1);
+}

data/ext/bsm/internal/extconf.rb

@@ -2,6 +2,29 @@
 
 require 'mkmf'
 
-have_library('stdc++')
-$CXXFLAGS = '-g -Wall -std=gnu++11'
+# bsm2 source is vendored at GEM_ROOT/bsm2 (a git submodule).
+# extconf lives at GEM_ROOT/ext/bsm/internal, so three dirs up to the gem root.
+BSM2_DIR = File.expand_path('../../../bsm2', __dir__)
+
+unless File.directory?(File.join(BSM2_DIR, 'src'))
+  abort "bsm2 source not found at #{BSM2_DIR}/src. " \
+        'If this is a checkout, init the submodule: git submodule update --init'
+end
+
+# Build the static library from vendored source.
+Dir.chdir(BSM2_DIR) do
+  success = system('make', 'libbsm2')
+  abort 'Failed to build bsm2/libbsm2.a (requires g++ with C++17)' unless success
+end
+
+# Expose the C API header and the built static lib to the extension.
+# rubocop:disable Style/GlobalVars
+$INCFLAGS << " -I#{File.join(BSM2_DIR, 'src')}"
+$LDFLAGS  << " -L#{File.join(BSM2_DIR, 'lib')}"
+# rubocop:enable Style/GlobalVars
+
+# libbsm2.a is C++ internally (std::string, new/delete); link the C++ runtime.
+have_library('stdc++') or abort 'libstdc++ not found'
+have_library('bsm2', 'bsm2_new') or abort 'libbsm2 not found / bsm2_new missing'
+
 create_makefile('bsm/internal')

data/lib/bsm/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bsm
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.1'
 end

data/lib/bsm.rb

@@ -1,6 +1,25 @@
+# frozen_string_literal: false
+
 require 'bsm/version'
+require 'bsm/internal'
 
 module Bsm
-  class Error < StandardError; end
-  # Your code goes here...
+  # Raised when bsm2 rejects input. Carries the structured error fields
+  # (line, column, length, line_text) from the native library so callers can
+  # report precise locations.
+  class InvalidInput < StandardError
+    attr_accessor :line, :column, :length, :line_text
+  end
+
+  # The generator class. Input is in bsm2 literate format: a line is data
+  # only if it starts with a semicolon (;); other lines are ignored.
+  class Generator
+    def initialize(_options = {})
+      @generator = GeneratorInternal.new
+    end
+
+    def generate(input)
+      @generator.generate_raw(input)
+    end
+  end
 end

metadata

@@ -1,74 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: bsm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - David Siaw
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-09-27 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-description: a longer description
+date: 2026-07-21 00:00:00.000000000 Z
+dependencies: []
+description: Bsm converts literate text (semicolon-prefixed lines of hex, strings,
+  bitfields) into binary. Backed by the native bsm2 library.
 email:
-- dsiaw@degica.com
+- 874280+davidsiaw@users.noreply.github.com
 executables:
 - bsm
 extensions:
@@ -77,21 +22,34 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - bsm.gemspec
+- bsm2/Makefile
+- bsm2/src/bsm2/main.cpp
+- bsm2/src/c_api.cpp
+- bsm2/src/c_api.h
+- bsm2/src/converter.h
+- bsm2/src/error_info.h
+- bsm2/src/lexer.cpp
+- bsm2/src/lexer.h
+- bsm2/src/msb2/README.md
+- bsm2/src/msb2/main.cpp
+- bsm2/src/processor.cpp
+- bsm2/src/processor.h
 - exe/bsm
+- ext/bsm/internal/bsm.c
 - ext/bsm/internal/extconf.rb
 - lib/bsm.rb
-- lib/bsm/bsm_parse.rb
-- lib/bsm/bsm_parse/internal.bundle
+- lib/bsm/internal.so
 - lib/bsm/version.rb
-homepage: https://github.org/davidsiaw/bsm
+homepage: https://github.com/davidsiaw/bsm
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.org/davidsiaw/bsm
-  source_code_uri: https://github.org/davidsiaw/bsm
-  changelog_uri: https://github.org/davidsiaw/bsm
-post_install_message: 
+  homepage_uri: https://github.com/davidsiaw/bsm
+  source_code_uri: https://github.com/davidsiaw/bsm
+  changelog_uri: https://github.com/davidsiaw/bsm
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -99,16 +57,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: a short summary
+summary: Write binary files in a human-readable way
 test_files: []

data/lib/bsm/bsm_parse.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'bsm/bsm_parse/internal'
-
-module Bsm
-  # Parser module, wraps the native functions with some error handling
-  module BsmParse
-    def self.runtest(hello)
-      bsm_parse_test(hello)
-    end
-
-    def self.compile_to_ast(string)
-      return bsm_parse_compile_to_ast(string) if string.is_a? String
-
-      raise 'Invalid type given. This method only accepts strings'
-    end
-  end
-end