unicode 0.1

data/ext/ustring.c

@@ -0,0 +1,206 @@
+/*
+ * Simple string library
+ * Version 0.2
+ * 1999 by yoshidam
+ */
+
+#include <stdio.h>
+#include "ustring.h"
+
+UString*
+UStr_alloc(UString* str)
+{
+  str->size = USTR_INITIAL_STRING_LEN;
+  str->len = 0;
+  if ((str->str = (unsigned char*)malloc(USTR_INITIAL_STRING_LEN)) == NULL) {
+    str->size = 0;
+    return NULL;
+  }
+
+  return str;
+}
+
+UString*
+UStr_enlarge(UString* str, int size)
+{
+  unsigned char* newptr;
+
+  if ((newptr = (unsigned char*)realloc(str->str, str->size + size))
+      == NULL) {
+    return NULL;
+  }
+  str->str = newptr;
+  str->size += size;
+
+  return str;
+}
+
+void
+UStr_free(UString* str)
+{
+  str->size = 0;
+  str->len = 0;
+  free(str->str);
+}
+
+int
+UStr_addChars(UString* s, const unsigned char* a, int len)
+{
+  if (s->len + len >= s->size) {
+    UStr_enlarge(s, len + USTR_STRING_EXTEND_LEN);
+  }
+  memcpy(s->str + s->len, a, len);
+  s->len += len;
+
+  return s->len;
+}
+
+int
+UStr_addChar(UString* s, unsigned char a)
+{
+  if (s->len + 1 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a;
+  (s->len)++;
+
+  return s->len;
+}
+
+int
+UStr_addChar2(UString* s, unsigned char a1, unsigned char a2)
+{
+  if (s->len + 2 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  s->len += 2;
+
+  return s->len;
+}
+
+int
+UStr_addChar3(UString* s, unsigned char a1, unsigned char a2, unsigned char a3)
+{
+  if (s->len + 3 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  *(s->str + s->len + 2) = a3;
+  s->len += 3;
+
+  return s->len;
+}
+
+int
+UStr_addChar4(UString* s, unsigned char a1, unsigned char a2,
+	      unsigned char a3, unsigned char a4)
+{
+  if (s->len + 4 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  *(s->str + s->len + 2) = a3;
+  *(s->str + s->len + 3) = a4;
+  s->len += 4;
+
+  return s->len;
+}
+
+int
+UStr_addChar5(UString* s, unsigned char a1, unsigned char a2,
+	      unsigned char a3, unsigned char a4, unsigned char a5)
+{
+  if (s->len + 5 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  *(s->str + s->len + 2) = a3;
+  *(s->str + s->len + 3) = a4;
+  *(s->str + s->len + 4) = a5;
+  s->len += 5;
+
+  return s->len;
+}
+
+int
+UStr_addChar6(UString* s, unsigned char a1, unsigned char a2,
+	      unsigned char a3, unsigned char a4,
+	      unsigned char a5, unsigned char a6)
+{
+  if (s->len + 6 >= s->size) {
+    UStr_enlarge(s, USTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  *(s->str + s->len + 2) = a3;
+  *(s->str + s->len + 3) = a4;
+  *(s->str + s->len + 4) = a5;
+  *(s->str + s->len + 5) = a6;
+  s->len += 6;
+
+  return s->len;
+}
+
+int
+UStr_addWChar(UString* ustr, int c)
+{
+  if (c < 128) {         /* 0x0000-0x00FF */
+    UStr_addChar(ustr, c);
+  }
+  else if (c < 2048) {        /* 0x0100-0x07FF */
+    unsigned char b2 = c & 63;
+    unsigned char b1 = c >> 6;
+    UStr_addChar2(ustr, b1 | 192, b2 | 128);
+
+  }
+  else if (c < 0x10000) {     /* 0x0800-0xFFFF */
+    unsigned char b3 = c & 63;
+    unsigned char b2 = (c >> 6) & 63;
+    unsigned char b1 = c >> 12;
+    UStr_addChar3(ustr, b1 | 224, b2 | 128, b3 | 128);
+  }
+  else if (c < 0x200000) {     /* 0x00010000-0x001FFFFF */
+    unsigned char b4 = c & 63;
+    unsigned char b3 = (c >> 6) & 63;
+    unsigned char b2 = (c >> 12) & 63;
+    unsigned char b1 = c >> 18;
+    UStr_addChar4(ustr, b1 | 240, b2 | 128, b3 | 128, b4 | 128);
+  }
+  else if (c < 0x4000000) {     /* 0x00200000-0x03FFFFFF */
+    unsigned char b5 = c & 63;
+    unsigned char b4 = (c >> 6) & 63;
+    unsigned char b3 = (c >> 12) & 63;
+    unsigned char b2 = (c >> 18) & 63;
+    unsigned char b1 = c >> 24;
+    UStr_addChar5(ustr, b1 | 248, b2 | 128, b3 | 128, b4 | 128, b5 | 128);
+  }
+  else if (c < 0x80000000) {     /* 0x04000000-0x7FFFFFFF */
+    unsigned char b6 = c & 63;
+    unsigned char b5 = (c >> 6) & 63;
+    unsigned char b4 = (c >> 12) & 63;
+    unsigned char b3 = (c >> 18) & 63;
+    unsigned char b2 = (c >> 24) & 63;
+    unsigned char b1 = (c >> 30) & 63;
+    UStr_addChar6(ustr, b1 | 252, b2 | 128, b3 | 128,
+		  b4 | 128, b5 | 128, b6 | 128);
+  }
+
+  return ustr->len;
+}
+
+void
+UStr_dump(UString* s)
+{
+  int i;
+
+  printf("[%d/%d] ", s->len, s->size);
+  for (i = 0; i < s->len ; i++) {
+    printf("%02x ", *(s->str + i));
+  }
+  printf("\n");
+}

data/ext/ustring.h

@@ -0,0 +1,48 @@
+/*
+ * Simple string library
+ * Version 0.2
+ * 1999 by yoshidam
+ */
+
+#ifndef _USTRING_H
+#define _USTRING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define USTR_INITIAL_STRING_LEN 1024
+#define USTR_STRING_EXTEND_LEN 1024
+
+/*#define malloc(s) xmalloc(s)*/
+/*#define relloc(p, s) xrelloc(p, s)*/
+
+typedef struct _UString {
+  unsigned char* str;
+  int len;
+  int size;
+} UString;
+
+UString* UStr_alloc(UString* str);
+UString* UStr_enlarge(UString* str, int size);
+void UStr_free(UString* str);
+int UStr_addUhars(UString* s, const unsigned char* a, int len);
+int UStr_addChar(UString* s, unsigned char a);
+int UStr_addChar2(UString* s, unsigned char a1, unsigned char a2);
+int UStr_addChar3(UString* s, unsigned char a1, unsigned char a2,
+		  unsigned char a3);
+int UStr_addChar4(UString* s, unsigned char a1, unsigned char a2,
+		  unsigned char a3, unsigned char a4);
+int UStr_addChar5(UString* s, unsigned char a1, unsigned char a2,
+		  unsigned char a3, unsigned char a4, unsigned char a5);
+int UStr_addChar6(UString* s, unsigned char a1, unsigned char a2,
+		  unsigned char a3, unsigned char a4,
+		  unsigned char a5, unsigned char a6);
+int UStr_addWChar(UString* s, int c);
+void UStr_dump(UString* s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/wstring.c

@@ -0,0 +1,185 @@
+/*
+ * Simple wide string Library
+ * Version 0.1
+ * 1999 by yoshidam
+ */
+
+#include <stdio.h>
+#include "wstring.h"
+
+WString*
+WStr_alloc(WString* str)
+{
+  str->size = WSTR_INITIAL_STRING_LEN;
+  str->len = 0;
+  if ((str->str =
+       (int*)malloc(WSTR_INITIAL_STRING_LEN * sizeof(int))) == NULL) {
+    str->size = 0;
+    return NULL;
+  }
+
+  return str;
+}
+
+WString*
+WStr_enlarge(WString* str, int size)
+{
+  int* newptr;
+
+  if ((newptr = (int*)realloc(str->str, (str->size + size) * sizeof(int)))
+      == NULL) {
+    return NULL;
+  }
+  str->str = newptr;
+  str->size += size;
+
+  return str;
+}
+
+void
+WStr_free(WString* str)
+{
+  str->size = 0;
+  str->len = 0;
+  free(str->str);
+}
+
+int
+WStr_addWChars(WString* s, const int* a, int len)
+{
+  if (s->len + len >= s->size) {
+    WStr_enlarge(s, len + WSTR_STRING_EXTEND_LEN);
+  }
+  memcpy(s->str + s->len, a, len * sizeof(int));
+  s->len += len;
+
+  return s->len;
+}
+
+int
+WStr_addWChar(WString* s, int a)
+{
+  if (s->len + 1 >= s->size) {
+    WStr_enlarge(s, WSTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a;
+  (s->len)++;
+
+  return s->len;
+}
+
+int
+WStr_pushWString(WString* s, const WString* add)
+{
+  if (s->len + add->len >= s->size) {
+    WStr_enlarge(s, add->len + WSTR_STRING_EXTEND_LEN);
+  }
+  memcpy(s->str + s->len, add->str, add->len * sizeof(int));
+  s->len += add->len;
+
+  return s->len;
+}
+
+int
+WStr_addWChar2(WString* s, int a1, int a2)
+{
+  if (s->len + 2 >= s->size) {
+    WStr_enlarge(s, WSTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  s->len += 2;
+
+  return s->len;
+}
+
+int
+WStr_addWChar3(WString* s, int a1, int a2, int a3)
+{
+  if (s->len + 3 >= s->size) {
+    WStr_enlarge(s, WSTR_STRING_EXTEND_LEN);
+  }
+  *(s->str + s->len) = a1;
+  *(s->str + s->len + 1) = a2;
+  *(s->str + s->len + 2) = a3;
+  s->len += 3;
+
+  return s->len;
+}
+
+WString*
+WStr_allocWithUTF8(WString* s, const char* in)
+{
+  int i;
+  int u = 0;
+  int rest = 0;
+
+  WStr_alloc(s);
+  for (i = 0; in[i] != '\0'; i++) {
+    unsigned char c = in[i];
+    if (c >= 128 && c < 192) {
+      if (rest == 0)
+	return NULL;
+      u = (u << 6) | (c & 63);
+      rest--;
+      if (rest == 0) {
+	WStr_addWChar(s, u);
+      }
+    }
+    else if (c < 128) {      /* 0b0nnnnnnn (7bit) */
+      if (c == 0)
+	return NULL;
+      WStr_addWChar(s, c);
+      rest = 0;
+    }
+    else if (c < 224) {      /* 0b110nnnnn (11bit) */
+      rest = 1;
+      u = c & 31;
+    }
+    else if (c < 240) {      /* 0b1110nnnn (16bit) */
+      rest = 2;
+      u = c & 15;
+    }
+    else if (c < 248) {      /* 0b11110nnn (21bit) */
+      rest = 3;
+      u = c & 7;
+    }
+    else if (c < 252) {      /* 0b111110nn (26bit) */
+      rest = 4;
+      u = c & 3;
+    }
+    else if (c < 254) {      /* 0b1111110n (31bit) */
+      rest = 5;
+      u = c & 1;
+    }
+    else {
+      return NULL;
+    }
+  }
+
+  return s;
+}
+
+UString*
+WStr_convertIntoUString(WString* wstr, UString* ustr)
+{
+  int i;
+
+  for (i = 0; i < wstr->len; i++) {
+    UStr_addWChar(ustr, wstr->str[i]);
+  }
+
+  return ustr;
+}
+
+void
+WStr_dump(WString* s)
+{
+  int i;
+
+  printf("[%d/%d] ", s->len, s->size);
+  for (i = 0; i < s->len ; i++) {
+    printf("%04x ", *(s->str + i));
+  }
+  printf("\n");
+}

data/ext/wstring.h

@@ -0,0 +1,41 @@
+/*
+ * Simple wide string library
+ * Version 0.1
+ * 1999 by yoshidam
+ */
+
+#ifndef _WSTRING_H
+#define _WSTRING_H
+
+#include "ustring.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define WSTR_INITIAL_STRING_LEN 1024
+#define WSTR_STRING_EXTEND_LEN 1024
+
+typedef struct _WString {
+  int* str;
+  int len;
+  int size;
+} WString;
+
+WString* WStr_alloc(WString* str);
+WString* WStr_allocWithUTF8(WString* s, const char* u);
+WString* WStr_enlarge(WString* str, int size);
+void WStr_free(WString* str);
+int WStr_addWChars(WString* s, const int* a, int len);
+int WStr_addWChar(WString* s, int a);
+int WStr_pushWString(WString* s, const WString* add);
+int WStr_addWChar2(WString* s, int a1, int a2);
+int WStr_addWChar3(WString* s, int a1, int a2, int a3);
+UString* WStr_convertIntoUString(WString* wstr, UString* ustr);
+void WStr_dump(WString* s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif