altprintf 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df338e1fe04766f80321b04dc0380e6c022ae06c8e4d13cbaea05522630b7463
-  data.tar.gz: 9b7c74147e5ef03e947467d2c4c89e7471c873a56410d2aa00f4015680352c96
+  metadata.gz: 30fe21097d8d96fc45f13bf03bc0c66c73cabd30e27d9a5829d33022e54d21fb
+  data.tar.gz: 2e3974374ac51f2f6750cdf48b660711ac9c4de60c14a9ba3c239a345cf9541d
 SHA512:
-  metadata.gz: ba342f2d892020efc12b7e0489a376b005fb2161b81ae235ac9021d04f7d594c9bda20e0c8c1a332a607a4897688faa34143c2bd1dcb100f6b71611992eeaa30
-  data.tar.gz: c19648ebefd35dbdf6b00760e92567be3f42c042227ba3e49d32f9595dcec29ce67ca47169c2f64ca1c164b199e3050c8a912403a1a28855c89b54084026a49d
+  metadata.gz: 5dfa57f474993381bd7c9c5704b09a867d02795abaa10f6fda6bc6a64a76b6c970bc80af41f225ef6dd98b610013b75eb2b101661dddea7e7407f06f3dc21bb2
+  data.tar.gz: 95b00d639a18eaccb25105c80129cab7f651c7f3cb5bcc0836177c06ad0170548e8abd6849e48efed84fca54c1750b411f5f736c87e4e1940488e41a1d5c5b67

data/altprintf.gemspec

@@ -17,8 +17,10 @@ Altprintf::SPEC = Gem::Specification.new do |s|
   s.extensions = Dir["ext/**/extconf.rb"]
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 2.5.5'
+  s.required_ruby_version = '>= 2.5.7'
 
+  s.add_development_dependency 'benchmark-ips', '~> 2.7'
   s.add_development_dependency 'rake-compiler', '~> 1.0'
   s.add_development_dependency 'rake', '~> 12.3'
+  s.add_development_dependency 'rspec', '~> 3.9'
 end unless Altprintf.const_defined?(:'SPEC')

data/ext/altprintf/altprintf/altprintf.h

@@ -0,0 +1,8 @@
+#ifndef ALTPRINTF_H_
+#define ALTPRINTF_H_
+#define ALTPRINTF_VERSION "0.3.0"
+
+#include <altprintf/fmt.h>
+#include <altprintf/fmte.h>
+#include <altprintf/parsef.h>
+#endif

data/ext/altprintf/altprintf/cwidth.h

@@ -0,0 +1,6 @@
+#ifndef _CWIDTH_H
+#define _CWIDTH_H
+#include <stdlib.h>
+int cswidth(const char *utf8, size_t maxlen);
+int cwidth(const char* utf8);
+#endif

data/ext/altprintf/{enums.h → altprintf/enums.h}

@@ -1,5 +1,5 @@
-#ifndef ARGTYPE_H_
-#define ARGTYPE_H_
+#ifndef _ALTPRINTF_ENUM_H
+#define _ALTPRINTF_ENUM_H
 enum arg_type { FMul, FTern, FAlign, FInt, FChar, FDouble, FString, FRaw, FNone,
 		FEnd };
 enum align { Left, Right, Center };
@@ -11,5 +11,4 @@ enum altprintf_err {
 };
 
 extern enum altprintf_err apf_err;
-
 #endif

data/ext/altprintf/altprintf/fmt.h

@@ -0,0 +1,5 @@
+#ifndef FMT_H_
+#define FMT_H_
+#include <altprintf/fmte.h>
+char *assemble_fmt(struct fmte *);
+#endif

data/ext/altprintf/{fmte.h → altprintf/fmte.h}

@@ -1,23 +1,20 @@
 #ifndef FMTE_H_
 #define FMTE_H_
-#include <wchar.h>
 #include <stdlib.h>
-#include <stdio.h>
-#include "enums.h"
-#include "log.h"
+#include <altprintf/enums.h>
 
 struct fmte {
-	wchar_t *parenarg_start;
-	wchar_t *parenarg_end;
+	const char *parenarg_start;
+	const char *parenarg_end;
 	size_t parenarg_len;
 
-	wchar_t *anglearg_start;
-	wchar_t *anglearg_end;
+	const char *anglearg_start;
+	const char *anglearg_end;
 	size_t anglearg_len;
 
-	wint_t chararg;
+	char chararg;
 
-	wint_t padchar;
+	char padchar;
 
 	enum arg_type type;
 	enum align align;
@@ -30,7 +27,7 @@ struct fmte {
 	struct fmte *next;
 };
 
-struct fmte *fmte_ini();
+struct fmte *fmte_ini(void);
 void fmte_inspect(struct fmte *);
 void fmte_push(struct fmte *, struct fmte *);
 void fmte_destroy(struct fmte *);

data/ext/altprintf/altprintf/parsef.h

@@ -0,0 +1,6 @@
+#ifndef PARSEF_H_
+#define PARSEF_H_
+#include <stdlib.h>
+
+struct fmte *parsef(const char **);
+#endif

data/ext/altprintf/altprintf/strbuf.h

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

data/ext/altprintf/{syntax.h → altprintf/syntax.h}

@@ -4,7 +4,7 @@
 #define FS_START    '%'
 #define FS_DOUBLE_SEP '.'
 
-#define FS_ESC L'\\'
+#define FS_ESC '\\'
 #define FS_ESC_NL 'n'
 #define FS_ESC_ESC 'e'
 
@@ -24,12 +24,11 @@
 #define FS_A_CHARARG     '~'
 #define FS_A_LALIGN      '-'
 #define FS_A_CALIGN      '^'
-#define FS_A_SPAD        ' '
-#define FS_A_ZPAD        '0'
+#define FS_A_PAD         '_'
 #define FS_A_PREC        '.'
 
 #define FS_D_PREC   100
 
-#define EOS L'\0'
+#define EOS '\0'
 
 #endif

data/ext/altprintf/ext.c

@@ -9,56 +9,40 @@
 #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"
+#include <altprintf/altprintf.h>
+#include <altprintf/log.h>
 
 #define MODNAME "Altprintf"
 
 rb_encoding *enc;
 
-wchar_t *rbstowcs(VALUE str)
+char *rbstocs(VALUE *rbstr)
 {
-	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);
+	char *p, *tmp;
+	long len;
 
-	LOG("rbs to wcs, len: %d, cstr: '%s'\n", len, cstr);
-	LOG("wide string: '%ls'\n", wstr);
+	p = StringValuePtr(*rbstr);
+	len = RSTRING_LEN(*rbstr);
+	tmp = calloc(len + 1, sizeof(char));
+	strncpy(tmp, p, len);
+	tmp[len] = '\0';
 
-	return wstr;
+	return tmp;
 }
 
-VALUE wcstorbs(const wchar_t *wstr)
+VALUE cstorbs(const char *cstr)
 {
 	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);
+	len = strlen(cstr);
 
 	if (len == (size_t)-1)
 		return Qnil;
 
 	str = rb_external_str_new_with_enc(cstr, len, enc);
-	free(cstr);
 
 	return str;
 }
@@ -66,9 +50,6 @@ VALUE wcstorbs(const wchar_t *wstr)
 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");
 
@@ -81,35 +62,22 @@ VALUE get_entry(struct fmte *f, size_t argc, size_t *argi, VALUE *argv, VALUE *h
 		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);
+	sym = rb_check_symbol_cstr(f->anglearg_start, f->anglearg_len, enc);
 	entry = rb_hash_lookup2(*hash, sym, Qnil);
 	if (entry == Qnil)
-		rb_raise(rb_eKeyError, "missing key :%s", cstr);
-	free(cstr);
+		rb_raise(rb_eKeyError, "missing key " PRIsVALUE, sym);
 
 	return entry;
 }
 
-wchar_t *rb_apformat(wchar_t *fmt, size_t argc, size_t *argi, VALUE *argv, VALUE *hash)
+char *rb_apformat(const char *fmt, size_t argc, size_t *argi, VALUE *argv, VALUE *hash)
 {
 	struct fmte *f, *head;
-	wchar_t *final;
+	char *final;
 	int loop = 1;
 	long *tmpi;
-	wint_t *tmpc;
-	wchar_t *tmps;
+	char *tmpc;
+	char *tmps;
 	double *tmpd;
 	void *tmp;
 	VALUE entry;
@@ -131,7 +99,7 @@ wchar_t *rb_apformat(wchar_t *fmt, size_t argc, size_t *argi, VALUE *argv, VALUE
 		case FString:
 			Check_Type(entry, T_STRING);
 
-			tmp = rbstowcs(entry);
+			tmp = rbstocs(&entry);
 			goto match;
 		case FTern:
 			tmpi = malloc(sizeof(long));
@@ -152,9 +120,9 @@ wchar_t *rb_apformat(wchar_t *fmt, size_t argc, size_t *argi, VALUE *argv, VALUE
 		case FChar:
 			Check_Type(entry, T_STRING);
 
-			tmpc = malloc(sizeof(wint_t));
-			tmps = rbstowcs(entry);
-			*tmpc = btowc(tmps[0]);
+			tmpc = malloc(sizeof(char));
+			tmps = StringValueCStr(entry);
+			*tmpc = tmps[0];
 			tmp = tmpc;
 			goto match;
 		case FDouble:
@@ -188,6 +156,7 @@ match:
 
 	LOG("got all fmt elements\n");
 	final = assemble_fmt(head);
+	LOG("assembled fmt: %s", final);
 	fmte_destroy(head);
 	return final;
 }
@@ -195,9 +164,10 @@ match:
 VALUE rb_altprintf(long passes, size_t argc, VALUE *argv, VALUE self)
 {
 	VALUE fmt, args, hash, final;
-	wchar_t *wfmt;
-	wchar_t *formatted;
+	char *wfmt;
+	char *formatted;
 	size_t argi;
+	int free_wfmt;
 
 	apf_err = apfe_none;
 	rb_scan_args(argc, argv, "1*:", &fmt, &args, &hash);
@@ -211,24 +181,28 @@ VALUE rb_altprintf(long passes, size_t argc, VALUE *argv, VALUE self)
 	if (passes == 0)
 		return fmt;
 
-	wfmt = rbstowcs(fmt);
+	free_wfmt = 0;
+	wfmt = StringValueCStr(fmt);
 	formatted = NULL;
 
 	argi = 0;
 	for (; passes > 0; passes--) {
-		LOG("wfmt: %ls\n", wfmt);
+		LOG("wfmt: %s\n", wfmt);
 
 		formatted = rb_apformat(wfmt, argc, &argi, &args, &hash);
 
-		LOG("formatted result: '%ls'\n", formatted);
+		LOG("formatted result: '%s'\n", formatted);
 
-		free(wfmt);
+		if (free_wfmt)
+			free(wfmt);
+		else
+			free_wfmt = 1;
 		wfmt = formatted;
 	}
 
 
-	LOG("final: '%ls'\n", formatted);
-	final = wcstorbs(formatted);
+	LOG("final: '%s'\n", formatted);
+	final = cstorbs(formatted);
 
 	free(formatted);
 

data/ext/altprintf/extconf_helper.rb

@@ -2,15 +2,23 @@ require 'mkmf'
 
 module ExtconfHelper
   BASE_DIR = File.join(__dir__, '../../../')
+  SRC_DIR = File.join(BASE_DIR, 'subprojects/libaltprintf/src/')
+  BUILD_DIR = File.join(BASE_DIR, 'build')
+  LIB_DIR = File.join(BUILD_DIR, 'subprojects/libaltprintf/')
+  INC_DIR = File.join(BASE_DIR, 'subprojects/libaltprintf/include')
 
   module_function
 
-  def dev_header
-    find_header('altprintf.h', File.join(BASE_DIR, 'src'))
-  end
+  def dev_setup
+    unless find_header('altprintf/altprintf.h', INC_DIR)
+      $stderr.puts("couldn't find header 'altprintf.h'")
+      exit(1)
+    end
 
-  def dev_objs(folder = 'release')
-    $objs = Dir[File.join(BASE_DIR, "target/#{folder}/*.o")] + ['ext.o']
+    unless find_library('altprintf', 'parsef', LIB_DIR)
+      $stderr.puts("you haven't built libaltprintf yet")
+      exit(1)
+    end
   end
 
   def setup(mode = 'release')
@@ -19,12 +27,7 @@ module ExtconfHelper
     when 'release'
       # do nothing
     when 'dev'
-      dev_header
-      dev_objs('release')
-    when 'debug'
-      dev_header
-      $defs.push("-DDEBUG")
-      dev_objs('debug')
+      dev_setup
     else
       raise(ArgumentError, "invalid mode #{mode}")
     end

data/ext/altprintf/fmt.c

@@ -1,8 +1,17 @@
-#include "fmt.h"
+#include <altprintf/syntax.h>
+#include <altprintf/strbuf.h>
+#include <altprintf/fmte.h>
+#include <altprintf/log.h>
+#include <altprintf/fmt.h>
 
 #define BUFNUM 25
 
-#define CHECKNULL(p) if (p == NULL) { apf_err = apfe_missing_argument; return; }
+#define CHECKNULL(p) do {                                \
+		if (p == NULL) {                         \
+			apf_err = apfe_missing_argument; \
+			return;                          \
+		}                                        \
+} while (0)
 
 enum altprintf_err apf_err;
 
@@ -27,10 +36,11 @@ void fmt_tern(struct strbuf *sb, struct fmte *f)
 
 	long int *b = f->value;
 	int first_half = 1;
-	wchar_t sep = f->chararg;
-	wchar_t *p = f->parenarg_start;
+	char sep = f->chararg;
+	const char *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);
+		LOG("*p: %lc, first half? %d, bool: %ld, sep: %lc\n",
+		    (char)*p, first_half, *b, (char)sep);
 		if (*p == sep)
 			first_half = 0;
 		else if (*b && first_half)
@@ -40,25 +50,25 @@ void fmt_tern(struct strbuf *sb, struct fmte *f)
 	}
 }
 
-wchar_t process_escape_seq(wchar_t seq)
+char process_escape_seq(char seq)
 {
 	switch (seq) {
 	case FS_ESC_NL:
-		return L'\n';
+		return '\n';
 	case FS_ESC_ESC:
-		return L'\e';
+		return '\e';
 	case 'a':
-		return L'\a';
+		return '\a';
 	case 'b':
-		return L'\b';
+		return '\b';
 	case 'f':
-		return L'\f';
+		return '\f';
 	case 'r':
-		return L'\r';
+		return '\r';
 	case 't':
-		return L'\t';
+		return '\t';
 	case 'v':
-		return L'\v';
+		return '\v';
 	default:
 		return seq;
 	}
@@ -68,15 +78,15 @@ void fmt_raw(struct strbuf *sb, struct fmte *f)
 {
 	CHECKNULL(f->parenarg_start);
 
-	wchar_t *p;
-	wchar_t c;
+	const char *p;
+	char 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);
+		LOG("p is '%lc' (%ld)\n", (char)*p, (long)*p);
 		c = (i > 1 && *p == FS_ESC) ? process_escape_seq(*++p) : *p;
 
 		strbuf_append(sb, c);
@@ -150,14 +160,14 @@ void fmt(struct strbuf *sb, struct fmte *f, void (*fmtr)(struct strbuf *, struct
 	strbuf_destroy(tmp);
 }
 
-wchar_t *assemble_fmt(struct fmte *head)
+char *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;
+	char *final;
 
 	void (*fmtr)(struct strbuf *, struct fmte *) = NULL;
 	int loop = 1;

data/ext/altprintf/fmte.c

@@ -1,6 +1,10 @@
-#include "fmte.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <altprintf/enums.h>
+#include <altprintf/log.h>
+#include <altprintf/fmte.h>
 
-struct fmte *fmte_ini()
+struct fmte *fmte_ini(void)
 {
 	struct fmte *f = malloc(sizeof(struct fmte));
 
@@ -12,10 +16,10 @@ struct fmte *fmte_ini()
 	f->anglearg_end = NULL;
 	f->anglearg_len = 0;
 
-	f->chararg = L' ';
-	f->padchar = L' ';
+	f->chararg = ' ';
+	f->padchar = ' ';
 	f->type = FNone;
-	f->align = Right;
+	f->align = Left;
 	f->prec = -1;
 	f->pad = 0;
 	f->value = NULL;
@@ -49,8 +53,8 @@ void fmte_destroy(struct fmte *f)
 
 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));
+	char *parenarg = calloc(f->parenarg_len + 1, sizeof(char));
+	char *anglearg = calloc(f->anglearg_len + 1, sizeof(char));
 	size_t i;
 
 	for (i = 0; i < f->parenarg_len; i++) parenarg[i] = f->parenarg_start[i];
@@ -61,11 +65,11 @@ void fmte_inspect(struct fmte *f)
 	parenarg_start: %p,\n\
 	parenarg_end: %p,\n\
 	parenarg_len: %ld,\n\
-	(parenarg): %ls,\n\
+	(parenarg): %s,\n\
 	anglearg_start: %p,\n\
 	anglearg_end: %p,\n\
 	anglearg_len: %ld,\n\
-	(anglearg): %ls,\n\
+	(anglearg): %s,\n\
 	chararg: %lc,\n\
 	padchar: %lc,\n\
 	type: %d,\n\

data/ext/altprintf/parsef.c

@@ -1,15 +1,33 @@
-#include "parsef.h"
+#include <altprintf/fmte.h>
+#include <altprintf/syntax.h>
+#include <altprintf/log.h>
+#include <altprintf/parsef.h>
 
-wchar_t *altprintf_pct = L"%";
+char *altprintf_pct = "%";
 
-struct fmte *parsef(wchar_t **fmt)
+void get_longarg(const char **s, const char **e, char stop, size_t *size)
 {
-	wchar_t *w_c;
-	wchar_t **w_a = &w_c;
+	*size = 0;
+
+	while (**s != EOS && **s != stop) {
+		LOG("checking (%c)\n", **s);
+		(*s)++;
+		(*size)++;
+	}
+
+	(*size)--;
+	if (*size > 0)
+		*e = *s - 1;
+}
+
+struct fmte *parsef(const char **fmt)
+{
+	char *w_c;
+	char **w_a = &w_c;
 	struct fmte *f = fmte_ini();
 	long *l_a = &f->pad;
 
-	LOG("processing %ld (%lc)\n", **fmt, (wint_t)**fmt);
+	LOG("processing %d (%c)\n", **fmt, **fmt);
 
 	if (**fmt != FS_START) {
 		if (**fmt == EOS) {
@@ -34,8 +52,8 @@ struct fmte *parsef(wchar_t **fmt)
 		(*fmt)++;
 	}
 
-	for (; **fmt != L'\0'; (*fmt)++) {
-		LOG("scanned char '%lc'\n", (wint_t)(**fmt));
+	for (; **fmt != '\0'; (*fmt)++) {
+		LOG("scanned char '%c'\n", **fmt);
 		switch (**fmt) {
 		case FS_A_CHARARG:
 			(*fmt)++;
@@ -55,19 +73,18 @@ struct fmte *parsef(wchar_t **fmt)
 		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';
+		case FS_A_PAD:
+			(*fmt)++;
+			f->padchar = **fmt;
 			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':
+		case '6': case '7': case '8': case '9': case '0':
 			LOG("l_a: %p %ld\n", l_a, *l_a);
-			*l_a = wcstol(*fmt, w_a, 10);
+			*l_a = strtol(*fmt, w_a, 10);
+			LOG("read num: %ld\n", *l_a);
 			*fmt = *w_a - 1;
 			break;
 		// Psuedo-type
@@ -110,18 +127,3 @@ 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/strbuf.c

@@ -1,8 +1,18 @@
-#include "strbuf.h"
+#define STRBUF_INI_SIZE 5
+#define STRBUF_GROW_STEP 100
+#define TMPLEN 50
+#define MAXPREC 25
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <altprintf/log.h>
+#include <altprintf/strbuf.h>
+#include <altprintf/cwidth.h>
 
 extern struct lconv *locale_info;
 
-struct strbuf *strbuf_new()
+struct strbuf *strbuf_new(void)
 {
 	struct strbuf *sb = malloc(sizeof(struct strbuf));
 
@@ -11,7 +21,7 @@ struct strbuf *strbuf_new()
 		exit(1);
 	}
 
-	sb->start = sb->end = calloc(STRBUF_INI_SIZE, sizeof(wchar_t));
+	sb->start = sb->end = calloc(STRBUF_INI_SIZE, sizeof(char));
 
 	if (NULL == sb->start) {
 		LOG("can't alloc memory for new strbuf string\n");
@@ -27,7 +37,7 @@ struct strbuf *strbuf_new()
 size_t strbuf_width(struct strbuf *sb)
 {
 	if (sb->width == 0)
-		sb->width = wcswidth(sb->start, sb->len);
+		sb->width = cswidth(sb->start, sb->len);
 
 	return sb->width;
 }
@@ -38,36 +48,33 @@ void strbuf_destroy(struct strbuf *sb)
 	free(sb);
 }
 
-void strbuf_append(struct strbuf *sb, wchar_t c)
+void strbuf_append(struct strbuf *sb, char c)
 {
-	wchar_t *ns;
+	char *ns;
 
 	if (sb->cap < sb->len + 2) {
-		ns = calloc(sb->cap + STRBUF_GROW_STEP, sizeof(wchar_t));
+		ns = realloc(sb->start, (sb->cap + STRBUF_GROW_STEP) * sizeof(char));
 
 		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->start[sb->len + 1] = '\0';
+	LOG("string so far: %s\n", sb->start);
 	sb->end = &sb->start[sb->len];
 	sb->len++;
 }
 
-void strbuf_append_strbuf(struct strbuf *sb, void *sbuf)
+void strbuf_append_strbuf(struct strbuf *sb, const void *sbuf)
 {
-	wchar_t *pos;
-	struct strbuf *frm = sbuf;
+	char *pos;
+	const struct strbuf *frm = sbuf;
 
 	LOG("frm->start: %p | frm->end: %p\n", frm->start, frm->end);
 
@@ -75,16 +82,16 @@ void strbuf_append_strbuf(struct strbuf *sb, void *sbuf)
 		strbuf_append(sb, *pos);
 }
 
-void strbuf_appendw_strbuf(struct strbuf *sb, void *sbuf, long w)
+void strbuf_appendw_strbuf(struct strbuf *sb, const void *sbuf, long w)
 {
-	wchar_t *pos;
+	char *pos;
 	long ws = 0;
-	struct strbuf *frm = sbuf;
+	const 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);
+		ws += cwidth(pos);
 		LOG("new width would be: %ld, requested width: %ld\n", ws, w);
 		if (ws > w)
 			break;
@@ -92,17 +99,17 @@ void strbuf_appendw_strbuf(struct strbuf *sb, void *sbuf, long w)
 	}
 }
 
-void strbuf_append_char(struct strbuf *sb, void *chr)
+void strbuf_append_char(struct strbuf *sb, const void *chr)
 {
-	wint_t *c = chr;
+	const char *c = chr;
 
 	strbuf_append(sb, *c);
 }
 
-void strbuf_append_str(struct strbuf *sb, void *str, int maxwidth)
+void strbuf_append_str(struct strbuf *sb, const void *str, int maxwidth)
 {
-	wchar_t *s = str;
-	wchar_t *end = &s[wcslen(s)];
+	const char *s = str;
+	const char *end = &s[strlen(s)];
 	int width = 0;
 	int maxlen = -1;
 
@@ -115,7 +122,7 @@ void strbuf_append_str(struct strbuf *sb, void *str, int maxwidth)
 			if (width > maxlen)
 				return;
 		} else {
-			width += wcwidth(*s);
+			width += cwidth(s);
 			if (width > maxwidth)
 				return;
 		}
@@ -124,55 +131,56 @@ void strbuf_append_str(struct strbuf *sb, void *str, int maxwidth)
 	}
 }
 
-void strbuf_append_int(struct strbuf *sb, void *in)
+void strbuf_append_int(struct strbuf *sb, const void *in)
 {
-	long int *i = in;
-	wchar_t wcs[TMPLEN];
-	long len = swprintf(wcs, TMPLEN - 1, L"%ld", *i);
+	const long *i = in;
+	char wcs[TMPLEN];
+	long len = snprintf(wcs, TMPLEN - 1, "%ld", *i);
 
 	if (len < 0)
-		strbuf_append_str(sb, L"error adding int", 16);
+		strbuf_append_str(sb, "error adding int", 16);
 	else
 		strbuf_append_str(sb, wcs, -1 * len);
 }
 
-void strbuf_append_double(struct strbuf *sb, void *dub, int prec)
+void strbuf_append_double(struct strbuf *sb, const void *dub, int prec)
 {
-	double *d = dub;
-	wchar_t wcs[TMPLEN];
-	wchar_t format[TMPLEN];
+	const double *d = dub;
+	char wcs[TMPLEN];
+	char format[TMPLEN];
 	int rprec = prec;
 
 	if (rprec > MAXPREC)
 		rprec = MAXPREC;
 
-	swprintf(format, TMPLEN - 1, L"%%.%ldf", rprec);
+	snprintf(format, TMPLEN - 1, "%%.%df", rprec);
 
-	LOG("format: %ls\n", format);
+	LOG("format: %s\n", format);
 
-	long len = swprintf(wcs, TMPLEN - 1, format, *d);
+	long len = snprintf(wcs, TMPLEN - 1, format, *d);
 	if (len < 0) {
-		strbuf_append_str(sb, L"error adding float", 18);
+		strbuf_append_str(sb, "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);
+			strbuf_pad(sb, '0', rprec - prec);
 	}
 }
 
-void strbuf_pad(struct strbuf *sb, wchar_t pc, int amnt)
+void strbuf_pad(struct strbuf *sb, char pc, int amnt)
 {
 	for (; amnt > 0; amnt--) strbuf_append(sb, pc);
 }
 
-wchar_t *strbuf_cstr(struct strbuf *sb)
+char *strbuf_cstr(struct strbuf *sb)
 {
-	wchar_t *str;
+	char *cstr;
+
+	cstr = calloc(sb->len + 1, sizeof(char));
 
-	str = calloc(sb->len + 1, sizeof(wchar_t));
-	wcscpy(str, sb->start);
+	strncpy(cstr, sb->start, sb->len);
 
-	return str;
+	return cstr;
 }

data/lib/altprintf/version.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: altprintf
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Stone Tickle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2019-10-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
 description: 
 email: lattis@mochiro.moe
 executables: []
@@ -45,21 +73,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - altprintf.gemspec
-- ext/altprintf/altprintf.h
-- ext/altprintf/enums.h
+- ext/altprintf/altprintf/altprintf.h
+- ext/altprintf/altprintf/cwidth.h
+- ext/altprintf/altprintf/enums.h
+- ext/altprintf/altprintf/fmt.h
+- ext/altprintf/altprintf/fmte.h
+- ext/altprintf/altprintf/log.h
+- ext/altprintf/altprintf/parsef.h
+- ext/altprintf/altprintf/strbuf.h
+- ext/altprintf/altprintf/syntax.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
@@ -77,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.5
+      version: 2.5.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/ext/altprintf/altprintf.h

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

data/ext/altprintf/fmt.h

@@ -1,9 +0,0 @@
-#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/parsef.h

@@ -1,10 +0,0 @@
-#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.h

@@ -1,38 +0,0 @@
-#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