kernaux 0.5.0

data/ext/default/ntoa.c

@@ -0,0 +1,254 @@
+#include "main.h"
+
+#ifdef KERNAUX_VERSION_WITH_NTOA
+
+static VALUE rb_KernAux_utoa(int argc, const VALUE *argv, VALUE self);
+static VALUE rb_KernAux_itoa(int argc, const VALUE *argv, VALUE self);
+static VALUE rb_KernAux_utoa2(VALUE self, VALUE number);
+static VALUE rb_KernAux_itoa2(VALUE self, VALUE number);
+static VALUE rb_KernAux_utoa8(VALUE self, VALUE number);
+static VALUE rb_KernAux_itoa8(VALUE self, VALUE number);
+static VALUE rb_KernAux_utoa10(VALUE self, VALUE number);
+static VALUE rb_KernAux_itoa10(VALUE self, VALUE number);
+static VALUE rb_KernAux_utoa16(VALUE self, VALUE number);
+static VALUE rb_KernAux_itoa16(VALUE self, VALUE number);
+
+static ID rb_intern_b = Qnil;
+static ID rb_intern_B = Qnil;
+static ID rb_intern_h = Qnil;
+static ID rb_intern_H = Qnil;
+static ID rb_intern_o = Qnil;
+static ID rb_intern_O = Qnil;
+static ID rb_intern_d = Qnil;
+static ID rb_intern_D = Qnil;
+static ID rb_intern_x = Qnil;
+static ID rb_intern_X = Qnil;
+
+static VALUE rb_KernAux_InvalidNtoaBaseError = Qnil;
+static VALUE rb_KernAux_TooLongNtoaPrefixError = Qnil;
+
+static int convert_base(VALUE base);
+
+void init_ntoa()
+{
+    rb_gc_register_mark_object(ID2SYM(rb_intern_b      = rb_intern("b")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_B      = rb_intern("B")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_h      = rb_intern("h")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_H      = rb_intern("H")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_o      = rb_intern("o")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_O      = rb_intern("O")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_d      = rb_intern("d")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_D      = rb_intern("D")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_x      = rb_intern("x")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_X      = rb_intern("X")));
+
+    rb_gc_register_mark_object(rb_KernAux_InvalidNtoaBaseError =
+        rb_define_class_under(rb_KernAux, "InvalidNtoaBaseError",
+                              rb_KernAux_Error));
+    rb_gc_register_mark_object(rb_KernAux_TooLongNtoaPrefixError =
+        rb_define_class_under(rb_KernAux, "TooLongNtoaPrefixError",
+                              rb_KernAux_Error));
+
+    rb_define_singleton_method(rb_KernAux, "utoa", rb_KernAux_utoa, -1);
+    rb_define_singleton_method(rb_KernAux, "itoa", rb_KernAux_itoa, -1);
+    rb_define_singleton_method(rb_KernAux, "utoa2", rb_KernAux_utoa2, 1);
+    rb_define_singleton_method(rb_KernAux, "itoa2", rb_KernAux_itoa2, 1);
+    rb_define_singleton_method(rb_KernAux, "utoa8", rb_KernAux_utoa8, 1);
+    rb_define_singleton_method(rb_KernAux, "itoa8", rb_KernAux_itoa8, 1);
+    rb_define_singleton_method(rb_KernAux, "utoa10", rb_KernAux_utoa10, 1);
+    rb_define_singleton_method(rb_KernAux, "itoa10", rb_KernAux_itoa10, 1);
+    rb_define_singleton_method(rb_KernAux, "utoa16", rb_KernAux_utoa16, 1);
+    rb_define_singleton_method(rb_KernAux, "itoa16", rb_KernAux_itoa16, 1);
+}
+
+VALUE rb_KernAux_utoa(const int argc, const VALUE *argv, const VALUE self)
+{
+    if (argc < 2 || argc > 3) {
+        rb_raise(
+            rb_eArgError,
+            "wrong number of arguments (given %d, expected 2..3)",
+            argc
+        );
+    }
+
+    VALUE number_rb = argv[0];
+    VALUE base_rb   = argv[1];
+    VALUE prefix_rb = argc == 3 ? argv[2] : Qnil;
+
+    const uint64_t number = NUM2ULL(number_rb);
+
+    if (rb_funcall(number_rb, rb_intern_LESS, 1, INT2FIX(0))) {
+        rb_raise(rb_eRangeError, "can't convert negative number to uint64_t");
+    }
+
+    const char *prefix = NULL;
+    long prefix_len = 0;
+    if (!NIL_P(prefix_rb)) {
+        prefix = StringValueCStr(prefix_rb);
+        prefix_len = RSTRING_LEN(prefix_rb);
+
+        if (prefix_len > KERNAUX_NTOA_MAX_PREFIX_LEN || prefix_len < 0) {
+            rb_raise(
+                rb_KernAux_TooLongNtoaPrefixError,
+                "prefix length %ld is too long",
+                prefix_len
+            );
+        }
+    }
+
+    char buffer[KERNAUX_UTOA_MIN_BUFFER_SIZE + prefix_len];
+    kernaux_utoa(number, buffer, convert_base(base_rb), prefix);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_itoa(const int argc, const VALUE *argv, const VALUE self)
+{
+    if (argc < 2 || argc > 3) {
+        rb_raise(
+            rb_eArgError,
+            "wrong number of arguments (given %d, expected 2..3)",
+            argc
+        );
+    }
+
+    VALUE number_rb = argv[0];
+    VALUE base_rb   = argv[1];
+    VALUE prefix_rb = argc == 3 ? argv[2] : Qnil;
+
+    const int64_t number = NUM2LL(number_rb);
+
+    const char *prefix = NULL;
+    long prefix_len = 0;
+    if (!NIL_P(prefix_rb)) {
+        prefix = StringValueCStr(prefix_rb);
+        prefix_len = RSTRING_LEN(prefix_rb);
+
+        if (prefix_len > KERNAUX_NTOA_MAX_PREFIX_LEN || prefix_len < 0) {
+            rb_raise(
+                rb_KernAux_TooLongNtoaPrefixError,
+                "prefix length %ld is too long",
+                prefix_len
+            );
+        }
+    }
+
+    char buffer[KERNAUX_ITOA_MIN_BUFFER_SIZE + prefix_len];
+    kernaux_itoa(number, buffer, convert_base(base_rb), prefix);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_utoa2(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const uint64_t number = NUM2ULL(number_rb);
+    if (rb_funcall(number_rb, rb_intern_LESS, 1, INT2FIX(0))) {
+        rb_raise(rb_eRangeError, "can't convert negative number to uint64_t");
+    }
+    char buffer[KERNAUX_UTOA2_BUFFER_SIZE];
+    kernaux_utoa2(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_itoa2(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const int64_t number = NUM2LL(number_rb);
+    char buffer[KERNAUX_ITOA2_BUFFER_SIZE];
+    kernaux_itoa2(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_utoa8(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const uint64_t number = NUM2ULL(number_rb);
+    if (rb_funcall(number_rb, rb_intern_LESS, 1, INT2FIX(0))) {
+        rb_raise(rb_eRangeError, "can't convert negative number to uint64_t");
+    }
+    char buffer[KERNAUX_UTOA8_BUFFER_SIZE];
+    kernaux_utoa8(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_itoa8(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const int64_t number = NUM2LL(number_rb);
+    char buffer[KERNAUX_ITOA8_BUFFER_SIZE];
+    kernaux_itoa8(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_utoa10(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const uint64_t number = NUM2ULL(number_rb);
+    if (rb_funcall(number_rb, rb_intern_LESS, 1, INT2FIX(0))) {
+        rb_raise(rb_eRangeError, "can't convert negative number to uint64_t");
+    }
+    char buffer[KERNAUX_UTOA10_BUFFER_SIZE];
+    kernaux_utoa10(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_itoa10(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const int64_t number = NUM2LL(number_rb);
+    char buffer[KERNAUX_ITOA10_BUFFER_SIZE];
+    kernaux_itoa10(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_utoa16(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const uint64_t number = NUM2ULL(number_rb);
+    if (rb_funcall(number_rb, rb_intern_LESS, 1, INT2FIX(0))) {
+        rb_raise(rb_eRangeError, "can't convert negative number to uint64_t");
+    }
+    char buffer[KERNAUX_UTOA16_BUFFER_SIZE];
+    kernaux_utoa16(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+VALUE rb_KernAux_itoa16(
+    const VALUE self_rb __attribute__((unused)),
+    const VALUE number_rb
+) {
+    const int64_t number = NUM2LL(number_rb);
+    char buffer[KERNAUX_ITOA16_BUFFER_SIZE];
+    kernaux_itoa16(number, buffer);
+    return rb_funcall(rb_str_new2(buffer), rb_intern_freeze, 0);
+}
+
+int convert_base(const VALUE base_rb)
+{
+    if (TYPE(base_rb) == T_SYMBOL) {
+        const ID base_id = SYM2ID(base_rb);
+        if      (base_id == rb_intern_b) return 'b';
+        else if (base_id == rb_intern_B) return 'B';
+        else if (base_id == rb_intern_h) return 'h';
+        else if (base_id == rb_intern_H) return 'H';
+        else if (base_id == rb_intern_o) return 'o';
+        else if (base_id == rb_intern_O) return 'O';
+        else if (base_id == rb_intern_d) return 'd';
+        else if (base_id == rb_intern_D) return 'D';
+        else if (base_id == rb_intern_x) return 'x';
+        else if (base_id == rb_intern_X) return 'X';
+        else {
+            rb_raise(rb_KernAux_InvalidNtoaBaseError, "invalid base");
+        }
+    } else {
+        return NUM2INT(base_rb);
+    }
+}
+
+#endif // KERNAUX_VERSION_WITH_NTOA

data/ext/default/printf.c

@@ -0,0 +1,210 @@
+#include "main.h"
+
+#include "dynarg.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#ifdef KERNAUX_VERSION_WITH_PRINTF
+
+/*************
+ * ::KernAux *
+ *************/
+
+static VALUE rb_KernAux_snprintf1(int argc, const VALUE *argv, VALUE self);
+
+static VALUE rb_KernAux_snprintf1_PROTECT(VALUE userdata);
+
+/************************
+ * ::KernAux::Snprintf1 *
+ ************************/
+
+static VALUE rb_KernAux_Snprintf1 = Qnil;
+
+static size_t rb_KernAux_Snprintf1_DSIZE(const void *ptr);
+
+const rb_data_type_t rb_KernAux_Snprintf1_DTYPE = {
+    .wrap_struct_name = "KernAux::Snprintf1",
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .function = {
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = rb_KernAux_Snprintf1_DSIZE,
+        .dmark = NULL,
+        .dcompact = NULL,
+        .reserved = { 0 },
+    },
+};
+
+struct rb_KernAux_Snprintf1_DATA {
+    const struct KernAux_PrintfFmt_Spec *spec;
+    const struct DynArg *dynarg;
+    int size;
+    const char *format;
+    char *str;
+};
+
+/********
+ * Main *
+ ********/
+
+void init_printf()
+{
+    rb_gc_register_mark_object(
+        rb_KernAux_Snprintf1 =
+            // @api private
+            rb_define_class_under(rb_KernAux, "Snprintf1", rb_cObject));
+    rb_funcall(rb_KernAux, rb_intern("private_constant"), 1, ID2SYM(rb_intern("Snprintf1")));
+
+    rb_define_singleton_method(rb_KernAux, "snprintf1",
+                               rb_KernAux_snprintf1, -1);
+}
+
+/*************
+ * ::KernAux *
+ *************/
+
+VALUE rb_KernAux_snprintf1(
+    const int argc,
+    const VALUE *const argv_rb,
+    const VALUE self __attribute__((unused))
+) {
+    if (argc < 2 || argc > 5) rb_raise(rb_eArgError, "expected 2, 3, 4 or 5 args");
+
+    const VALUE size_rb = argv_rb[0];
+    VALUE format_rb = argv_rb[1];
+
+    const int size = NUM2INT(size_rb);
+    const char *const format = StringValueCStr(format_rb);
+
+    if (size < 0) rb_raise(rb_eRangeError, "expected non-negative size");
+
+    const char *fmt = format;
+
+    while (*fmt && *fmt != '%') ++fmt;
+    if (*(fmt++) != '%') rb_raise(rb_eArgError, "invalid format");
+
+    struct KernAux_PrintfFmt_Spec spec = KernAux_PrintfFmt_Spec_create();
+
+    fmt = KernAux_PrintfFmt_Spec_parse(&spec, fmt);
+
+    while (*fmt) {
+        if (*(fmt++) == '%') rb_raise(rb_eArgError, "invalid format");
+    }
+
+    int arg_index = 2;
+    if (spec.set_width && argc > arg_index) {
+        KernAux_PrintfFmt_Spec_set_width(&spec, NUM2INT(argv_rb[arg_index++]));
+    }
+    if (spec.set_precision && argc > arg_index) {
+        KernAux_PrintfFmt_Spec_set_precision(&spec, NUM2INT(argv_rb[arg_index++]));
+    }
+
+    struct DynArg dynarg = DynArg_create();
+    if (argc > arg_index) {
+        VALUE arg_rb = argv_rb[arg_index];
+
+        if (spec.type == KERNAUX_PRINTF_FMT_TYPE_INT) {
+            DynArg_use_long_long(&dynarg, NUM2LL(arg_rb));
+        } else if (spec.type == KERNAUX_PRINTF_FMT_TYPE_UINT) {
+            DynArg_use_unsigned_long_long(&dynarg, NUM2ULL(arg_rb));
+        } else if (spec.type == KERNAUX_PRINTF_FMT_TYPE_FLOAT ||
+                   spec.type == KERNAUX_PRINTF_FMT_TYPE_EXP)
+        {
+            DynArg_use_double(&dynarg, NUM2DBL(arg_rb));
+        } else if (spec.type == KERNAUX_PRINTF_FMT_TYPE_CHAR) {
+            Check_Type(arg_rb, T_STRING);
+            DynArg_use_char(&dynarg, *StringValuePtr(arg_rb));
+        } else if (spec.type == KERNAUX_PRINTF_FMT_TYPE_STR) {
+            Check_Type(arg_rb, T_STRING);
+            DynArg_use_str(&dynarg, StringValueCStr(arg_rb));
+        }
+    }
+
+    char *const str = malloc(size);
+    if (!str) rb_raise(rb_eNoMemError, "snprintf1 buffer malloc");
+
+    struct rb_KernAux_Snprintf1_DATA *userdata;
+    VALUE userdata_rb = TypedData_Make_Struct(
+        rb_KernAux_Snprintf1,
+        struct rb_KernAux_Snprintf1_DATA,
+        &rb_KernAux_Snprintf1_DTYPE,
+        userdata
+    );
+    if (NIL_P(userdata_rb) || userdata == NULL) {
+        free(str);
+        rb_raise(rb_eNoMemError, "snprintf1 userdata alloc");
+    }
+
+    userdata->spec = &spec;
+    userdata->dynarg = &dynarg;
+    userdata->size = size;
+    userdata->format = format;
+    userdata->str = str;
+
+    int state = 0;
+    VALUE result =
+        rb_protect(rb_KernAux_snprintf1_PROTECT, userdata_rb, &state);
+
+    free(str);
+
+    if (state == 0) {
+        return result;
+    } else {
+        rb_jump_tag(state);
+    }
+}
+
+VALUE rb_KernAux_snprintf1_PROTECT(VALUE userdata_rb)
+{
+    const struct rb_KernAux_Snprintf1_DATA *userdata = NULL;
+    TypedData_Get_Struct(
+        userdata_rb,
+        struct rb_KernAux_Snprintf1_DATA,
+        &rb_KernAux_Snprintf1_DTYPE,
+        userdata
+    );
+
+    int slen;
+    if (userdata->spec->set_width) {
+        if (userdata->spec->set_precision) {
+            slen = userdata->dynarg->use_dbl
+                ? kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->width, userdata->spec->precision, userdata->dynarg->dbl)
+                : kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->width, userdata->spec->precision, userdata->dynarg->arg);
+        } else {
+            slen = userdata->dynarg->use_dbl
+                ? kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->width, userdata->dynarg->dbl)
+                : kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->width, userdata->dynarg->arg);
+        }
+    } else {
+        if (userdata->spec->set_precision) {
+            slen = userdata->dynarg->use_dbl
+                ? kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->precision, userdata->dynarg->dbl)
+                : kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->spec->precision, userdata->dynarg->arg);
+        } else {
+            slen = userdata->dynarg->use_dbl
+                ? kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->dynarg->dbl)
+                : kernaux_snprintf(userdata->str, userdata->size, userdata->format, userdata->dynarg->arg);
+        }
+    }
+
+    const VALUE output_rb =
+        rb_funcall(rb_str_new2(userdata->str), rb_intern_freeze, 0);
+
+    const VALUE result_rb = rb_ary_new2(2);
+    rb_ary_push(result_rb, output_rb);
+    rb_ary_push(result_rb, INT2NUM(slen));
+    return rb_funcall(result_rb, rb_intern_freeze, 0);
+}
+
+/************************
+ * ::KernAux::Snprintf1 *
+ ************************/
+
+size_t rb_KernAux_Snprintf1_DSIZE(const void *const ptr)
+{
+    return sizeof(struct rb_KernAux_Snprintf1_DATA);
+}
+
+#endif // KERNAUX_VERSION_WITH_PRINTF

data/ext/default/version.c

@@ -0,0 +1,47 @@
+#include "main.h"
+
+static VALUE rb_KernAux_Version_with_cmdlineQN(VALUE self);
+static VALUE rb_KernAux_Version_with_ntoaQN(VALUE self);
+static VALUE rb_KernAux_Version_with_printfQN(VALUE self);
+
+static VALUE rb_KernAux_Version = Qnil;
+
+void init_version()
+{
+    rb_gc_register_mark_object(rb_KernAux_Version =
+        rb_define_module_under(rb_KernAux, "Version"));
+
+    rb_define_singleton_method(rb_KernAux_Version, "with_cmdline?",
+                               rb_KernAux_Version_with_cmdlineQN, 0);
+    rb_define_singleton_method(rb_KernAux_Version, "with_ntoa?",
+                               rb_KernAux_Version_with_ntoaQN, 0);
+    rb_define_singleton_method(rb_KernAux_Version, "with_printf?",
+                               rb_KernAux_Version_with_printfQN, 0);
+}
+
+VALUE rb_KernAux_Version_with_cmdlineQN(VALUE self)
+{
+#ifdef KERNAUX_VERSION_WITH_CMDLINE
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}
+
+VALUE rb_KernAux_Version_with_ntoaQN(VALUE self)
+{
+#ifdef KERNAUX_VERSION_WITH_NTOA
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}
+
+VALUE rb_KernAux_Version_with_printfQN(VALUE self)
+{
+#ifdef KERNAUX_VERSION_WITH_PRINTF
+    return Qtrue;
+#else
+    return Qfalse;
+#endif
+}

data/kernaux.gemspec

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'lib/kernaux/version'
+
+Gem::Specification.new do |spec|
+  repo = 'https://github.com/tailix/libkernaux'
+  home = "#{repo}/tree/master/bindings/ruby"
+  bugs = "#{repo}/issues"
+  docs = "https://www.rubydoc.info/gems/kernaux/#{KernAux::VERSION}"
+
+  spec.name     = 'kernaux'
+  spec.version  = KernAux::VERSION
+  spec.license  = 'MIT'
+  spec.homepage = home
+  spec.platform = Gem::Platform::RUBY
+
+  spec.required_ruby_version = '~> 3.0'
+
+  spec.authors = ['Alex Kotov']
+  spec.email   = %w[kotovalexarian@gmail.com]
+
+  spec.summary =
+    'Binding to libkernaux - auxiliary library for kernel development'
+
+  spec.description = <<~DESCRIPTION.split("\n").map(&:strip).join ' '
+    Binding to libkernaux - auxiliary library for kernel development.
+  DESCRIPTION
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['homepage_uri']          = home
+  spec.metadata['source_code_uri']       = home
+  spec.metadata['bug_tracker_uri']       = bugs
+  spec.metadata['documentation_uri']     = docs
+
+  spec.bindir        = 'exe'
+  spec.require_paths = ['lib']
+
+  spec.files = Dir.chdir File.expand_path __dir__ do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match %r{\A(?:test|spec|features)/}
+    end
+  end
+
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename f }
+
+  spec.extensions << 'ext/default/extconf.rb'
+
+  spec.add_development_dependency 'bundler',             '~> 2.2'
+  spec.add_development_dependency 'pry',                 '~> 0.14'
+  spec.add_development_dependency 'rake',                '~> 13.0'
+  spec.add_development_dependency 'rake-compiler',       '~> 1.1'
+  spec.add_development_dependency 'rspec',               '~> 3.10'
+  spec.add_development_dependency 'rubocop',             '~> 1.25'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.13'
+  spec.add_development_dependency 'rubocop-rake',        '~> 0.6'
+  spec.add_development_dependency 'rubocop-rspec',       '~> 2.7'
+  spec.add_development_dependency 'simplecov',           '~> 0.21'
+  spec.add_development_dependency 'yard',                '~> 0.9'
+end

data/lib/kernaux/assert.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+begin; end
+
+module KernAux
+  # Default callback for assertions.
+  # @see .assert_cb
+  DEFAULT_ASSERT_CB = @assert_cb = lambda { |file, line, msg|
+    raise AssertError, "#{file}:#{line}:#{msg}"
+  }
+
+  # @!scope class
+
+  ##
+  # @!attribute [rw] assert_cb
+  # Panic callback.
+  #
+  # @return [Proc]
+  #
+  # @api unsafe
+  #
+  # @see .panic
+  # @see .assert_do
+  ##
+
+  ##
+  # Raise assertion with implicit file and line, retrieved from `caller`, and
+  # explicit message.
+  #
+  # @param msg [String] any message
+  # @return [nil]
+  #
+  # @raise [AssertError] if {.assert_cb} have not been changed
+  #
+  # @see .assert_do Explicit file and line.
+  #
+  def self.panic(msg)
+    file, line = caller(1..1).first.split(':')[0..1]
+    assert_do file, Integer(line), msg
+  end
+
+  ##
+  # @!method assert_do(file, line, msg)
+  # Raise assertion with explicit file, line and message.
+  #
+  # @param file [String] file name, usually from `__FILE__`
+  # @param line [Integer] line number, usually from `__LINE__`
+  # @param msg [String] any message
+  # @return [nil]
+  #
+  # @raise [AssertError] if {.assert_cb} have not been changed
+  #
+  # @see .panic Implicit file and line
+  ##
+end
+
+# rubocop:enable Style/Documentation

data/lib/kernaux/cmdline.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/Documentation
+begin; end
+
+module KernAux
+  # @!scope class
+
+  ##
+  # @!method cmdline(str)
+  # Parse command line.
+  #
+  # @param str [String] command line string
+  # @return [Array<String>] command line arguments
+  #
+  # @raise [CmdlineError] syntax is invalid
+  ##
+end
+
+# rubocop:enable Style/Documentation

data/lib/kernaux/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module KernAux
+  ##
+  # Our base class for runtime errors.
+  #
+  class Error < RuntimeError; end
+
+  ##
+  # Raised when assertion has failed or panic has been called.
+  #
+  # @see .panic
+  # @see .assert_do
+  #
+  class AssertError < Error; end
+
+  ##
+  # Raised when command line parsing goes wrong.
+  #
+  # @see .cmdline
+  #
+  class CmdlineError < Error; end
+
+  ##
+  # Raised when integer base is invalid.
+  #
+  # @see .utoa
+  # @see .itoa
+  #
+  class InvalidNtoaBaseError < Error; end
+
+  ##
+  # Raised when prefix is too long.
+  #
+  # @see .utoa
+  # @see .itoa
+  #
+  class TooLongNtoaPrefixError < Error; end
+end