mutant-melbourne 2.0.1

data/ext/melbourne/bstrlib.h

@@ -0,0 +1,267 @@
+/*
+ * This source file is part of the bstring string library.  This code was
+ * written by Paul Hsieh in 2002-2007, and is covered by the BSD open source
+ * license. Refer to the accompanying documentation for details on usage and
+ * license.
+ */
+
+/*
+ * bstrlib.c
+ *
+ * This file is the core module for implementing the bstring functions.
+ */
+
+#ifndef BSTRLIB_INCLUDE
+#define BSTRLIB_INCLUDE
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <string.h>
+#include <limits.h>
+#include <ctype.h>
+
+#define BSTR_ERR (-1)
+#define BSTR_OK (0)
+#define BSTR_BS_BUFF_LENGTH_GET (0)
+
+typedef struct tagbstring * bstring;
+typedef const struct tagbstring * const_bstring;
+
+/* Copy functions */
+#define cstr2bstr bfromcstr
+extern bstring bfromcstr (const char * str);
+extern bstring bfromcstralloc (int mlen, const char * str);
+extern bstring blk2bstr (const void * blk, int len);
+extern char * bstr2cstr (const_bstring s, char z);
+extern int bcstrfree (char * s);
+extern bstring bstrcpy (const_bstring b1);
+extern int bassign (bstring a, const_bstring b);
+extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
+extern int bassigncstr (bstring a, const char * str);
+extern int bassignblk (bstring a, const void * s, int len);
+
+/* Destroy function */
+extern int bdestroy (bstring b);
+
+/* Space allocation hinting functions */
+extern int balloc (bstring s, int len);
+extern int ballocmin (bstring b, int len);
+
+/* Substring extraction */
+extern bstring bmidstr (const_bstring b, int left, int len);
+
+/* Various standard manipulations */
+extern int bconcat (bstring b0, const_bstring b1);
+extern int bconchar (bstring b0, char c);
+extern int bcatcstr (bstring b, const char * s);
+extern int bcatblk (bstring b, const void * s, int len);
+extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
+extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
+extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
+extern int bdelete (bstring s1, int pos, int len);
+extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
+extern int btrunc (bstring b, int n);
+
+/* Scan/search functions */
+extern int bstricmp (const_bstring b0, const_bstring b1);
+extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
+extern int biseqcaseless (const_bstring b0, const_bstring b1);
+extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
+extern int biseq (const_bstring b0, const_bstring b1);
+extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
+extern int biseqcstr (const_bstring b, const char * s);
+extern int biseqcstrcaseless (const_bstring b, const char * s);
+extern int bstrcmp (const_bstring b0, const_bstring b1);
+extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
+extern int binstr (const_bstring s1, int pos, const_bstring s2);
+extern int binstrr (const_bstring s1, int pos, const_bstring s2);
+extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
+extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
+extern int bstrchrp (const_bstring b, int c, int pos);
+extern int bstrrchrp (const_bstring b, int c, int pos);
+#define bstrchr(b,c) bstrchrp ((b), (c), 0)
+#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
+extern int binchr (const_bstring b0, int pos, const_bstring b1);
+extern int binchrr (const_bstring b0, int pos, const_bstring b1);
+extern int bninchr (const_bstring b0, int pos, const_bstring b1);
+extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
+extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
+extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
+
+/* List of string container functions */
+struct bstrList {
+    int qty, mlen;
+    bstring * entry;
+};
+extern struct bstrList * bstrListCreate (void);
+extern int bstrListDestroy (struct bstrList * sl);
+extern int bstrListAlloc (struct bstrList * sl, int msz);
+extern int bstrListAllocMin (struct bstrList * sl, int msz);
+
+/* String split and join functions */
+extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
+extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
+extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
+extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
+extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
+	int (* cb) (void * parm, int ofs, int len), void * parm);
+extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
+	int (* cb) (void * parm, int ofs, int len), void * parm);
+extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
+	int (* cb) (void * parm, int ofs, int len), void * parm);
+
+/* Miscellaneous functions */
+extern int bpattern (bstring b, int len);
+extern int btoupper (bstring b);
+extern int btolower (bstring b);
+extern int bltrimws (bstring b);
+extern int brtrimws (bstring b);
+extern int btrimws (bstring b);
+
+typedef int (*bNgetc) (void *parm);
+typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
+
+/* Input functions */
+extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
+extern bstring bread (bNread readPtr, void * parm);
+extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
+extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
+extern int breada (bstring b, bNread readPtr, void * parm);
+
+/* Stream functions */
+extern struct bStream * bsopen (bNread readPtr, void * parm);
+extern void * bsclose (struct bStream * s);
+extern int bsbufflength (struct bStream * s, int sz);
+extern int bsreadln (bstring b, struct bStream * s, char terminator);
+extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
+extern int bsread (bstring b, struct bStream * s, int n);
+extern int bsreadlna (bstring b, struct bStream * s, char terminator);
+extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
+extern int bsreada (bstring b, struct bStream * s, int n);
+extern int bsunread (struct bStream * s, const_bstring b);
+extern int bspeek (bstring r, const struct bStream * s);
+extern int bssplitscb (struct bStream * s, const_bstring splitStr,
+	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
+extern int bssplitstrcb (struct bStream * s, const_bstring splitStr,
+	int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
+extern int bseof (const struct bStream * s);
+
+struct tagbstring {
+	int mlen;
+	int slen;
+	unsigned char * data;
+};
+
+/* Accessor macros */
+#define blengthe(b, e)      (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
+#define blength(b)          (blengthe ((b), 0))
+#define bdataofse(b, o, e)  (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
+#define bdataofs(b, o)      (bdataofse ((b), (o), (void *)0))
+#define bdatae(b, e)        (bdataofse (b, 0, e))
+#define bdata(b)            (bdataofs (b, 0))
+#define bchare(b, p, e)     ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
+#define bchar(b, p)         bchare ((b), (p), '\0')
+
+/* Static constant string initialization macro */
+#if defined(_MSC_VER) && defined(_DEBUG)
+# if _MSC_VER <= 1310
+#  define bsStatic(q)       {-32, (int) sizeof(q)-1, (unsigned char *) ("" q "")}
+# endif
+#endif
+#ifndef bsStatic
+# define bsStatic(q)        {-__LINE__, (int) sizeof(q)-1, (unsigned char *) ("" q "")}
+#endif
+
+/* Static constant block parameter pair */
+#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
+
+/* Reference building macros */
+#define cstr2tbstr btfromcstr
+#define btfromcstr(t,s) {                                            \
+    (t).data = (unsigned char *) (s);                                \
+    (t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
+    (t).mlen = -1;                                                   \
+}
+#define blk2tbstr(t,s,l) {            \
+    (t).data = (unsigned char *) (s); \
+    (t).slen = l;                     \
+    (t).mlen = -1;                    \
+}
+#define btfromblk(t,s,l) blk2tbstr(t,s,l)
+#define bmid2tbstr(t,b,p,l) {                                                \
+    bstring bstrtmp_s = (b);                                                 \
+    if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {              \
+        int bstrtmp_left = (p);                                              \
+        int bstrtmp_len  = (l);                                              \
+        if (bstrtmp_left < 0) {                                              \
+            bstrtmp_len += bstrtmp_left;                                     \
+            bstrtmp_left = 0;                                                \
+        }                                                                    \
+        if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                    \
+            bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                    \
+        if (bstrtmp_len <= 0) {                                              \
+            (t).data = (unsigned char *)"";                                  \
+            (t).slen = 0;                                                    \
+        } else {                                                             \
+            (t).data = bstrtmp_s->data + bstrtmp_left;                       \
+            (t).slen = bstrtmp_len;                                          \
+        }                                                                    \
+    } else {                                                                 \
+        (t).data = (unsigned char *)"";                                      \
+        (t).slen = 0;                                                        \
+    }                                                                        \
+    (t).mlen = -__LINE__;                                                    \
+}
+#define btfromblkltrimws(t,s,l) {                                            \
+    int bstrtmp_idx = 0, bstrtmp_len = (l);                                  \
+    unsigned char * bstrtmp_s = (s);                                         \
+    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
+        for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                   \
+            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
+        }                                                                    \
+    }                                                                        \
+    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
+    (t).slen = bstrtmp_len - bstrtmp_idx;                                    \
+    (t).mlen = -__LINE__;                                                    \
+}
+#define btfromblkrtrimws(t,s,l) {                                            \
+    int bstrtmp_len = (l) - 1;                                               \
+    unsigned char * bstrtmp_s = (s);                                         \
+    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
+        for (; bstrtmp_len >= 0; bstrtmp_len--) {                            \
+            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
+        }                                                                    \
+    }                                                                        \
+    (t).data = bstrtmp_s;                                                    \
+    (t).slen = bstrtmp_len + 1;                                              \
+    (t).mlen = -__LINE__;                                                    \
+}
+#define btfromblktrimws(t,s,l) {                                             \
+    int bstrtmp_idx = 0, bstrtmp_len = (l) - 1;                              \
+    unsigned char * bstrtmp_s = (s);                                         \
+    if (bstrtmp_s && bstrtmp_len >= 0) {                                     \
+        for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                  \
+            if (!isspace (bstrtmp_s[bstrtmp_idx])) break;                    \
+        }                                                                    \
+        for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                  \
+            if (!isspace (bstrtmp_s[bstrtmp_len])) break;                    \
+        }                                                                    \
+    }                                                                        \
+    (t).data = bstrtmp_s + bstrtmp_idx;                                      \
+    (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                \
+    (t).mlen = -__LINE__;                                                    \
+}
+
+/* Write protection macros */
+#define bwriteprotect(t)     { if ((t).mlen >=  0) (t).mlen = -1; }
+#define bwriteallow(t)       { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
+#define biswriteprotected(t) ((t).mlen <= 0)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/melbourne/encoding_compat.cpp

@@ -0,0 +1,188 @@
+#include "encoding_compat.hpp"
+
+extern "C" {
+
+#ifdef HAVE_RUBY_ENCODING_H
+
+  int parser_enc_isalnum(int c, rb_encoding* enc) {
+    return rb_enc_isalnum(c, enc);
+  }
+
+  int parser_enc_isascii(int c, rb_encoding* enc) {
+    return rb_enc_isascii(c, enc);
+  }
+
+  int parser_enc_isspace(int c, rb_encoding* enc) {
+    return rb_enc_isspace(c, enc);
+  }
+
+  int parser_enc_ispunct(int c, rb_encoding* enc) {
+    return rb_enc_ispunct(c, enc);
+  }
+
+  int parser_enc_isupper(int c, rb_encoding* enc) {
+    return rb_enc_isupper(c, enc);
+  }
+
+  int parser_enc_precise_mbclen(const char* p, const char* e, rb_encoding* enc) {
+    return rb_enc_precise_mbclen(p, e, enc);
+  }
+
+  int parser_enc_codelen(int c, rb_encoding* enc) {
+    return rb_enc_codelen(c, enc);
+  }
+
+  int parser_enc_mbclen(const char* p, const char* e, rb_encoding* enc) {
+    return rb_enc_mbclen(p, e, enc);
+  }
+
+  int parser_enc_asciicompat(rb_encoding* enc) {
+    return rb_enc_asciicompat(enc);
+  }
+
+  int parser_enc_str_coderange(VALUE str) {
+    return rb_enc_str_coderange(str);
+  }
+
+  int parser_enc_find_index(const char* name) {
+    return rb_enc_find_index(name);
+  }
+
+  void parser_enc_mbcput(int c, const char* ptr, rb_encoding* enc) {
+    rb_enc_mbcput(c, ptr, enc);
+  }
+
+  const char* parser_enc_name(rb_encoding* enc) {
+    return rb_enc_name(enc);
+  }
+
+  VALUE parser_enc_str_new(const char* ptr, long len, rb_encoding* enc) {
+    return rb_enc_str_new(ptr, len, enc);
+  }
+
+  VALUE parser_enc_associate(VALUE obj, rb_encoding* enc) {
+    return rb_enc_associate(obj, enc);
+  }
+
+  rb_encoding* parser_enc_get(VALUE obj) {
+    return rb_enc_get(obj);
+  }
+
+  rb_encoding* parser_enc_compatible(VALUE str1, VALUE str2) {
+    return rb_enc_compatible(str1, str2);
+  }
+
+  rb_encoding* parser_enc_from_index(int index) {
+    return rb_enc_from_index(index);
+  }
+
+  rb_encoding* parser_utf8_encoding() {
+    return rb_utf8_encoding();
+  }
+
+  rb_encoding* parser_usascii_encoding() {
+    return rb_usascii_encoding();
+  }
+
+  rb_encoding* parser_ascii8bit_encoding() {
+    return rb_ascii8bit_encoding();
+  }
+
+#else
+
+  int parser_enc_isalnum(int c, rb_encoding* enc) {
+    return isalnum(c);
+  }
+
+  int parser_enc_isascii(int c, rb_encoding* enc) {
+    return isascii(c);
+  }
+
+  int parser_enc_isspace(int c, rb_encoding* enc) {
+    return isspace(c);
+  }
+
+  int parser_enc_ispunct(int c, rb_encoding* enc) {
+    return ispunct(c);
+  }
+
+  int parser_enc_isupper(int c, rb_encoding* enc) {
+    return isupper(c);
+  }
+
+  int parser_enc_precise_mbclen(const char* p, const char* e, rb_encoding* enc) {
+    return 1;
+  }
+
+  int parser_enc_codelen(int c, rb_encoding* enc) {
+    return 1;
+  }
+
+  int parser_enc_mbclen(const char* p, const char* e, rb_encoding* enc) {
+    return 1;
+  }
+
+  int parser_enc_asciicompat(rb_encoding* enc) {
+    return 1;
+  }
+
+  int parser_enc_str_coderange(VALUE str) {
+    return ENC_CODERANGE_7BIT;
+  }
+
+  int parser_enc_find_index(const char* name) {
+    return 1;
+  }
+
+  void parser_enc_mbcput(int c, const char* ptr, rb_encoding* enc) {
+    // Do nothing
+  }
+
+  const char* parser_enc_name(rb_encoding* enc) {
+    return enc->name;
+  }
+
+  VALUE parser_enc_str_new(const char* ptr, long len, rb_encoding* enc) {
+    return rb_str_new(ptr, len);
+  }
+
+  VALUE parser_enc_associate(VALUE obj, rb_encoding* enc) {
+    return obj;
+  }
+
+  rb_encoding* parser_enc_get(VALUE obj) {
+    return parser_usascii_encoding();
+  }
+
+  rb_encoding* parser_enc_compatible(VALUE str1, VALUE str2) {
+    return parser_enc_get(str1);
+  }
+
+  rb_encoding* parser_enc_from_index(int index) {
+    return parser_usascii_encoding();
+  }
+
+  rb_encoding* parser_utf8_encoding() {
+    static rb_encoding enc = { "UTF-8" };
+
+    return &enc;
+  }
+
+  rb_encoding* parser_usascii_encoding() {
+    static rb_encoding enc = { "US-ASCII" };
+
+    return &enc;
+  }
+
+  rb_encoding* parser_ascii8bit_encoding() {
+    static rb_encoding enc = { "ASCII-8BIT" };
+
+    return &enc;
+  }
+
+  ID rb_intern_str(VALUE str) {
+    return SYM2ID(rb_funcall(str, rb_intern("to_sym"), 0));
+  }
+
+#endif
+}

data/ext/melbourne/encoding_compat.hpp

@@ -0,0 +1,57 @@
+#ifndef MEL_ENCODING_COMPAT_HPP
+#define MEL_ENCODING_COMPAT_HPP
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "melbourne.hpp"
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#else
+
+#define ENCODING_NAMELEN_MAX 63
+
+typedef struct {
+  const char name[ENCODING_NAMELEN_MAX];
+} rb_encoding;
+
+#define ENC_CODERANGE_UNKNOWN               0
+#define ENC_CODERANGE_7BIT                  1
+
+#define MBCLEN_CHARFOUND_P(ret)             1
+
+#endif
+
+int parser_enc_isalnum(int c, rb_encoding* enc);
+int parser_enc_isascii(int c, rb_encoding* enc);
+int parser_enc_isspace(int c, rb_encoding* enc);
+int parser_enc_ispunct(int c, rb_encoding* enc);
+int parser_enc_isupper(int c, rb_encoding* enc);
+
+int parser_enc_precise_mbclen(const char* p, const char* e, rb_encoding* enc);
+int parser_enc_codelen(int c, rb_encoding* enc);
+int parser_enc_mbclen(const char* p, const char* e, rb_encoding* enc);
+int parser_enc_asciicompat(rb_encoding* enc);
+int parser_enc_str_coderange(VALUE str);
+int parser_enc_find_index(const char* name);
+
+void parser_enc_mbcput(int c, const char* ptr, rb_encoding* enc);
+
+const char* parser_enc_name(rb_encoding* enc);
+
+VALUE parser_enc_str_new(const char* ptr, long len, rb_encoding* enc);
+VALUE parser_enc_associate(VALUE obj, rb_encoding* enc);
+
+rb_encoding* parser_enc_get(VALUE obj);
+rb_encoding* parser_enc_compatible(VALUE str1, VALUE str2);
+rb_encoding* parser_enc_from_index(int index);
+rb_encoding* parser_utf8_encoding();
+rb_encoding* parser_usascii_encoding();
+rb_encoding* parser_ascii8bit_encoding();
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+#endif

data/ext/melbourne/extconf.rb

@@ -0,0 +1,87 @@
+unless(defined?(RUBY_ENGINE) and RUBY_ENGINE == 'rbx')
+require 'mkmf'
+
+def add_lib(name)
+  i, lib = dir_config(name)
+  $libs << " #{lib}/lib#{name}.a "
+end
+
+# add_lib("mquark")
+# add_lib("bstring")
+# add_lib("ptr_array")
+# add_lib("cchash")
+
+#have_library("bstring")
+#have_library("mquark")
+#have_library("ptr_array")
+#have_library("cchash")
+
+$CFLAGS += " -ggdb3"
+
+# Courtesy of EventMachine. Thank you EventMachine and tmm1 !
+case RUBY_PLATFORM
+when /mswin32/, /mingw32/, /bccwin32/
+  check_heads(%w[windows.h winsock.h], true)
+  check_libs(%w[kernel32 rpcrt4 gdi32], true)
+
+  if GNU_CHAIN
+    CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
+  else
+    $defs.push "-EHs"
+    $defs.push "-GR"
+  end
+
+when /solaris/
+  add_define 'OS_SOLARIS8'
+
+  if CONFIG['CC'] == 'cc' and `cc -flags 2>&1` =~ /Sun/ # detect SUNWspro compiler
+    # SUN CHAIN
+    add_define 'CC_SUNWspro'
+    $preload = ["\nCXX = CC"] # hack a CXX= line into the makefile
+    $CFLAGS = CONFIG['CFLAGS'] = "-KPIC"
+    CONFIG['CCDLFLAGS'] = "-KPIC"
+    CONFIG['LDSHARED'] = "$(CXX) -G -KPIC -lCstd"
+  else
+    # GNU CHAIN
+    # on Unix we need a g++ link, not gcc.
+    CONFIG['LDSHARED'] = "$(CXX) -shared"
+  end
+
+when /openbsd/
+  # OpenBSD branch contributed by Guillaume Sellier.
+
+  # on Unix we need a g++ link, not gcc. On OpenBSD, linking against libstdc++ have to be explicitly done for shared libs
+  CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++ -fPIC"
+  CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
+
+when /darwin/
+  # on Unix we need a g++ link, not gcc.
+  # Ff line contributed by Daniel Harple.
+  CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
+
+when /aix/
+  CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G -Wl,-brtl"
+
+else
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+end
+
+create_makefile('melbourne')
+
+File.open("Makefile","a+") do |f|
+  f.puts <<END
+
+grammar.cpp: grammar.y
+	bison -o grammar.cpp grammar.y
+END
+end
+else
+File.open("Makefile","w+") do |f|
+  f.puts <<END
+all: 
+
+install:
+END
+end
+end