alt_printf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca3bfbd5642eb9ee9d75ed799b3cb18708d44c2d1f57eabcf8cf9795cc54e82c
+  data.tar.gz: e7d66a6c4770522c112d677de2c3d88df98ddb2a0089ddd784b10063493a21cb
+SHA512:
+  metadata.gz: fe5d82f1920848129f2bf490bb49754efd1de8b46dd7c468cc700b6a5e9d76a5b130706bcbfff1d87faa000f8a933247886bff4c2c2fdba17d5f398f7b822dac
+  data.tar.gz: 5fe9d231104bcfc0d5fda40924c3f55630c3981427f09ab63985432123f314250b858f2bb7dd946ae58161702abd832e2e81f4a4f06a8b58ab7f56b86a80fcfd

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,14 @@
+# AltPrintf
+
+AltPrintf is a gem that wraps `altprintf`.
+
+It exposes the following module functions
+
++ `#fmt(format_string, *args, **kwargs)`
++ `#fmtm(passes, format_string, *args, **kwargs)`
+
+In addition to the syntax of vanilla altprintf, the following additional
+argument is accepted:
+
++ `<val>` - access the value of the given hash with key `:"#{val}"` rather than
+  try to read the next argument.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rake/extensiontask'
+require 'bundler/gem_tasks'
+require 'securerandom'
+require 'fileutils'
+
+SRC_DIR = File.join(__dir__, '../src')
+
+Rake::ExtensionTask.new('alt_printf') do |ext|
+  ext.lib_dir = 'lib/alt_printf'
+  ext.config_script = 'extconf_dev.rb'
+end
+
+task :build_gem do
+  tmp_dir = "/tmp/alt_printf_#{SecureRandom.hex(8)}"
+  puts "cloning to #{tmp_dir}"
+  FileUtils.mkdir(tmp_dir)
+
+  Dir[
+    'Gemfile',
+    'README.md',
+    'Rakefile',
+    'alt_printf.gemspec',
+    '{ext,lib}/**/*'
+  ].each do |f|
+    next if File.directory?(f)
+
+    dir = File.join(tmp_dir, File.dirname(f))
+    FileUtils.mkdir_p(dir)
+    FileUtils.cp(f, File.join(dir, File.basename(f)))
+  end
+
+  FileUtils.cp_r(
+    %w[altprintf list log strbuf syntax].map do |w|
+      %w[h c].map { |e| File.join(SRC_DIR, "#{w}.#{e}") }
+        .select { |f| File.exist?(f) }
+    end.flatten,
+    File.join(tmp_dir, 'ext/alt_printf/')
+  )
+
+  FileUtils.cd(tmp_dir)
+
+  sh "rake build"
+
+  FileUtils.cp(Dir['pkg/*'], File.join(__dir__, 'pkg'))
+  FileUtils.cd(__dir__)
+  FileUtils.rm_rf(tmp_dir)
+end
+
+task publish: :build_gem do
+  load File.join(__dir__, 'alt_printf.gemspec')
+  p AltPrintf
+  sh "gem push pkg/#{AltPrintf::SPEC.name}-#{AltPrintf::SPEC.version}.gem"
+end

data/alt_printf.gemspec

@@ -0,0 +1,24 @@
+require 'date'
+require_relative 'lib/alt_printf/version'
+
+AltPrintf::SPEC = Gem::Specification.new do |s|
+  s.name          = 'alt_printf'
+  s.version       = AltPrintf::VERSION.join('.')
+  s.date          = Date.today.strftime('%Y-%m-%d')
+  s.summary       = 'A powerful printf-like template language'
+  s.authors       = ['Stone Tickle']
+  s.email         = 'lattis@mochiro.moe'
+  s.homepage      = 'https://github.com/alt_printf/gem'
+  s.license       = 'MIT'
+
+  s.files         = Dir['{**/*}']
+
+  s.platform = Gem::Platform::RUBY
+  s.extensions = Dir["ext/**/extconf.rb"]
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.6.3'
+
+  s.add_development_dependency 'rake-compiler', '~> 1.0'
+  s.add_development_dependency 'rake', '~> 12.3'
+end unless AltPrintf.const_defined?(:'SPEC')

data/ext/alt_printf/alt_printf.c

@@ -0,0 +1,222 @@
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "extconf.h"
+#include "list.h"
+#include "altprintf.h"
+#include "log.h"
+
+#define CHECKARG                              \
+if (!use_hash) {                              \
+	if (*argi >= argc) goto no_more_args; \
+	entry = rb_ary_entry(*argv, *argi);   \
+}
+
+#define MODNAME "AltPrintf"
+
+rb_encoding *enc;
+
+wchar_t *rbstowcs(VALUE str) {
+	const char *cstr;
+	wchar_t *wstr;
+	size_t len;
+
+	cstr = StringValueCStr(str);
+
+	len = mbsrtowcs(NULL, &cstr, 0, NULL);
+	wstr = calloc(len + 1, sizeof(wchar_t));
+	len = mbsrtowcs(wstr, &cstr, len, NULL);
+
+	LOG("rbs to wcs, len: %d, cstr: '%s'\n", len, cstr);
+	LOG("wide string: '%ls'\n", wstr);
+
+	return wstr;
+}
+
+VALUE wcstorbs(const wchar_t *wstr) {
+	size_t len;
+	char *cstr;
+	VALUE str;
+
+	len = wcsrtombs(NULL, &wstr, 0, NULL);
+	cstr = calloc(len, sizeof(wchar_t));
+	wcsrtombs(cstr, &wstr, len, NULL);
+
+	LOG("wcs to rbs, len: %d, cstr: '%s'\n", len, cstr);
+
+	str = rb_external_str_new_with_enc(cstr, len, enc);
+	free(cstr);
+
+	return str;
+}
+
+struct list_elem *rb_altprintf_make_list(const wchar_t *fmt, VALUE *argv, long *argi, VALUE *hash) {
+	struct list_elem *le_cur;
+	struct list_elem *le_start;
+	struct list_elem *le_prev;
+	/* create a dummy element as the head */
+	le_start = le_prev = list_elem_create();
+
+	VALUE entry, symbol;
+
+	long int *tmp_int;
+	wint_t *tmp_char;
+	double *tmp_double;
+	const wchar_t *tmp_str;
+
+	char *cstr;
+	size_t len;
+
+	int mode	= 0;
+	long argc = rb_array_len(*argv);
+	int use_hash = 0;
+
+	const wchar_t *end = &fmt[wcslen(fmt)];
+
+	for (;fmt<end;fmt++) {
+		LOG("checking char '%lc', lvl: '%d'\n", (wint_t)(*fmt), mode);
+		if (mode == 0) {
+			switch(*fmt) {
+			case FS_START: mode = 1;
+				break;
+			}
+		} else {
+			switch (*fmt) {
+			case FS_A_CHARARG:
+				fmt++;
+				break;
+			case FS_A_RBHASHSTART:
+				tmp_str = fmt + 1;
+
+				use_hash = -1;
+				while (fmt < end && *fmt != FS_A_RBHASHEND) {
+					fmt++;
+					use_hash++;
+				}
+
+				len = wcsnrtombs(NULL, &fmt, use_hash, 0, NULL);
+				cstr = calloc(len + 1, sizeof(char));
+				wcsnrtombs(cstr, &tmp_str, use_hash, len, NULL);
+				LOG("cstr: '%s'\n", cstr);
+
+				symbol = rb_check_symbol_cstr(cstr, len, enc);
+				entry = rb_hash_lookup2(*hash, symbol, Qnil);
+				free(cstr);
+				use_hash = 1;
+
+				break;
+			case FS_A_STRINGSTART:
+				while (fmt < end && *fmt != FS_A_STRINGEND) fmt++;
+				break;
+			case FS_T_STRING:
+				CHECKARG;
+
+				tmp_str = rbstowcs(entry);
+				le_cur = list_elem_ini(tmp_str, String);
+				goto match;
+			case FS_T_MUL:
+			case FS_T_TERN:
+			case FS_T_ALIGN:
+			case FS_T_INT:
+				CHECKARG;
+
+				tmp_int = malloc(sizeof(long int));
+				*tmp_int = FIX2LONG(entry);
+				LOG("got int %ld\n", *tmp_int);
+				le_cur = list_elem_ini(tmp_int, Int);
+				goto match;
+			case FS_T_CHAR:
+				CHECKARG;
+
+				tmp_char = malloc(sizeof(wint_t));
+				tmp_str = rbstowcs(entry);
+				*tmp_char = btowc(tmp_str[0]);
+				le_cur = list_elem_ini(tmp_char, Char);
+				goto match;
+			case FS_T_DOUBLE:
+				CHECKARG;
+
+				tmp_double = malloc(sizeof(double));
+				*tmp_double = RFLOAT_VALUE(entry);
+				le_cur = list_elem_ini(tmp_double, Double);
+				goto match;
+			match: le_prev->next = le_cur;
+				le_prev = le_cur;
+				mode = 0;
+				(*argi)++;
+				break;
+			case FS_START:
+				mode = 0;
+				break;
+			}
+		}
+	}
+
+no_more_args:
+	if (le_start->next == NULL) return le_start;
+
+	/* set cur to the 2nd element and destroy the first one */
+	le_cur = le_start->next;
+	le_start->next = NULL;
+	list_elem_destroy(le_start);
+
+	return le_cur;
+}
+
+VALUE rb_alt_printf(long passes, size_t argc, VALUE *argv, VALUE self) {
+	VALUE fmt, args, hash, final;
+	wchar_t *wfmt;
+	wchar_t *formatted;
+	struct list_elem *ap;
+
+	rb_scan_args(argc, argv, "1*:", &fmt, &args, &hash);
+
+	if (passes == 0) return fmt;
+
+	wfmt = rbstowcs(fmt);
+
+	long argi = 0;
+	while (passes > 0) {
+		ap = rb_altprintf_make_list(wfmt, &args, &argi, &hash);
+
+		formatted = altsprintf(wfmt, ap);
+		LOG("formatted result: '%ls'\n", formatted);
+
+		free(wfmt);
+		list_elem_destroy(ap);
+
+		wfmt = formatted;
+		passes--;
+	}
+
+	final = wcstorbs(formatted);
+
+	free(formatted);
+
+	return final;
+}
+
+VALUE rb_alt_printf_single_pass(size_t argc, VALUE *argv, VALUE self) {
+	VALUE fmt, args, hash, final;
+
+	return rb_alt_printf(1, argc, argv, self);
+}
+
+VALUE rb_alt_printf_multi_pass(size_t argc, VALUE *argv, VALUE self) {
+	long passes;
+
+	passes = FIX2LONG(argv[0]);
+
+	LOG("passes: %ld\n", passes);
+	return rb_alt_printf(passes, argc - 1, &argv[1], self);
+}
+
+void Init_alt_printf()
+{
+	enc = rb_enc_find("UTF-8");
+	VALUE mod = rb_define_module(MODNAME);
+	rb_define_module_function(mod, "fmt", rb_alt_printf_single_pass, -1);
+	rb_define_module_function(mod, "fmtm", rb_alt_printf_multi_pass, -1);
+}

data/ext/alt_printf/altprintf.c

@@ -0,0 +1,244 @@
+#include "syntax.h"
+#include "altprintf.h"
+#include "log.h"
+
+void default_format(struct format *f) {
+	struct width width = {.prec = -1, .pad = 0};
+	f->stringarg_start = NULL;
+	f->stringarg_end = NULL;
+	f->chararg = L':';
+	f->padchar = L' ';
+	f->align = Right;
+	f->width = width;
+	f->le = NULL;
+}
+
+void format_mul(struct strbuf *sb, struct format *f)
+{
+	long int *i = f->le->data;
+	strbuf_pad(sb, f->chararg, *i);
+}
+void format_tern(struct strbuf *sb, struct format *f)
+{
+	long int *b = f->le->data;
+	int first_half = 1;
+	wchar_t sep = f->chararg;
+	wchar_t *p = f->stringarg_start;
+	for (;p<=f->stringarg_end;p++) {
+		LOG("*p: %lc, first half? %d, bool: %ld, sep: %lc\n", (wint_t)*p, first_half, *b, (wint_t)sep);
+		if (*p == sep) first_half = 0;
+		else if (*b && first_half) strbuf_append_char(sb, p);
+		else if (!*b && !first_half) strbuf_append_char(sb, p);
+	}
+}
+
+void format_string(struct strbuf *sb, struct format *f)
+{
+	int prec = f->width.prec == -1 ? 100000000 : f->width.prec;
+	strbuf_append_str(sb, f->le->data, prec);
+}
+void format_char(struct strbuf *sb, struct format *f)
+{
+	strbuf_append_char(sb, f->le->data);
+}
+void format_int(struct strbuf *sb, struct format *f)
+{
+	strbuf_append_int(sb, f->le->data);
+}
+void format_double(struct strbuf *sb, struct format *f)
+{
+	int prec = f->width.prec == -1 ? 3 : f->width.prec;
+	strbuf_append_double(sb, f->le->data, prec);
+}
+
+void format(struct strbuf *sb, struct format *f, void (*to_s)(struct strbuf *, struct format *))
+{
+	struct strbuf *tmp = strbuf_new();
+	to_s(tmp, f);
+
+	if (tmp->len == 0) return;
+
+	int pad = f->width.pad - tmp->width;
+
+	if (pad > 0) {
+		LOG("padding: %d\n", pad);
+		switch(f->align) {
+		case Right:
+			strbuf_append_strbuf(sb, tmp);
+			strbuf_pad(sb, f->padchar, pad);
+			break;
+		case Left:
+			strbuf_pad(sb, f->padchar, pad);
+			strbuf_append_strbuf(sb, tmp);
+			break;
+		case Center:
+			strbuf_pad(sb, f->padchar, pad/2);
+			strbuf_append_strbuf(sb, tmp);
+			strbuf_pad(sb, f->padchar, pad/2 + pad%2);
+			break;
+		}
+	} else {
+		strbuf_append_strbuf(sb, tmp);
+	}
+
+	strbuf_destroy(tmp);
+}
+
+wchar_t *altsprintf(wchar_t *fmt, struct list_elem *le) {
+	int lvl = 0;
+	int split = 0;
+	struct strbuf *sbs[] = {strbuf_new(), strbuf_new()};
+	struct strbuf *sb = sbs[0];
+	wchar_t *end = &fmt[wcslen(fmt)];
+	wchar_t *jump;
+
+	void (*append_func)(struct strbuf *, struct format *);
+	struct format f;
+	long int *number_p = NULL;
+	long int *width;
+	wint_t split_pad = L' ';
+
+	for (;fmt<end;fmt++) {
+		LOG("checking char '%lc', lvl: '%d'\n", (wint_t)(*fmt), lvl);
+		switch (lvl) {
+		case 0:
+			switch(*fmt) {
+			case FS_START:
+				default_format(&f);
+				lvl = 1;
+				break;
+			case FS_ESC:
+				lvl = 3;
+				break;
+			default:
+				strbuf_append(sb, *fmt);
+				break;
+			}; break;
+		case 1:
+			switch(*fmt) {
+			/* special arguments */
+			case FS_A_STRINGSTART:
+				f.stringarg_start = fmt + 1;
+				lvl = 2;
+				break;
+			case FS_A_CHARARG:
+				f.chararg = *(fmt+1);
+				fmt += 1;
+				break;
+
+			/* standard arguments */
+			case FS_A_LALIGN:
+				f.align = Left;
+				break;
+			case FS_A_SPAD:
+				f.padchar = FS_A_SPAD;
+				break;
+			case 0:
+				f.padchar = '0';
+				break;
+			case '.':
+				number_p = &f.width.prec;
+				fmt++;
+			case '1': case '2': case '3': case '4': case '5':
+			case '6': case '7': case '8': case '9':
+				if (number_p == NULL) number_p = &f.width.pad;
+				*number_p = wcstol(fmt, &jump, 10);
+				fmt = (jump-1);
+				break;
+
+			/* align operator */
+			case FS_T_ALIGN:
+				if (le != NULL && le->type != Null) {
+					width = le->data;
+					le = le->next;
+				} else {
+					goto no_more_args;
+				}
+
+				split = 1;
+				split_pad = f.chararg;
+				sb = sbs[1];
+				lvl = 0;
+				break;
+
+			/* types */
+			case FS_T_STRING:
+				append_func = format_string;
+				goto match;
+			case FS_T_TERN:
+				append_func = format_tern;
+				goto match;
+			case FS_T_INT:
+				append_func = format_int;
+				goto match;
+			case FS_T_MUL:
+				append_func = format_mul;
+				goto match;
+			case FS_T_CHAR:
+				append_func = format_char;
+				goto match;
+			case FS_T_DOUBLE:
+				append_func = format_double;
+			match:
+				if (le != NULL && le->type != Null) {
+					f.le = le;
+					format(sb, &f, append_func);
+					le = le->next;
+				}
+				lvl = 0;
+				break;
+			case FS_START:
+				strbuf_append(sb, FS_START);
+				lvl = 0;
+				break;
+			}; break;
+		case 2:
+			if (*fmt == FS_A_STRINGEND) {
+				f.stringarg_end = fmt - 1;
+				lvl = 1;
+			}; break;
+		case 3:
+			switch(*fmt) {
+			case FS_ESC_NL:
+				strbuf_append(sb, '\n');
+				break;
+			case FS_ESC_ESC:
+				strbuf_append(sb, '\e');
+				break;
+			default:
+				strbuf_append(sb, *fmt);
+				break;
+			};
+			lvl = 0;
+			break;
+		}
+	}
+
+	wchar_t *str;
+no_more_args:
+	if (split) {
+		LOG("splitting string\n");
+		lvl = *width - (sbs[0]->width + sbs[1]->width);
+		if (lvl >= 0) {
+			LOG("padding center\n");
+			strbuf_pad(sbs[0], split_pad, lvl);
+			strbuf_append_strbuf(sbs[0], sbs[1]);
+		} else if (sbs[0]->width > *width) {
+			LOG("the first half is longer than the requested with\n");
+			strbuf_destroy(sbs[1]);
+			sbs[1] = sbs[0];
+			sbs[0] = strbuf_new();
+			strbuf_appendw_strbuf(sbs[0], sbs[1], *width);
+		} else {
+			LOG("just shave some off the last half\n");
+			strbuf_appendw_strbuf(sbs[0], sbs[1], *width - sbs[0]->width);
+		}
+	}
+
+	str = strbuf_cstr(sbs[0]);
+
+	strbuf_destroy(sbs[0]);
+	strbuf_destroy(sbs[1]);
+
+	return str;
+}

data/ext/alt_printf/altprintf.h

@@ -0,0 +1,42 @@
+#ifndef ALTPRINTF_H
+#define ALTPRINTF_H
+
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <math.h>
+#include <limits.h>
+#include <wchar.h>
+#include "strbuf.h"
+#include "list.h"
+#include "syntax.h"
+
+wchar_t *altsprintf(wchar_t *fmt, struct list_elem *le);
+
+enum align {
+  Left,
+  Right,
+  Center
+};
+
+struct width {
+  long int prec;
+  long int pad;
+};
+
+struct format {
+  wchar_t *stringarg_start;
+  wchar_t *stringarg_end;
+  wint_t chararg;
+  wint_t padchar;
+  enum align align;
+  struct width width;
+  struct list_elem *le;
+};
+
+#endif

data/ext/alt_printf/extconf.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+
+create_header
+create_makefile('alt_printf')

data/ext/alt_printf/extconf_dev.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'mkmf'
+
+base_dir = File.join(__dir__, '../../../')
+find_header('altprintf.h', File.join(base_dir, 'src'))
+$objs = Dir[File.join(base_dir, 'target/release/*.o')] + ['alt_printf.o']
+
+create_header
+create_makefile('alt_printf')

data/ext/alt_printf/list.c

@@ -0,0 +1,81 @@
+#include "list.h"
+#include "log.h"
+
+struct list_elem *list_elem_create() {
+	void *null = NULL;
+	struct list_elem *le = malloc(sizeof(struct list_elem));
+	LOG("allocatted %zu	%p\n", sizeof(struct list_elem), le);
+	le->data = null;
+	le->type = Null;
+	le->next = null;
+	le->heap = 1;
+
+	return le;
+}
+
+void list_elem_destroy(struct list_elem *le) {
+	if (le->heap && le->data != NULL) {
+		LOG("freeing %p\n", le->data);
+		free(le->data);
+	}
+	if (le->next != NULL) { list_elem_destroy(le->next); }
+
+	LOG("freeing %p\n", le);
+	free(le);
+}
+
+struct list_elem *list_elem_ini(void *data, enum type t) {
+	struct list_elem *le = list_elem_create();
+	le->data = data;
+	le->type = t;
+	return le;
+}
+
+struct list_elem *list_elem_ini_str(wchar_t *str) {
+	struct list_elem *le = list_elem_create();
+	le->data = str;
+	le->type = String;
+	return le;
+}
+
+struct list_elem *list_elem_ini_int(long int *i) {
+	struct list_elem	*le = list_elem_create();
+	le->data = i;
+	le->type = Int;
+	return le;
+}
+
+struct list_elem *list_elem_ini_dub(double *d) {
+	struct list_elem	*le = list_elem_create();
+	le->data = d;
+	le->type = Double;
+	return le;
+}
+
+void list_elem_inspect(struct list_elem *le) {
+	switch (le->type) {
+	case Int:
+		printf("->Int %ld\n", *(long int *)le->data);
+		break;
+	case String:
+		printf("->String '%ls'\n", (wchar_t *)le->data);
+		break;
+	case Char:
+		printf("->Char %lc\n", *(wint_t *)le->data);
+		break;
+	case Double:
+		printf("->Double %f\n", *(double *)le->data);
+		break;
+	case Null:
+		printf("->Null\n");
+		break;
+	}
+}
+
+void list_elem_inspect_all(struct list_elem *le) {
+	while(1) {
+		list_elem_inspect(le);
+		if (le->next == NULL) { break; }
+		le = le->next;
+	}
+}

data/ext/alt_printf/list.h

@@ -0,0 +1,24 @@
+#ifndef LIST_H
+#define LIST_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+enum type { Int, String, Char, Double, Null };
+
+struct list_elem {
+  void *data;
+  enum type type;
+  struct list_elem *next;
+  int heap;
+};
+
+struct list_elem *list_elem_create();
+void list_elem_destroy(struct list_elem *le);
+struct list_elem *list_elem_ini(void *data, enum type t);
+struct list_elem *list_elem_ini_int(long int *i);
+struct list_elem *list_elem_ini_str(wchar_t *str);
+struct list_elem *list_elem_ini_dub(double *d);
+void list_elem_inspect(struct list_elem *le);
+void list_elem_inspect_all(struct list_elem *le);
+#endif

data/ext/alt_printf/log.h

@@ -0,0 +1,11 @@
+#ifndef LOG_H
+#define LOG_H
+
+#ifdef DEBUG
+#define LOG(...) printf("%s[%d] - ", __FILE__, __LINE__);printf(__VA_ARGS__);
+#define FLOG(msg, ...) fprintf(stderr, "%s[%d] - "msg, __FILE__, __LINE__ __VA_OPT__(,) __VA_ARGS__)
+#else
+#define LOG(msg, ...)
+#define FLOG(msg, ...)
+#endif
+#endif

data/ext/alt_printf/strbuf.c

@@ -0,0 +1,142 @@
+#define _XOPEN_SOURCE
+#include <locale.h>
+#include <limits.h>
+#include "strbuf.h"
+#include "log.h"
+
+#define STRBUF_INI_SIZE 5
+#define STRBUF_GROW_STEP 100
+
+extern struct lconv *locale_info;
+
+struct strbuf *strbuf_new() {
+	struct strbuf *sb = malloc(sizeof(struct strbuf));
+
+	if (NULL == sb) {
+		LOG("can't alloc memory for new strbuf", NULL);
+		exit(1);
+	}
+
+	sb->start = sb->end = calloc(STRBUF_INI_SIZE, sizeof(wchar_t));
+
+	if (NULL == sb->start) {
+		LOG("can't alloc memory for new strbuf string", NULL);
+		exit(1);
+	}
+
+	sb->len = 0;
+	sb->cap = STRBUF_INI_SIZE;
+	sb->width = 0;
+	return sb;
+}
+
+void strbuf_destroy(struct strbuf *sb) {
+	free(sb->start);
+	free(sb);
+}
+
+void strbuf_append(struct strbuf *sb, wchar_t c)
+{
+	wchar_t *ns;
+
+	if (sb->cap < sb->len + 2) {
+		ns = calloc(sb->cap + STRBUF_GROW_STEP, sizeof(wchar_t));
+
+		if (ns == NULL) {
+			LOG("can't increase size of strbuf to %d\n", sb->cap + STRBUF_GROW_STEP);
+			exit(1);
+		}
+
+		wcscpy(ns, sb->start);
+		free(sb->start);
+
+		sb->start = ns;
+		sb->cap += STRBUF_GROW_STEP;
+	}
+
+	sb->start[sb->len] = c;
+	sb->start[sb->len+1] = L'\0';
+	LOG("string so far: %ls\n", sb->start);
+	sb->end = &sb->start[sb->len];
+	sb->len++;
+	int w = wcwidth(c);
+	if (w >= 0) sb->width += w;
+}
+
+void strbuf_append_strbuf(struct strbuf *sb, void *sbuf)
+{
+	wchar_t *pos;
+	struct strbuf *frm = sbuf;
+	LOG("frm->start: %p | frm->end: %p\n", frm->start, frm->end);
+
+	for (pos = frm->start;pos<=frm->end;pos++) {
+		strbuf_append(sb, *pos);
+	}
+}
+
+void strbuf_appendw_strbuf(struct strbuf *sb, void *sbuf, long w)
+{
+	wchar_t *pos;
+	long ws = 0;
+	struct strbuf *frm = sbuf;
+	LOG("frm->start: %p | frm->end: %p\n", frm->start, frm->end);
+
+	for (pos = frm->start;pos<=frm->end;pos++) {
+		ws += wcwidth(*pos);
+		LOG("new width would be: %ld, requested width: %ld\n", ws, w);
+		if (ws > w) break;
+		strbuf_append(sb, *pos);
+	}
+}
+
+void strbuf_append_char(struct strbuf *sb, void *chr)
+{
+	wint_t *c = chr;
+	strbuf_append(sb, *c);
+}
+
+void strbuf_append_str(struct strbuf *sb, void *str, int maxwidth)
+{
+	wchar_t *s = str;
+	wchar_t *end = &s[wcslen(s)];
+	int width = 0;
+
+	for (;s<end;s++) {
+		width += wcwidth(*s);
+		if (width > maxwidth) return;
+		strbuf_append(sb, *s);
+	}
+}
+
+void strbuf_append_int(struct strbuf *sb, void *in)
+{
+	long int *i = in;
+	wchar_t wcs[50];
+	swprintf(wcs, 50, L"%ld", *i);
+	strbuf_append_str(sb, wcs, 50);
+}
+
+void strbuf_append_double(struct strbuf *sb, void *dub, int prec)
+{
+	double *d = dub;
+	wchar_t wcs[50];
+	wchar_t format[30];
+	swprintf(format, 30, L"%%.%ldf", prec);
+	LOG("format: %ls\n", format);
+	swprintf(wcs, 50, format, *d);
+	strbuf_append_str(sb, wcs, 50);
+}
+
+void strbuf_pad(struct strbuf *sb, wchar_t pc, int amnt)
+{
+	for (;amnt>0;amnt--) strbuf_append(sb, pc);
+}
+
+wchar_t *strbuf_cstr(struct strbuf *sb)
+{
+	wchar_t *str;
+	str = calloc(sb->len + 1, sizeof(wchar_t));
+	wcscpy(str, sb->start);
+
+	return str;
+}

data/ext/alt_printf/strbuf.h

@@ -0,0 +1,28 @@
+#ifndef STRBUF_H
+#define STRBUF_H
+#include <wchar.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+struct strbuf *strbuf_new();
+void strbuf_destroy(struct strbuf *sb);
+void strbuf_append(struct strbuf *sb, wchar_t);
+void strbuf_append_char(struct strbuf *sb, void  *);
+void strbuf_append_str(struct strbuf *, void *, int);
+void strbuf_append_int(struct strbuf *sb, void *);
+void strbuf_append_double(struct strbuf *, void *, int);
+void strbuf_append_strbuf(struct strbuf *, void *);
+void strbuf_appendw_strbuf(struct strbuf *, void *, long);
+void strbuf_pad(struct strbuf *, wchar_t, int);
+wchar_t *strbuf_cstr(struct strbuf *);
+
+struct strbuf {
+  wchar_t *start;
+  wchar_t *end;
+  size_t len;
+  size_t width;
+  size_t cap;
+};
+#endif

data/ext/alt_printf/syntax.h

@@ -0,0 +1,30 @@
+#ifndef SYNTAX_H
+#define SYNTAX_H
+
+#define FS_START    '%'
+#define FS_DOUBLE_SEP '.'
+
+#define FS_ESC '\\'
+#define FS_ESC_NL 'n'
+#define FS_ESC_ESC 'e'
+
+#define FS_T_STRING 's'
+#define FS_T_CHAR   'c'
+#define FS_T_DOUBLE 'f'
+#define FS_T_INT    'd'
+#define FS_T_MUL    '*'
+#define FS_T_TERN   '?'
+#define FS_T_ALIGN  '='
+
+#define FS_A_STRINGSTART '('
+#define FS_A_STRINGEND   ')'
+#define FS_A_CHARARG     '~'
+#define FS_A_LALIGN      '-'
+#define FS_A_SPAD        ' '
+
+#define FS_A_RBHASHSTART '<'
+#define FS_A_RBHASHEND   '>'
+
+#define FS_D_PREC   100
+
+#endif

data/lib/alt_printf/version.rb

@@ -0,0 +1,3 @@
+module AltPrintf
+  VERSION = [0, 1, 0]
+end

data/lib/alt_printf.rb

@@ -0,0 +1,4 @@
+require_relative 'alt_printf/version'
+require_relative 'alt_printf/alt_printf'
+
+module AltPrintf end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: alt_printf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stone Tickle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: 
+email: lattis@mochiro.moe
+executables: []
+extensions:
+- ext/alt_printf/extconf.rb
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- alt_printf.gemspec
+- ext/alt_printf/alt_printf.c
+- ext/alt_printf/altprintf.c
+- ext/alt_printf/altprintf.h
+- ext/alt_printf/extconf.rb
+- ext/alt_printf/extconf_dev.rb
+- ext/alt_printf/list.c
+- ext/alt_printf/list.h
+- ext/alt_printf/log.h
+- ext/alt_printf/strbuf.c
+- ext/alt_printf/strbuf.h
+- ext/alt_printf/syntax.h
+- lib/alt_printf.rb
+- lib/alt_printf/alt_printf.so
+- lib/alt_printf/version.rb
+homepage: https://github.com/alt_printf/gem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A powerful printf-like template language
+test_files: []