alt_printf 0.1.3 → 0.1.4

data/ext/alt_printf/enums.h

@@ -0,0 +1,6 @@
+#ifndef ARGTYPE_H_
+#define ARGTYPE_H_
+enum arg_type { FMul, FTern, FAlign, FInt, FChar, FDouble, FString, FRaw, FNone,
+	FEnd };
+enum align { Left, Right, Center };
+#endif

data/ext/alt_printf/extconf.h

@@ -0,0 +1 @@
+

data/ext/alt_printf/extconf.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-require 'mkmf'
 
-create_header
-create_makefile('alt_printf')
+require_relative 'extconf_helper'
+ExtconfHelper.setup

data/ext/alt_printf/extconf_debug.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative 'extconf_helper'
+ExtconfHelper.setup('debug')

data/ext/alt_printf/extconf_dev.rb

@@ -1,9 +1,4 @@
 #!/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')
+require_relative 'extconf_helper'
+ExtconfHelper.setup('dev')

data/ext/alt_printf/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")] + ['alt_printf.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('alt_printf')
+  end
+end

data/ext/alt_printf/fmt.c

@@ -0,0 +1,174 @@
+#include "fmt.h"
+
+#define BUFNUM 25
+
+void fmt_mul(struct strbuf *sb, struct fmte *f) {
+	long int *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) {
+	if (f->parenarg_start == NULL) return;
+
+	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);
+	}
+}
+
+void fmt_raw(struct strbuf *sb, struct fmte *f) {
+	strbuf_append_str(sb, f->parenarg_start, -1 * f->parenarg_len);
+}
+
+void fmt_string(struct strbuf *sb, struct fmte *f) {
+	int prec = f->prec == -1 ? 100000000 : f->prec;
+	strbuf_append_str(sb, f->value, prec);
+}
+
+void fmt_char(struct strbuf *sb, struct fmte *f) {
+	strbuf_append_char(sb, f->value);
+}
+
+void fmt_int(struct strbuf *sb, struct fmte *f) {
+	strbuf_append_int(sb, f->value);
+}
+
+void fmt_double(struct strbuf *sb, struct fmte *f) {
+	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 - 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 *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);
+	tw = bufs[0]->width;
+	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 > bufs[i]->width + tw) {
+				w = rw - (bufs[i]->width + 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/alt_printf/fmt.h

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

data/ext/alt_printf/fmte.c

@@ -0,0 +1,92 @@
+#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: %d,\n\
+	(parenarg): %ls,\n\
+	anglearg_start: %p,\n\
+	anglearg_end: %p,\n\
+	anglearg_len: %d,\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,
+	f->parenarg_len,
+	parenarg,
+	f->anglearg_start,
+	f->anglearg_end,
+	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/alt_printf/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/alt_printf/log.h

@@ -2,10 +2,11 @@
 #define LOG_H
 
 #ifdef DEBUG
-#define LOG(...) printf("%s[%d] - ", __FILE__, __LINE__);printf(__VA_ARGS__);
+#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/alt_printf/parsef.c

@@ -0,0 +1,125 @@
+#include "parsef.h"
+
+#define EOS L'\0'
+
+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:
+			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;
+}