altprintf 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df338e1fe04766f80321b04dc0380e6c022ae06c8e4d13cbaea05522630b7463
+  data.tar.gz: 9b7c74147e5ef03e947467d2c4c89e7471c873a56410d2aa00f4015680352c96
+SHA512:
+  metadata.gz: ba342f2d892020efc12b7e0489a376b005fb2161b81ae235ac9021d04f7d594c9bda20e0c8c1a332a607a4897688faa34143c2bd1dcb100f6b71611992eeaa30
+  data.tar.gz: c19648ebefd35dbdf6b00760e92567be3f42c042227ba3e49d32f9595dcec29ce67ca47169c2f64ca1c164b199e3050c8a912403a1a28855c89b54084026a49d

data/altprintf.gemspec

@@ -0,0 +1,24 @@
+require 'date'
+require_relative 'lib/altprintf/version'
+
+Altprintf::SPEC = Gem::Specification.new do |s|
+  s.name          = 'altprintf'
+  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/annacrombie/altprintf/tree/master/gem'
+  s.license       = 'MIT'
+
+  s.files         = Dir['{**/*}'] - ['Rakefile']
+
+  s.platform = Gem::Platform::RUBY
+  s.extensions = Dir["ext/**/extconf.rb"]
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.5.5'
+
+  s.add_development_dependency 'rake-compiler', '~> 1.0'
+  s.add_development_dependency 'rake', '~> 12.3'
+end unless Altprintf.const_defined?(:'SPEC')

data/ext/altprintf/altprintf.h

@@ -0,0 +1,6 @@
+#ifndef ALTPRINTF_H_
+#define ALTPRINTF_H_
+#define ALTPRINTF_VERSION "0.2.4"
+#include "parsef.h"
+#include "fmt.h"
+#endif

data/ext/altprintf/enums.h

@@ -0,0 +1,15 @@
+#ifndef ARGTYPE_H_
+#define ARGTYPE_H_
+enum arg_type { FMul, FTern, FAlign, FInt, FChar, FDouble, FString, FRaw, FNone,
+		FEnd };
+enum align { Left, Right, Center };
+
+enum altprintf_err {
+	apfe_none,
+	apfe_invalid_token,
+	apfe_missing_argument
+};
+
+extern enum altprintf_err apf_err;
+
+#endif

data/ext/altprintf/ext.c

@@ -0,0 +1,270 @@
+#ifdef _FORTIFY_SOURCE
+#undef _FORTIFY_SOURCE
+#endif
+
+#ifdef RUBY_EXTCONF_H
+#undef RUBY_EXTCONF_H
+#endif
+
+#include "extconf.h"
+#include <stdio.h>
+#include <locale.h>
+#include <wchar.h>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "altprintf.h"
+#include "log.h"
+
+#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;
+
+	LOG("converting wcs to rbs\n");
+	LOG("wcs: '%ls'\n\n", wstr);
+
+	len = wcsrtombs(NULL, &wstr, 0, NULL);
+	LOG("len: %d\n", len);
+	cstr = calloc(len, sizeof(wchar_t));
+	wcsrtombs(cstr, &wstr, len, NULL);
+	LOG("cstr: '%s'\n", cstr);
+
+	LOG("wcs to rbs, len: %d, wcs: %ls, mbs: '%s'\n", len, wstr, cstr);
+
+	if (len == (size_t)-1)
+		return Qnil;
+
+	str = rb_external_str_new_with_enc(cstr, len, enc);
+	free(cstr);
+
+	return str;
+}
+
+VALUE get_entry(struct fmte *f, size_t argc, size_t *argi, VALUE *argv, VALUE *hash)
+{
+	VALUE sym, entry;
+	size_t len;
+	const wchar_t *tmpw;
+	char *cstr;
+
+	LOG("getting entry\n");
+
+	if (f->anglearg_len == 0) {
+		LOG("getting from argv[%d] (argc: %d)\n", *argi, argc);
+		if (*argi >= argc)
+			rb_raise(rb_eArgError, "too few arguments");
+		entry = rb_ary_entry(*argv, *argi);
+		(*argi)++;
+		return entry;
+	}
+
+	LOG("getting from hash\n");
+
+	tmpw = f->anglearg_start;
+	len = wcsnrtombs(NULL, &tmpw, f->anglearg_len, 0, NULL);
+	LOG("allocating %d, maxlen %d\n", len, f->anglearg_len);
+
+	cstr = calloc(len + 1, sizeof(char));
+	wcsnrtombs(cstr, &tmpw, f->anglearg_len, len, NULL);
+	LOG("wrote cstr %s\n", cstr);
+
+	LOG("symbol | cstr: '%s', len %d\n", cstr, len);
+
+	sym = rb_check_symbol_cstr(cstr, len, enc);
+	entry = rb_hash_lookup2(*hash, sym, Qnil);
+	if (entry == Qnil)
+		rb_raise(rb_eKeyError, "missing key :%s", cstr);
+	free(cstr);
+
+	return entry;
+}
+
+wchar_t *rb_apformat(wchar_t *fmt, size_t argc, size_t *argi, VALUE *argv, VALUE *hash)
+{
+	struct fmte *f, *head;
+	wchar_t *final;
+	int loop = 1;
+	long *tmpi;
+	wint_t *tmpc;
+	wchar_t *tmps;
+	double *tmpd;
+	void *tmp;
+	VALUE entry;
+
+	head = f = parsef(&fmt);
+
+	while (loop) {
+		if (apf_err != apfe_none)
+			rb_raise(rb_eArgError, "malformed format string");
+
+		LOG("scanned type: %d\n", f->type);
+
+		if (f->type != FEnd && f->type != FRaw)
+			entry = get_entry(f, argc, argi, argv, hash);
+		else
+			entry = Qnil;
+
+		switch (f->type) {
+		case FString:
+			Check_Type(entry, T_STRING);
+
+			tmp = rbstowcs(entry);
+			goto match;
+		case FTern:
+			tmpi = malloc(sizeof(long));
+
+			*tmpi = (entry == Qfalse || entry == Qnil) ? 0 : 1;
+
+			tmp = tmpi;
+			goto match;
+		case FMul:
+		case FAlign:
+		case FInt:
+			Check_Type(entry, T_FIXNUM);
+
+			tmpi = malloc(sizeof(long));
+			*tmpi = FIX2LONG(entry);
+			tmp = tmpi;
+			goto match;
+		case FChar:
+			Check_Type(entry, T_STRING);
+
+			tmpc = malloc(sizeof(wint_t));
+			tmps = rbstowcs(entry);
+			*tmpc = btowc(tmps[0]);
+			tmp = tmpc;
+			goto match;
+		case FDouble:
+			Check_Type(entry, T_FLOAT);
+
+			tmpd = malloc(sizeof(double));
+			*tmpd = RFLOAT_VALUE(entry);
+			tmp = tmpd;
+match:
+			f->value = tmp;
+			break;
+		case FRaw:
+			break;
+		case FEnd:
+			LOG("EOS (end of string)\n");
+			loop = 0;
+			break;
+		case FNone:
+			LOG("error! shouldn' t be none\n");
+			break;
+		}
+
+		LOG("pushing fmt\n");
+#ifdef DEBUG
+		fmte_inspect(f);
+#endif
+		fmte_push(head, f);
+		if (loop)
+			f = parsef(&fmt);
+	}
+
+	LOG("got all fmt elements\n");
+	final = assemble_fmt(head);
+	fmte_destroy(head);
+	return final;
+}
+
+VALUE rb_altprintf(long passes, size_t argc, VALUE *argv, VALUE self)
+{
+	VALUE fmt, args, hash, final;
+	wchar_t *wfmt;
+	wchar_t *formatted;
+	size_t argi;
+
+	apf_err = apfe_none;
+	rb_scan_args(argc, argv, "1*:", &fmt, &args, &hash);
+	argc--;
+
+	if (hash == Qnil && RB_TYPE_P(argv[argc - 1], T_HASH)) {
+		hash = argv[argc - 1];
+		argc--;
+	}
+
+	if (passes == 0)
+		return fmt;
+
+	wfmt = rbstowcs(fmt);
+	formatted = NULL;
+
+	argi = 0;
+	for (; passes > 0; passes--) {
+		LOG("wfmt: %ls\n", wfmt);
+
+		formatted = rb_apformat(wfmt, argc, &argi, &args, &hash);
+
+		LOG("formatted result: '%ls'\n", formatted);
+
+		free(wfmt);
+		wfmt = formatted;
+	}
+
+
+	LOG("final: '%ls'\n", formatted);
+	final = wcstorbs(formatted);
+
+	free(formatted);
+
+	return final;
+}
+
+VALUE rb_altprintf_single_pass(size_t argc, VALUE *argv, VALUE self)
+{
+	return rb_altprintf(1, argc, argv, self);
+}
+
+VALUE rb_altprintf_multi_pass(size_t argc, VALUE *argv, VALUE self)
+{
+	long passes;
+
+	Check_Type(argv[0], T_FIXNUM);
+	passes = FIX2LONG(argv[0]);
+	if (passes < 0)
+		rb_raise(rb_eArgError, "expected positive number of passes");
+
+	LOG("passes: %ld\n", passes);
+	return rb_altprintf(passes, argc - 1, &argv[1], self);
+}
+
+void Init_altprintf()
+{
+	VALUE mod, ver;
+	size_t len;
+
+	enc = rb_enc_find("UTF-8");
+	mod = rb_define_module(MODNAME);
+
+	len = strlen(ALTPRINTF_VERSION);
+	ver = rb_external_str_new_with_enc(ALTPRINTF_VERSION, len, enc);
+	rb_define_const(mod, "LIB_VERSION", ver);
+
+	rb_define_module_function(mod, "fmt", rb_altprintf_single_pass, -1);
+	rb_define_module_function(mod, "fmtm", rb_altprintf_multi_pass, -1);
+}

data/ext/altprintf/extconf.h

@@ -0,0 +1 @@
+

data/ext/altprintf/extconf_helper.rb

@@ -0,0 +1,35 @@
+require 'mkmf'
+
+module ExtconfHelper
+  BASE_DIR = File.join(__dir__, '../../../')
+
+  module_function
+
+  def dev_header
+    find_header('altprintf.h', File.join(BASE_DIR, 'src'))
+  end
+
+  def dev_objs(folder = 'release')
+    $objs = Dir[File.join(BASE_DIR, "target/#{folder}/*.o")] + ['ext.o']
+  end
+
+  def setup(mode = 'release')
+    puts "extconf setting up #{mode}"
+    case mode
+    when 'release'
+      # do nothing
+    when 'dev'
+      dev_header
+      dev_objs('release')
+    when 'debug'
+      dev_header
+      $defs.push("-DDEBUG")
+      dev_objs('debug')
+    else
+      raise(ArgumentError, "invalid mode #{mode}")
+    end
+
+    create_header
+    create_makefile('altprintf')
+  end
+end

data/ext/altprintf/fmt.c

@@ -0,0 +1,243 @@
+#include "fmt.h"
+
+#define BUFNUM 25
+
+#define CHECKNULL(p) if (p == NULL) { apf_err = apfe_missing_argument; return; }
+
+enum altprintf_err apf_err;
+
+void fmt_mul(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->value);
+
+	long *i;
+
+	i = f->value;
+	if (f->parenarg_start == NULL)
+		strbuf_pad(sb, f->chararg, *i);
+	else
+		for (int j = 0; j < *i; j++)
+			strbuf_append_str(sb, f->parenarg_start, -f->parenarg_len);
+}
+
+void fmt_tern(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->parenarg_start);
+	CHECKNULL(f->value);
+
+	long int *b = f->value;
+	int first_half = 1;
+	wchar_t sep = f->chararg;
+	wchar_t *p = f->parenarg_start;
+	for (; p <= f->parenarg_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);
+	}
+}
+
+wchar_t process_escape_seq(wchar_t seq)
+{
+	switch (seq) {
+	case FS_ESC_NL:
+		return L'\n';
+	case FS_ESC_ESC:
+		return L'\e';
+	case 'a':
+		return L'\a';
+	case 'b':
+		return L'\b';
+	case 'f':
+		return L'\f';
+	case 'r':
+		return L'\r';
+	case 't':
+		return L'\t';
+	case 'v':
+		return L'\v';
+	default:
+		return seq;
+	}
+}
+
+void fmt_raw(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->parenarg_start);
+
+	wchar_t *p;
+	wchar_t c;
+	long i;
+
+	p = f->parenarg_start;
+	i = f->parenarg_len;
+
+	for (; i > 0; i--) {
+		LOG("p is '%lc' (%ld)\n", (wint_t)*p, (long)*p);
+		c = (i > 1 && *p == FS_ESC) ? process_escape_seq(*++p) : *p;
+
+		strbuf_append(sb, c);
+		p++;
+		if (*p == EOS)
+			break;
+	}
+}
+
+void fmt_string(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->value);
+
+	int prec = f->prec == -1 ? 100000000 : f->prec;
+	strbuf_append_str(sb, f->value, prec);
+}
+
+void fmt_char(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->value);
+	strbuf_append_char(sb, f->value);
+}
+
+void fmt_int(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->value);
+	strbuf_append_int(sb, f->value);
+}
+
+void fmt_double(struct strbuf *sb, struct fmte *f)
+{
+	CHECKNULL(f->value);
+	int prec = f->prec == -1 ? 3 : f->prec;
+	strbuf_append_double(sb, f->value, prec);
+}
+
+void fmt(struct strbuf *sb, struct fmte *f, void (*fmtr)(struct strbuf *, struct fmte *))
+{
+	struct strbuf *tmp = strbuf_new();
+
+	fmtr(tmp, f);
+
+	if (tmp->len == 0) {
+		strbuf_destroy(tmp);
+		return;
+	}
+
+	int pad = f->pad > 0 ? f->pad - strbuf_width(tmp) : 0;
+
+	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 *assemble_fmt(struct fmte *head)
+{
+	struct fmte *f = head;
+	struct strbuf *bufs[BUFNUM];
+	struct fmte *splits[BUFNUM];
+	size_t buf = 0, i;
+	size_t w, tw, rw;
+	wchar_t *final;
+
+	void (*fmtr)(struct strbuf *, struct fmte *) = NULL;
+	int loop = 1;
+
+	bufs[buf] = strbuf_new();
+
+	LOG("assembling elements\n");
+	while (loop) {
+		switch (f->type) {
+		case FMul:
+			fmtr = fmt_mul;
+			break;
+		case FTern:
+			fmtr = fmt_tern;
+			break;
+		case FInt:
+			fmtr = fmt_int;
+			break;
+		case FChar:
+			fmtr = fmt_char;
+			break;
+		case FDouble:
+			fmtr = fmt_double;
+			break;
+		case FString:
+			fmtr = fmt_string;
+			break;
+		case FRaw:
+			fmtr = fmt_raw;
+			break;
+
+		case FAlign:
+			buf++;
+			splits[buf] = f;
+			bufs[buf] = strbuf_new();
+			fmtr = NULL;
+			break;
+		case FEnd:
+			loop = 0;
+			fmtr = NULL;
+			break;
+		case FNone:
+			fmtr = NULL;
+			break;
+		}
+
+		if (fmtr != NULL)
+			fmt(bufs[buf], f, fmtr);
+		f = f->next;
+	}
+
+	// Assemble splits
+	LOG("assembling %d splits\n", buf);
+	if (buf > 0)
+		tw = strbuf_width(bufs[0]);
+	for (i = 1; i <= buf; i++) {
+		rw = *(long*)splits[i]->value;
+
+		if (tw > rw) {
+			LOG("trimming first half to width\n");
+			strbuf_destroy(bufs[i]);
+			bufs[i] = bufs[0];
+			bufs[0] = strbuf_new();
+			strbuf_appendw_strbuf(bufs[0], bufs[i], rw);
+		} else {
+			if (rw > strbuf_width(bufs[i]) + tw) {
+				w = rw - (strbuf_width(bufs[i]) + tw);
+				LOG("padding %d\n", w);
+				strbuf_pad(bufs[0], splits[i]->chararg, w);
+				strbuf_append_strbuf(bufs[0], bufs[i]);
+			} else {
+				LOG("%d %d %d\n", w, rw, tw);
+				strbuf_appendw_strbuf(bufs[0], bufs[i], rw - tw);
+			}
+		}
+
+		tw = rw;
+	}
+
+	final = strbuf_cstr(bufs[0]);
+	for (i = 0; i <= buf; i++) strbuf_destroy(bufs[i]);
+	return final;
+}

data/ext/altprintf/fmt.h

@@ -0,0 +1,9 @@
+#ifndef FMT_H_
+#define FMT_H_
+#include "syntax.h"
+#include "strbuf.h"
+#include "fmte.h"
+#include "log.h"
+
+wchar_t *assemble_fmt(struct fmte *);
+#endif

data/ext/altprintf/fmte.c

@@ -0,0 +1,98 @@
+#include "fmte.h"
+
+struct fmte *fmte_ini()
+{
+	struct fmte *f = malloc(sizeof(struct fmte));
+
+	f->parenarg_start = NULL;
+	f->parenarg_end = NULL;
+	f->parenarg_len = 0;
+
+	f->anglearg_start = NULL;
+	f->anglearg_end = NULL;
+	f->anglearg_len = 0;
+
+	f->chararg = L' ';
+	f->padchar = L' ';
+	f->type = FNone;
+	f->align = Right;
+	f->prec = -1;
+	f->pad = 0;
+	f->value = NULL;
+
+	f->next = NULL;
+
+	return f;
+}
+
+void fmte_push(struct fmte *a, struct fmte *b)
+{
+	if (a == b)
+		return;     // refuse to create an infinite loop
+
+	while (a->next != NULL) a = a->next;
+
+	a->next = b;
+}
+
+void fmte_destroy(struct fmte *f)
+{
+	struct fmte *j;
+
+	while (f != NULL) {
+		j = f->next;
+		free(f->value);
+		free(f);
+		f = j;
+	}
+}
+
+void fmte_inspect(struct fmte *f)
+{
+	wchar_t *parenarg = calloc(f->parenarg_len + 1, sizeof(wchar_t));
+	wchar_t *anglearg = calloc(f->anglearg_len + 1, sizeof(wchar_t));
+	size_t i;
+
+	for (i = 0; i < f->parenarg_len; i++) parenarg[i] = f->parenarg_start[i];
+	for (i = 0; i < f->anglearg_len; i++) anglearg[i] = f->anglearg_start[i];
+
+	printf(
+		"Format@%p {\n\
+	parenarg_start: %p,\n\
+	parenarg_end: %p,\n\
+	parenarg_len: %ld,\n\
+	(parenarg): %ls,\n\
+	anglearg_start: %p,\n\
+	anglearg_end: %p,\n\
+	anglearg_len: %ld,\n\
+	(anglearg): %ls,\n\
+	chararg: %lc,\n\
+	padchar: %lc,\n\
+	type: %d,\n\
+	align: %d,\n\
+	prec: %ld,\n\
+	pad: %ld,\n\
+	value: %p,\n\
+	next: %p\n\
+}\n",
+		f,
+		f->parenarg_start,
+		f->parenarg_end,
+		(unsigned long)f->parenarg_len,
+		parenarg,
+		f->anglearg_start,
+		f->anglearg_end,
+		(unsigned long)f->anglearg_len,
+		anglearg,
+		f->chararg,
+		f->padchar,
+		f->type,
+		f->align,
+		f->prec,
+		f->pad,
+		f->value,
+		f->next);
+
+	free(parenarg);
+	free(anglearg);
+}

data/ext/altprintf/fmte.h

@@ -0,0 +1,37 @@
+#ifndef FMTE_H_
+#define FMTE_H_
+#include <wchar.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "enums.h"
+#include "log.h"
+
+struct fmte {
+	wchar_t *parenarg_start;
+	wchar_t *parenarg_end;
+	size_t parenarg_len;
+
+	wchar_t *anglearg_start;
+	wchar_t *anglearg_end;
+	size_t anglearg_len;
+
+	wint_t chararg;
+
+	wint_t padchar;
+
+	enum arg_type type;
+	enum align align;
+
+	long prec;
+	long pad;
+
+	void *value;
+
+	struct fmte *next;
+};
+
+struct fmte *fmte_ini();
+void fmte_inspect(struct fmte *);
+void fmte_push(struct fmte *, struct fmte *);
+void fmte_destroy(struct fmte *);
+#endif

data/ext/altprintf/log.h

@@ -0,0 +1,12 @@
+#ifndef LOG_H
+#define LOG_H
+
+#ifdef DEBUG
+#define LOG(...) printf("%s:%d [\e[35m%s\e[0m] ", __FILE__, __LINE__, __func__); 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/altprintf/parsef.c

@@ -0,0 +1,127 @@
+#include "parsef.h"
+
+wchar_t *altprintf_pct = L"%";
+
+struct fmte *parsef(wchar_t **fmt)
+{
+	wchar_t *w_c;
+	wchar_t **w_a = &w_c;
+	struct fmte *f = fmte_ini();
+	long *l_a = &f->pad;
+
+	LOG("processing %ld (%lc)\n", **fmt, (wint_t)**fmt);
+
+	if (**fmt != FS_START) {
+		if (**fmt == EOS) {
+			f->type = FEnd;
+			goto return_format;
+		}
+
+		LOG("building raw format\n");
+		f->type = FRaw;
+
+		f->parenarg_start = *fmt;
+		LOG("scanning long arg\n");
+		get_longarg(fmt, &f->parenarg_end, FS_START, &f->parenarg_len);
+
+		f->parenarg_end++;
+		f->parenarg_len++;
+		(*fmt)--;
+
+		goto return_format;
+	} else {
+		LOG("building format\n");
+		(*fmt)++;
+	}
+
+	for (; **fmt != L'\0'; (*fmt)++) {
+		LOG("scanned char '%lc'\n", (wint_t)(**fmt));
+		switch (**fmt) {
+		case FS_A_CHARARG:
+			(*fmt)++;
+			f->chararg = **fmt;
+			break;
+		case FS_A_ANGLEARG_S:
+			f->anglearg_start = *fmt + 1;
+			get_longarg(fmt, &f->anglearg_end, FS_A_ANGLEARG_E, &f->anglearg_len);
+			break;
+		case FS_A_PARENARG_S:
+			f->parenarg_start = *fmt + 1;
+			get_longarg(fmt, &f->parenarg_end, FS_A_PARENARG_E, &f->parenarg_len);
+			break;
+		case FS_A_LALIGN:
+			f->align = Left;
+			break;
+		case FS_A_CALIGN:
+			f->align = Center;
+			break;
+		case FS_A_SPAD:
+			f->padchar = FS_A_SPAD;
+			break;
+		case FS_A_ZPAD:
+			f->padchar = '0';
+			break;
+		case FS_A_PREC:
+			l_a = &f->prec;
+			break;
+		case '1': case '2': case '3': case '4': case '5':
+		case '6': case '7': case '8': case '9':
+			LOG("l_a: %p %ld\n", l_a, *l_a);
+			*l_a = wcstol(*fmt, w_a, 10);
+			*fmt = *w_a - 1;
+			break;
+		// Psuedo-type
+		case FS_START:
+			f->type = FRaw;
+			f->parenarg_start = &altprintf_pct[0];
+			f->parenarg_end = &altprintf_pct[1];
+			f->parenarg_len = 1;
+			goto return_format;
+		// Types
+		case FS_T_STRING:
+			f->type = FString;
+			goto return_format;
+		case FS_T_MUL:
+			f->type = FMul;
+			goto return_format;
+		case FS_T_TERN:
+			f->type = FTern;
+			goto return_format;
+		case FS_T_ALIGN:
+			f->type = FAlign;
+			goto return_format;
+		case FS_T_INT:
+			f->type = FInt;
+			goto return_format;
+		case FS_T_CHAR:
+			f->type = FChar;
+			goto return_format;
+		case FS_T_DOUBLE:
+			f->type = FDouble;
+			goto return_format;
+		default:
+			apf_err = apfe_invalid_token;
+			f->type = FRaw;
+		}
+	}
+
+	f->type = FEnd;
+return_format:
+	(*fmt)++;
+	return f;
+}
+
+void get_longarg(wchar_t **s, wchar_t **e, wchar_t stop, size_t *size)
+{
+	*size = 0;
+
+	while (**s != EOS && **s != stop) {
+		LOG("checking (%lc)\n", (wint_t)**s);
+		(*s)++;
+		(*size)++;
+	}
+
+	(*size)--;
+	if (*size > 0)
+		*e = *s - 1;
+}

data/ext/altprintf/parsef.h

@@ -0,0 +1,10 @@
+#ifndef PARSEF_H_
+#define PARSEF_H_
+#include "fmte.h"
+#include "syntax.h"
+#include "log.h"
+
+void get_longarg(wchar_t **, wchar_t **, wchar_t, size_t *);
+struct fmte *parsef(wchar_t **);
+
+#endif

data/ext/altprintf/strbuf.c

@@ -0,0 +1,178 @@
+#include "strbuf.h"
+
+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\n");
+		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\n");
+		exit(1);
+	}
+
+	sb->len = 0;
+	sb->cap = STRBUF_INI_SIZE;
+	sb->width = 0;
+	return sb;
+}
+
+size_t strbuf_width(struct strbuf *sb)
+{
+	if (sb->width == 0)
+		sb->width = wcswidth(sb->start, sb->len);
+
+	return sb->width;
+}
+
+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++;
+}
+
+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;
+	int maxlen = -1;
+
+	if (maxwidth < 0)
+		maxlen = maxwidth * -1;
+
+	for (; s < end; s++) {
+		if (maxlen >= 0) {
+			width++;
+			if (width > maxlen)
+				return;
+		} else {
+			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[TMPLEN];
+	long len = swprintf(wcs, TMPLEN - 1, L"%ld", *i);
+
+	if (len < 0)
+		strbuf_append_str(sb, L"error adding int", 16);
+	else
+		strbuf_append_str(sb, wcs, -1 * len);
+}
+
+void strbuf_append_double(struct strbuf *sb, void *dub, int prec)
+{
+	double *d = dub;
+	wchar_t wcs[TMPLEN];
+	wchar_t format[TMPLEN];
+	int rprec = prec;
+
+	if (rprec > MAXPREC)
+		rprec = MAXPREC;
+
+	swprintf(format, TMPLEN - 1, L"%%.%ldf", rprec);
+
+	LOG("format: %ls\n", format);
+
+	long len = swprintf(wcs, TMPLEN - 1, format, *d);
+	if (len < 0) {
+		strbuf_append_str(sb, L"error adding float", 18);
+	} else {
+		LOG("inserting double: len: %ld\n", len);
+		strbuf_append_str(sb, wcs, len);
+
+		if (rprec < prec)
+			strbuf_pad(sb, L'0', rprec - prec);
+	}
+}
+
+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/altprintf/strbuf.h

@@ -0,0 +1,38 @@
+#ifndef STRBUF_H
+#define STRBUF_H
+
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE
+#endif
+
+#include <wchar.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "log.h"
+
+#define STRBUF_INI_SIZE 5
+#define STRBUF_GROW_STEP 100
+#define TMPLEN 50
+#define MAXPREC 25
+
+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 *);
+size_t strbuf_width(struct strbuf *);
+
+struct strbuf {
+	wchar_t *start;
+	wchar_t *end;
+	size_t len;
+	size_t width;
+	size_t cap;
+};
+#endif

data/ext/altprintf/syntax.h

@@ -0,0 +1,35 @@
+#ifndef SYNTAX_H
+#define SYNTAX_H
+
+#define FS_START    '%'
+#define FS_DOUBLE_SEP '.'
+
+#define FS_ESC L'\\'
+#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_PARENARG_S '('
+#define FS_A_PARENARG_E ')'
+#define FS_A_ANGLEARG_S '<'
+#define FS_A_ANGLEARG_E '>'
+
+#define FS_A_CHARARG     '~'
+#define FS_A_LALIGN      '-'
+#define FS_A_CALIGN      '^'
+#define FS_A_SPAD        ' '
+#define FS_A_ZPAD        '0'
+#define FS_A_PREC        '.'
+
+#define FS_D_PREC   100
+
+#define EOS L'\0'
+
+#endif

data/lib/altprintf.rb

@@ -0,0 +1,2 @@
+require_relative 'altprintf/altprintf'
+require_relative 'altprintf/version'

data/lib/altprintf/version.rb

@@ -0,0 +1,3 @@
+module Altprintf
+  VERSION = [0, 2, 4]
+end

data/readme.md

@@ -0,0 +1,16 @@
+# Altprintf
+
+[rubygems.org/gems/altprintf](https://rubygems.org/gems/altprintf)
+
+altprintf is a gem that wraps `../altprintf`.
+
+It exposes the following module functions
+
++ `Altprintf#fmt(format_string, *args, **kwargs)`
++ `Altprintf#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.

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: altprintf
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Stone Tickle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-27 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: []
+extra_rdoc_files: []
+files:
+- altprintf.gemspec
+- ext/altprintf/altprintf.h
+- ext/altprintf/enums.h
+- ext/altprintf/ext.c
+- ext/altprintf/extconf.h
+- ext/altprintf/extconf_helper.rb
+- ext/altprintf/fmt.c
+- ext/altprintf/fmt.h
+- ext/altprintf/fmte.c
+- ext/altprintf/fmte.h
+- ext/altprintf/log.h
+- ext/altprintf/parsef.c
+- ext/altprintf/parsef.h
+- ext/altprintf/strbuf.c
+- ext/altprintf/strbuf.h
+- ext/altprintf/syntax.h
+- lib/altprintf.rb
+- lib/altprintf/alt_printf.so
+- lib/altprintf/altprintf.so
+- lib/altprintf/version.rb
+- readme.md
+homepage: https://github.com/annacrombie/altprintf/tree/master/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.5.5
+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: []