Mon Sep 15 16:21:10 2014 Eric Wong <[email protected]>

* io.c (struct io_advise_struct): 32 => 24 bytes on 64-bit

static int

big5_mbc_enc_len(const UChar* p, const UChar* e, OnigEncoding enc ARG_UNUSED)

{

}

static int

big5_hkscs_mbc_enc_len(const UChar* p, const UChar* e, OnigEncoding enc ARG_UNUSED)

{

}

static int

big5_uao_mbc_enc_len(const UChar* p, const UChar* e, OnigEncoding enc ARG_UNUSED)

{

}

static OnigCodePoint

OnigApplyAllCaseFoldFunc f, void* arg, OnigEncoding enc)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

property_name_to_ctype(OnigEncoding enc, UChar* p, UChar* end)

{

UChar *s = p, *e = end;

if (!prop) {

return onigenc_minimum_property_name_to_ctype(enc, s, e);

}

}

static int

#include "regenc.h"

#define ENC_IS_ISO_8859_1_CTYPE(code,ctype) \

((EncISO_8859_1_CtypeTable[code] & CTYPE_TO_BIT(ctype)) != 0)

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

#include "regenc.h"

#define ENC_ISO_8859_2_TO_LOWER_CASE(c) EncISO_8859_2_ToLowerCaseTable[c]

#define ENC_IS_ISO_8859_2_CTYPE(code,ctype) \

((EncISO_8859_2_CtypeTable[code] & CTYPE_TO_BIT(ctype)) != 0)

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

void* arg, OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigCaseFoldCodeItem items[], OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

void* arg, OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

OnigCaseFoldCodeItem items[], OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

OnigApplyAllCaseFoldFunc f, void* arg, OnigEncoding enc)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

property_name_to_ctype(OnigEncoding enc, UChar* p, UChar* end)

{

UChar *s = p, *e = end;

if (!prop) {

return onigenc_minimum_property_name_to_ctype(enc, s, e);

}

}

static int

#include "enc/unicode/name2ctype.h"

#define CODE_RANGES_NUM numberof(CodeRanges)

extern int

static int

us_ascii_mbc_enc_len(const UChar* p, const UChar* e, OnigEncoding enc)

{

}

OnigEncodingDefine(us_ascii, US_ASCII) = {

#include "regenc.h"

/* dummy for unsupported, statefull encoding */

ENC_DUMMY_UNICODE("UTF-16");

ENC_DUMMY_UNICODE("UTF-32");

#include "regenc.h"

#if 0

static const int EncLen_UTF16[] = {

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

#include "regenc.h"

#if 0

static const int EncLen_UTF16[] = {

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

static int

mbc_case_fold(OnigCaseFoldType flag, const UChar** pp,

{

const UChar* p = *pp;

static int

get_ctype_code_range(OnigCtype ctype, OnigCodePoint *sb_out,

{

*sb_out = 0x80;

return onigenc_unicode_ctype_code_range(ctype, ranges);

OnigApplyAllCaseFoldFunc f, void* arg, OnigEncoding enc ARG_UNUSED)

{

return onigenc_apply_all_case_fold_with_map(

flag, f, arg);

}

const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[], OnigEncoding enc ARG_UNUSED)

{

return onigenc_get_case_fold_codes_by_str_with_map(

flag, p, end, items);

}

#define ONIGURUMA

#define ONIGURUMA_VERSION_MAJOR 5

#ifdef __cplusplus

# ifndef HAVE_S

(op) == OP_EXACTMB3N || (op) == OP_EXACTMBN || (op) == OP_EXACTN_IC)

static int

{

int op;

if (ignore_case) {

switch (str_len) {

}

static int

regex_t* reg ARG_UNUSED, int ignore_case)

{

int len;

len = SIZE_OPCODE;

if (IS_NEED_STR_LEN_OP_EXACT(op))

len += SIZE_LENGTH;

return len;

}

static int

regex_t* reg, int ignore_case)

{

add_opcode(reg, op);

if (op == OP_EXACTMBN)

if (IS_NEED_STR_LEN_OP_EXACT(op)) {

if (op == OP_EXACTN_IC)

else

}

return 0;

}

static int

compile_length_string_node(Node* node, regex_t* reg)

{

OnigEncoding enc = reg->enc;

UChar *p, *prev;

StrNode* sn;

p = prev = sn->s;

prev_len = enclen(enc, p, sn->end);

p += prev_len;

rlen = 0;

for (; p < sn->end; ) {

len = enclen(enc, p, sn->end);

}

else {

rlen += r;

prev = p;

prev_len = len;

}

p += len;

}

rlen += r;

return rlen;

}

static int

compile_string_node(Node* node, regex_t* reg)

{

OnigEncoding enc = reg->enc;

UChar *p, *prev, *end;

StrNode* sn;

p = prev = sn->s;

prev_len = enclen(enc, p, end);

p += prev_len;

for (; p < end; ) {

len = enclen(enc, p, end);

}

else {

if (r) return r;

prev = p;

prev_len = len;

}

p += len;

}

}

static int

return 0;

}

else {

for (i = 0; i < SINGLE_BYTE_SIZE; i++) {

int is_word;

if (NCTYPE(y)->ascii_range)

qn->next_head_exact = n;

}

#endif

if (qn->lower <= 1) {

int ttype = NTYPE(qn->target);

if (IS_NODE_TYPE_SIMPLE(ttype)) {

}

static int

expand_case_fold_string_alt(int item_num, OnigCaseFoldCodeItem items[],

UChar *p, int slen, UChar *end,

regex_t* reg, Node **rnode)

{

Node *anode, *var_anode, *snode, *xnode, *an;

UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN];

*rnode = var_anode = NULL_NODE;

varlen = 0;

for (i = 0; i < item_num; i++) {

if (items[i].byte_len != slen) {

varlen = 1;

break;

}

}

if (varlen != 0) {

}

}

return varlen;

mem_err2:

len = enclen(reg->enc, p, end);

if (IS_NULL(snode)) {

if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {

top_root = root = onig_node_list_add(NULL_NODE, prev_node);

}

else {

alt_num *= (n + 1);

if (IS_NULL(root) && IS_NOT_NULL(prev_node)) {

top_root = root = onig_node_list_add(NULL_NODE, prev_node);

if (IS_NULL(root)) {

r = expand_case_fold_string_alt(n, items, p, len, end, reg, &prev_node);

if (r < 0) goto mem_err;

if (r == 1) {

if (IS_NULL(root)) {

top_root = prev_node;

root = NCAR(prev_node);

}

if (IS_NOT_NULL(root)) {

if (IS_NULL(onig_node_list_add(root, prev_node))) {

onig_node_free(prev_node);

p += len;

}

if (p < end) {

Node *srem;

/* ending */

top_root = (IS_NOT_NULL(top_root) ? top_root : prev_node);

onig_node_free(top_root);

mem_err:

r = ONIGERR_MEMORY;

6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 1

};

if (i == 0 && ONIGENC_MBC_MINLEN(enc) > 1)

return 20;

else

if (mm->max == ONIG_INFINITE_DISTANCE) return 0;

d = mm->max - mm->min;

/* return dist_vals[d] * 16 / (mm->min + 12); */

return (int )dist_vals[d];

else

if (right_len == 0) {

to->right_anchor |= left->right_anchor;

}

}

static int

case ANCHOR_END_BUF:

case ANCHOR_SEMI_END_BUF:

case ANCHOR_END_LINE:

add_opt_anc_info(&opt->anc, NANCHOR(node)->type);

break;

}

break;

case ANCHOR_LOOK_BEHIND_NOT:

break;

}

ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML |

ANCHOR_LOOK_BEHIND);

if (reg->anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF)) {

reg->anchor_dmin = opt.len.min;

OnigCodePoint code;

int i, r;

code = OnigAsciiLowerMap[i].to;

r = (*f)(OnigAsciiLowerMap[i].from, &code, 1, arg);

if (r != 0) return r;

extern int

onigenc_ascii_get_case_fold_codes_by_str(OnigCaseFoldType flag ARG_UNUSED,

{

if (0x41 <= *p && *p <= 0x5a) {

items[0].byte_len = 1;

extern int

{

return ONIG_NO_SUPPORT_CONFIG;

}

/* for single byte encodings */

extern int

onigenc_ascii_mbc_case_fold(OnigCaseFoldType flag ARG_UNUSED, const UChar** p,

{

*lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(**p);

onigenc_single_byte_code_to_mbc(OnigCodePoint code, UChar *buf, OnigEncoding enc ARG_UNUSED)

{

if (code > 0xff)

*buf = (UChar )(code & 0xff);

return 1;

}

extern UChar*

OnigEncoding enc ARG_UNUSED)

{

return (UChar* )s;

}

extern int

OnigEncoding enc ARG_UNUSED)

{

return TRUE;

}

extern int

OnigEncoding enc ARG_UNUSED)

{

return FALSE;

#if 0

extern int

onigenc_mbn_is_mbc_ambiguous(OnigEncoding enc, OnigCaseFoldType flag,

{

const UChar* p = *pp;

onigenc_minimum_property_name_to_ctype(OnigEncoding enc, UChar* p, UChar* end)

{

static const PosixBracketEntryType PBS[] = {

};

int len;

len = onigenc_strlen(enc, p, end);

if (len == pb->len &&

onigenc_with_ascii_strnicmp(enc, p, end, pb->name, pb->len) == 0)

return pb->ctype;

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*/

#ifndef REGINT_H

#ifndef RUBY_EXTERN

#include "ruby/config.h"

#include "ruby/defines.h"

#endif

#ifdef ONIG_ESCAPE_UCHAR_COLLISION

#undef ONIG_ESCAPE_UCHAR_COLLISION

#endif

#include "ruby/oniguruma.h"

RUBY_SYMBOL_EXPORT_BEGIN

short int len;

} PosixBracketEntryType;

#define USE_CRNL_AS_LINE_TERMINATOR

#define USE_UNICODE_PROPERTIES

#define UTF16_IS_SURROGATE_FIRST(c) (((c) & 0xfc) == 0xd8)

#define UTF16_IS_SURROGATE_SECOND(c) (((c) & 0xfc) == 0xdc)

#define ONIGENC_ISO_8859_1_TO_LOWER_CASE(c) \

OnigEncISO_8859_1_ToLowerCaseTable[c]

(int )(end - str), (int )(sstart - str));

#endif

best_len = ONIG_MISMATCH;

s = (UChar* )sstart;

pkeep = (UChar* )sstart;

if (s) {

UChar *q, *bp, buf[50];

int len;

bp = buf;

if (*p != OP_FINISH) { /* s may not be a valid pointer if OP_FINISH. */

for (i = 0, q = s; i < 7 && q < end; i++) {

*bp = 0;

fputs((char* )buf, stderr);

for (i = 0; i < 20 - (bp - buf); i++) fputc(' ', stderr);

onig_print_compiled_byte_code(stderr, p, p + strlen((char *)p), NULL, encode);

fprintf(stderr, "\n");

}

prev = s;

s += enclen(reg->enc, s, end);

while (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)

&& s < range) {

prev = s;

#define USE_UPPER_CASE_TABLE

#else

#define st_init_table onig_st_init_table

#define st_init_table_with_size onig_st_init_table_with_size

#define st_init_numtable onig_st_init_numtable

/* */

#define onig_st_is_member st_is_member

#endif

#define STATE_CHECK_STRING_THRESHOLD_LEN 7

extern OnigOpInfoType OnigOpInfo[];

extern void onig_print_compiled_byte_code P_((FILE* f, UChar* bp, UChar* bpend, UChar** nextp, OnigEncoding enc));

#ifdef ONIG_DEBUG_STATISTICS

extern void onig_statistics_init P_((void));

}

static int

{

int c, r;

const OnigCodePoint *ranges;

OnigCodePoint sb_out;

OnigEncoding enc = env->enc;

OnigOptionType option = env->option;

r = ONIGENC_GET_CTYPE_CODE_RANGE(enc, ctype, &sb_out, &ranges);

if (r == 0) {

if (ascii_range) {

}

static int

{

#define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20

#define POSIX_BRACKET_NAME_MIN_LEN 4

static const PosixBracketEntryType PBS[] = {

};

const PosixBracketEntryType *pb;

int not, i, r;

OnigCodePoint c;

OnigEncoding enc = env->enc;

UChar *p = *src;

if (onigenc_strlen(enc, p, end) < POSIX_BRACKET_NAME_MIN_LEN + 3)

goto not_posix_bracket;

if (onigenc_with_ascii_strncmp(enc, p, end, pb->name, pb->len) == 0) {

p = (UChar* )onigenc_step(enc, p, end, pb->len);

if (onigenc_with_ascii_strncmp(enc, p, end, (UChar* )":]", 2) != 0)

return ONIGERR_INVALID_POSIX_BRACKET_TYPE;

if (r != 0) return r;

PINC_S; PINC_S;

*src = p;

return 0;

return r;

}

static int

parse_char_property(Node** np, OnigToken* tok, UChar** src, UChar* end,

ScanEnv* env)

*np = node_new_cclass();

CHECK_NULL_RETURN_MEMERR(*np);

cc = NCCLASS(*np);

if (r != 0) return r;

if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);

}

};

static int

enum CCSTATE* state, ScanEnv* env)

{

int r;

return ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE;

if (*state == CCS_VALUE && *type != CCV_CLASS) {

BITSET_SET_BIT_CHKDUP(cc->bs, (int )(*vs));

else if (*type == CCV_CODE_POINT) {

r = add_code_range(&(cc->mbuf), env, *vs, *vs);

if (r < 0) return r;

}

}

}

static int

int* vs_israw, int v_israw,

enum CCVALTYPE intype, enum CCVALTYPE* type,

enum CCSTATE* state, ScanEnv* env)

switch (*state) {

case CCS_VALUE:

BITSET_SET_BIT_CHKDUP(cc->bs, (int )(*vs));

else if (*type == CCV_CODE_POINT) {

r = add_code_range(&(cc->mbuf), env, *vs, *vs);

if (r < 0) return r;

}

break;

return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;

}

bitset_set_range(env, cc->bs, (int )*vs, (int )v);

}

else {

r = add_code_range(&(cc->mbuf), env, *vs, v);

if (r < 0) return r;

}

}

else {

bitset_set_range(env, cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));

r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);

if (r < 0) return r;

#if 0

}

else

}

static int

ScanEnv* env)

{

int r, neg, len, fetched, and_start;

OnigCodePoint v, vs;

UChar *p;

Node* node;

CClassNode *cc, *prev_cc;

enum CCSTATE state;

enum CCVALTYPE val_type, in_type;

int val_israw, in_israw;

r = fetch_token_in_cc(tok, src, end, env);

if (r == TK_CHAR && tok->u.c == '^' && tok->escaped == 0) {

neg = 1;

CHECK_NULL_RETURN_MEMERR(node);

cc = NCCLASS(node);

and_start = 0;

state = CCS_START;

p = *src;

}

in_type = (len == 1 ? CCV_SB : CCV_CODE_POINT);

val_entry2:

&state, env);

if (r != 0) goto err;

break;

case TK_POSIX_BRACKET_OPEN:

if (r < 0) goto err;

if (r == 1) { /* is not POSIX bracket */

CC_ESC_WARN(env, (UChar* )"[");

break;

case TK_CHAR_TYPE:

if (r != 0) return r;

next_class:

if (r != 0) goto err;

break;

ctype = fetch_char_property_to_ctype(&p, end, env);

if (ctype < 0) return ctype;

if (r != 0) return r;

goto next_class;

}

break;

case TK_CC_CC_OPEN: /* [ */

{

CClassNode* acc;

if (r == 0) {

acc = NCCLASS(anode);

r = or_cclass(cc, acc, env);

}

onig_node_free(anode);

if (r != 0) goto err;

}

break;

case TK_CC_AND: /* && */

{

if (state == CCS_VALUE) {

&val_type, &state, env);

if (r != 0) goto err;

}

r = and_cclass(prev_cc, cc, env);

if (r != 0) goto err;

bbuf_free(cc->mbuf);

}

else {

prev_cc = cc;

cc = &work_cc;

}

initialize_cclass(cc);

}

break;

}

if (state == CCS_VALUE) {

&val_type, &state, env);

if (r != 0) goto err;

}

if (r != 0) goto err;

bbuf_free(cc->mbuf);

cc = prev_cc;

}

NCCLASS_SET_NOT(cc);

NCCLASS_CLEAR_NOT(cc);

if (IS_NCCLASS_NOT(cc) &&

IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) {

int is_empty;

err:

if (cc != NCCLASS(*np))

bbuf_free(cc->mbuf);

return r;

}

typedef struct {

ScanEnv* env;

CClassNode* cc;

Node* alt_root;

Node** ptail;

} IApplyCaseFoldArg;

IApplyCaseFoldArg* iarg;

ScanEnv* env;

CClassNode* cc;

BitSetRef bs;

iarg = (IApplyCaseFoldArg* )arg;

env = iarg->env;

cc = iarg->cc;

bs = cc->bs;

if (to_len == 1) {

int is_in = onig_is_code_in_cc(env->enc, from, cc);

#ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS

if ((is_in != 0 && !IS_NCCLASS_NOT(cc)) ||

(is_in == 0 && IS_NCCLASS_NOT(cc))) {

}

}

#else

if (is_in != 0) {

}

}

}

#endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */

}

static int

node_linebreak(Node** np, ScanEnv* env)

{

/* same as (?>\x0D\x0A|[\x0A-\x0D\x{85}\x{2028}\x{2029}]) */

np1 = node_new_cclass();

if (IS_NULL(np1)) goto err;

cc1 = NCCLASS(np1);

if (r != 0) goto err;

NCCLASS_SET_NOT(cc1);

np2 = node_new_cclass();

if (IS_NULL(np2)) goto err;

cc2 = NCCLASS(np2);

if (r != 0) goto err;

qn = node_new_quantifier(0, REPEAT_INFINITE, 0);

*np = node_new_cclass();

CHECK_NULL_RETURN_MEMERR(*np);

cc = NCCLASS(*np);

if (r != 0) return r;

if (tok->u.prop.not != 0) NCCLASS_SET_NOT(cc);

#ifdef USE_SHARED_CCLASS_TABLE

case TK_CC_OPEN:

{

CClassNode* cc;

OnigCodePoint code;

cc = NCCLASS(*np);

if (is_onechar_cclass(cc, &code)) {

onig_node_free(*np);

*np = node_new_empty();

CHECK_NULL_RETURN_MEMERR(*np);

r = node_str_cat_codepoint(*np, env->enc, code);

goto string_loop;

}

if (IS_IGNORECASE(env->option)) {

if (r != 0) {

return r;

}

}

}

break;

int type;

int regnum;

OnigOptionType option;

AbsAddrType call_addr;

/* for multiple call reference */

OnigDistance min_len; /* min length (byte) */

OnigDistance max_len; /* max length (byte) */

UChar* error;

UChar* error_end;

regex_t* reg; /* for reg->names only */

#ifdef USE_SUBEXP_CALL

UnsetAddrList* unset_addr_list;

#endif

int num_mem;

#ifdef USE_NAMED_GROUP

int num_named;