packages: ruby-ferret/ruby-ferret-ruby1.9.patch (NEW) - partial fix for rub...
baggins
baggins at pld-linux.org
Tue Mar 2 15:45:49 CET 2010
Author: baggins Date: Tue Mar 2 14:45:49 2010 GMT
Module: packages Tag: HEAD
---- Log message:
- partial fix for ruby 1.9
---- Files affected:
packages/ruby-ferret:
ruby-ferret-ruby1.9.patch (NONE -> 1.1) (NEW)
---- Diffs:
================================================================
Index: packages/ruby-ferret/ruby-ferret-ruby1.9.patch
diff -u /dev/null packages/ruby-ferret/ruby-ferret-ruby1.9.patch:1.1
--- /dev/null Tue Mar 2 15:45:49 2010
+++ packages/ruby-ferret/ruby-ferret-ruby1.9.patch Tue Mar 2 15:45:44 2010
@@ -0,0 +1,481 @@
+--- ferret-0.11.6/ext/r_index.c~ 2007-11-28 21:14:10.000000000 +0100
++++ ferret-0.11.6/ext/r_index.c 2010-03-01 23:13:32.028394802 +0100
+@@ -765,8 +765,8 @@
+ char *term;
+ int term_cnt = 0;
+ VALUE vals = rb_ary_new2(2);
+- RARRAY(vals)->len = 2;
+- rb_mem_clear(RARRAY(vals)->ptr, 2);
++ RARRAY_LEN(vals) = 2;
++ rb_mem_clear(RARRAY_PTR(vals), 2);
+
+
+ /* each is being called so there will be no current term */
+@@ -775,8 +775,8 @@
+
+ while (NULL != (term = te->next(te))) {
+ term_cnt++;
+- RARRAY(vals)->ptr[0] = rb_str_new(term, te->curr_term_len);
+- RARRAY(vals)->ptr[1] = INT2FIX(te->curr_ti.doc_freq);
++ RARRAY_PTR(vals)[0] = rb_str_new(term, te->curr_term_len);
++ RARRAY_PTR(vals)[1] = INT2FIX(te->curr_ti.doc_freq);
+ rb_yield(vals);
+ }
+ return INT2FIX(term_cnt);
+@@ -1040,13 +1040,13 @@
+ int doc_cnt = 0;
+ TermDocEnum *tde = (TermDocEnum *)DATA_PTR(self);
+ VALUE vals = rb_ary_new2(2);
+- RARRAY(vals)->len = 2;
+- rb_mem_clear(RARRAY(vals)->ptr, 2);
++ RARRAY_LEN(vals) = 2;
++ rb_mem_clear(RARRAY_PTR(vals), 2);
+
+ while (tde->next(tde)) {
+ doc_cnt++;
+- RARRAY(vals)->ptr[0] = INT2FIX(tde->doc_num(tde));
+- RARRAY(vals)->ptr[1] = INT2FIX(tde->freq(tde));
++ RARRAY_PTR(vals)[0] = INT2FIX(tde->doc_num(tde));
++ RARRAY_PTR(vals)[1] = INT2FIX(tde->freq(tde));
+ rb_yield(vals);
+
+ }
+@@ -1215,11 +1215,11 @@
+ VALUE *rpos;
+ int *positions = tv_term->positions;
+ rpositions = rb_ary_new2(freq);
+- rpos = RARRAY(rpositions)->ptr;
++ rpos = RARRAY_PTR(rpositions);
+ for (i = 0; i < freq; i++) {
+ rpos[i] = INT2FIX(positions[i]);
+ }
+- RARRAY(rpositions)->len = freq;
++ RARRAY_LEN(rpositions) = freq;
+ }
+ return rb_struct_new(cTVTerm, rtext, rpositions, NULL);
+ }
+@@ -1242,20 +1242,20 @@
+ rfield = ID2SYM(rb_intern(tv->field));
+
+ rterms = rb_ary_new2(t_cnt);
+- rts = RARRAY(rterms)->ptr;
++ rts = RARRAY_PTR(rterms);
+ for (i = 0; i < t_cnt; i++) {
+ rts[i] = frt_get_tv_term(&terms[i]);
+- RARRAY(rterms)->len++;
++ RARRAY_LEN(rterms)++;
+ }
+
+ if (tv->offsets) {
+ VALUE *ros;
+ Offset *offsets = tv->offsets;
+ roffsets = rb_ary_new2(o_cnt);
+- ros = RARRAY(roffsets)->ptr;
++ ros = RARRAY_PTR(roffsets);
+ for (i = 0; i < o_cnt; i++) {
+ ros[i] = frt_get_tv_offsets(&offsets[i]);
+- RARRAY(roffsets)->len++;
++ RARRAY_LEN(roffsets)++;
+ }
+ }
+
+@@ -1458,19 +1458,19 @@
+ {
+ int i;
+ df->destroy_data = true;
+- for (i = 0; i < RARRAY(value)->len; i++) {
+- val = rb_obj_as_string(RARRAY(value)->ptr[i]);
+- df_add_data_len(df, nstrdup(val), RSTRING(val)->len);
++ for (i = 0; i < RARRAY_LEN(value); i++) {
++ val = rb_obj_as_string(RARRAY_PTR(value)[i]);
++ df_add_data_len(df, nstrdup(val), RSTRING_LEN(val));
+ }
+ }
+ break;
+ case T_STRING:
+- df_add_data_len(df, rs2s(value), RSTRING(value)->len);
++ df_add_data_len(df, rs2s(value), RSTRING_LEN(value));
+ break;
+ default:
+ val = rb_obj_as_string(value);
+ df->destroy_data = true;
+- df_add_data_len(df, nstrdup(val), RSTRING(val)->len);
++ df_add_data_len(df, nstrdup(val), RSTRING_LEN(val));
+ break;
+ }
+ doc_add_field(doc, df);
+@@ -1498,9 +1498,9 @@
+ int i;
+ df = df_new("content");
+ df->destroy_data = true;
+- for (i = 0; i < RARRAY(rdoc)->len; i++) {
+- val = rb_obj_as_string(RARRAY(rdoc)->ptr[i]);
+- df_add_data_len(df, nstrdup(val), RSTRING(val)->len);
++ for (i = 0; i < RARRAY_LEN(rdoc); i++) {
++ val = rb_obj_as_string(RARRAY_PTR(rdoc)[i]);
++ df_add_data_len(df, nstrdup(val), RSTRING_LEN(val));
+ }
+ doc_add_field(doc, df);
+ }
+@@ -1511,13 +1511,13 @@
+ break;
+ case T_STRING:
+ df = df_add_data_len(df_new("content"), rs2s(rdoc),
+- RSTRING(rdoc)->len);
++ RSTRING_LEN(rdoc));
+ doc_add_field(doc, df);
+ break;
+ default:
+ val = rb_obj_as_string(rdoc);
+ df = df_add_data_len(df_new("content"), nstrdup(val),
+- RSTRING(val)->len);
++ RSTRING_LEN(val));
+ df->destroy_data = true;
+ doc_add_field(doc, df);
+ break;
+@@ -1597,14 +1597,14 @@
+ IndexReader **irs;
+ Check_Type(rreaders, T_ARRAY);
+
+- irs = ALLOC_N(IndexReader *, RARRAY(rreaders)->len);
+- i = RARRAY(rreaders)->len;
++ irs = ALLOC_N(IndexReader *, RARRAY_LEN(rreaders));
++ i = RARRAY_LEN(rreaders);
+ while (i-- > 0) {
+ IndexReader *ir;
+- Data_Get_Struct(RARRAY(rreaders)->ptr[i], IndexReader, ir);
++ Data_Get_Struct(RARRAY_PTR(rreaders)[i], IndexReader, ir);
+ irs[i] = ir;
+ }
+- iw_add_readers(iw, irs, RARRAY(rreaders)->len);
++ iw_add_readers(iw, irs, RARRAY_LEN(rreaders));
+ free(irs);
+ return self;
+ }
+@@ -1953,9 +1953,9 @@
+ rdata = rb_ary_new2(lazy_df->size);
+ for (i = 0; i < lazy_df->size; i++) {
+ char *data = lazy_df_get_data(lazy_df, i);
+- RARRAY(rdata)->ptr[i] =
++ RARRAY_PTR(rdata)[i] =
+ rb_str_new(data, lazy_df->data[i].length);
+- RARRAY(rdata)->len++;
++ RARRAY_LEN(rdata)++;
+ }
+ }
+ rb_hash_aset(self, rkey, rdata);
+@@ -2038,8 +2038,8 @@
+ rb_ivar_set(self, id_data, rdata);
+
+ for (i = 0; i < lazy_doc->size; i++) {
+- RARRAY(rfields)->ptr[i] = ID2SYM(rb_intern(lazy_doc->fields[i]->name));
+- RARRAY(rfields)->len++;
++ RARRAY_PTR(rfields)[i] = ID2SYM(rb_intern(lazy_doc->fields[i]->name));
++ RARRAY_LEN(rfields)++;
+ }
+ rb_ivar_set(self, id_fields, rfields);
+
+@@ -2115,11 +2115,11 @@
+
+ if (TYPE(rdir) == T_ARRAY) {
+ VALUE rdirs = rdir;
+- const int reader_cnt = RARRAY(rdir)->len;
++ const int reader_cnt = RARRAY_LEN(rdir);
+ IndexReader **sub_readers = ALLOC_N(IndexReader *, reader_cnt);
+ int i;
+ for (i = 0; i < reader_cnt; i++) {
+- rdir = RARRAY(rdirs)->ptr[i];
++ rdir = RARRAY_PTR(rdirs)[i];
+ switch (TYPE(rdir)) {
+ case T_DATA:
+ if (CLASS_OF(rdir) == cIndexReader) {
+@@ -2235,11 +2235,11 @@
+ int offset;
+ offset = FIX2INT(roffset);
+ Check_Type(rnorms, T_STRING);
+- if (RSTRING(rnorms)->len < offset + ir->max_doc(ir)) {
++ if (RSTRING_LEN(rnorms) < offset + ir->max_doc(ir)) {
+ rb_raise(rb_eArgError, "supplied a string of length:%d to "
+ "IndexReader#get_norms_into but needed a string of length "
+ "offset:%d + maxdoc:%d",
+- RSTRING(rnorms)->len, offset, ir->max_doc(ir));
++ RSTRING_LEN(rnorms), offset, ir->max_doc(ir));
+ }
+
+ ir_get_norms_into(ir, frt_field(rfield),
+@@ -2382,8 +2382,8 @@
+ len = max - pos;
+ ary = rb_ary_new2(len);
+ for (i = 0; i < len; i++) {
+- RARRAY(ary)->ptr[i] = frt_get_lazy_doc(ir->get_lazy_doc(ir, i + pos));
+- RARRAY(ary)->len++;
++ RARRAY_PTR(ary)[i] = frt_get_lazy_doc(ir->get_lazy_doc(ir, i + pos));
++ RARRAY_LEN(ary)++;
+ }
+ return ary;
+ }
+--- ferret-0.11.6/ext/r_analysis.c.orig 2007-10-09 02:44:32.000000000 +0200
++++ ferret-0.11.6/ext/r_analysis.c 2010-03-02 15:37:06.422124836 +0100
+@@ -1,6 +1,6 @@
+-#include <regex.h>
+ #include <locale.h>
+-#include <st.h>
++#include <ruby/st.h>
++#include <ruby/regex.h>
+ #include "ferret.h"
+ #include "analysis.h"
+
+@@ -53,7 +53,7 @@
+ int
+ frt_rb_hash_size(VALUE hash)
+ {
+- return RHASH(hash)->tbl->num_entries;
++ return RHASH_SIZE(hash);
+ }
+
+ /****************************************************************************
+@@ -69,11 +69,11 @@
+ int i, len;
+ VALUE rstr;
+ Check_Type(rstop_words, T_ARRAY);
+- len = RARRAY(rstop_words)->len;
+- stop_words = ALLOC_N(char *, RARRAY(rstop_words)->len + 1);
++ len = RARRAY_LEN(rstop_words);
++ stop_words = ALLOC_N(char *, RARRAY_LEN(rstop_words) + 1);
+ stop_words[len] = NULL;
+ for (i = 0; i < len; i++) {
+- rstr = rb_obj_as_string(RARRAY(rstop_words)->ptr[i]);
++ rstr = rb_obj_as_string(RARRAY_PTR(rstop_words)[i]);
+ stop_words[i] = rs2s(rstr);
+ }
+ return stop_words;
+@@ -132,7 +132,7 @@
+ if (rt == Qnil) return NULL;
+
+ Data_Get_Struct(rt, RToken, rtk);
+- tk_set(tk, rs2s(rtk->text), RSTRING(rtk->text)->len,
++ tk_set(tk, rs2s(rtk->text), RSTRING_LEN(rtk->text),
+ rtk->start, rtk->end, rtk->pos_inc);
+ return tk;
+ }
+@@ -372,7 +372,7 @@
+ RToken *token;
+ char *buf;
+ GET_TK(token, self);
+- buf = alloca(RSTRING(token->text)->len + 80);
++ buf = alloca(RSTRING_LEN(token->text) + 80);
+ sprintf(buf, "token[\"%s\":%d:%d:%d]", rs2s(token->text),
+ token->start, token->end, token->pos_inc);
+ return rb_str_new2(buf);
+@@ -697,8 +697,8 @@
+ struct RString *rtext = RSTRING(RETS(ts)->rtext);
+ Check_Type(RETS(ts)->regex, T_REGEXP);
+ ret = ruby_re_search(RREGEXP(RETS(ts)->regex)->ptr,
+- rtext->ptr, rtext->len,
+- RETS(ts)->curr_ind, rtext->len - RETS(ts)->curr_ind,
++ RSTRING_PTR(rtext), RSTRING_LEN(rtext),
++ RETS(ts)->curr_ind, RSTRING_LEN(rtext) - RETS(ts)->curr_ind,
+ ®s);
+
+ if (ret == -2) rb_raise(rb_eStandardError, "regexp buffer overflow");
+@@ -707,13 +707,13 @@
+ beg = regs.beg[0];
+ RETS(ts)->curr_ind = end = regs.end[0];
+ if (NIL_P(RETS(ts)->proc)) {
+- return tk_set(&(CachedTS(ts)->token), rtext->ptr + beg, end - beg,
++ return tk_set(&(CachedTS(ts)->token), RSTRING_PTR(rtext) + beg, end - beg,
+ beg, end, 1);
+ } else {
+- VALUE rtok = rb_str_new(rtext->ptr + beg, end - beg);
++ VALUE rtok = rb_str_new(RSTRING_PTR(rtext) + beg, end - beg);
+ rtok = rb_funcall(RETS(ts)->proc, id_call, 1, rtok);
+ return tk_set(&(CachedTS(ts)->token), rs2s(rtok),
+- RSTRING(rtok)->len, beg, end, 1);
++ RSTRING_LEN(rtok), beg, end, 1);
+ }
+ }
+
+@@ -1029,8 +1029,8 @@
+ }
+ if (TYPE(key) == T_ARRAY) {
+ int i;
+- for (i = RARRAY(key)->len - 1; i >= 0; i--) {
+- frt_add_mapping_i(mf, RARRAY(key)->ptr[i], to);
++ for (i = RARRAY_LEN(key) - 1; i >= 0; i--) {
++ frt_add_mapping_i(mf, RARRAY_PTR(key)[i], to);
+ }
+ }
+ else {
+--- ferret-0.11.6/ext/ferret.c~ 2007-10-08 10:47:04.000000000 +0200
++++ ferret-0.11.6/ext/ferret.c 2010-03-02 15:38:31.451322502 +0100
+@@ -162,14 +162,14 @@
+ char *
+ rs2s(VALUE rstr)
+ {
+- return (char *)(RSTRING(rstr)->ptr ? RSTRING(rstr)->ptr : EMPTY_STRING);
++ return (char *)(RSTRING_PTR(rstr) ? RSTRING_PTR(rstr) : EMPTY_STRING);
+ }
+
+ char *
+ nstrdup(VALUE rstr)
+ {
+ char *old = rs2s(rstr);
+- int len = RSTRING(rstr)->len;
++ int len = RSTRING_LEN(rstr);
+ char *new = ALLOC_N(char, len + 1);
+ memcpy(new, old, len + 1);
+ return new;
+@@ -295,7 +295,7 @@
+ char *field = StringValuePtr(rfield);
+ char *text = StringValuePtr(rtext);
+ char *term_str = ALLOC_N(char,
+- 5 + RSTRING(rfield)->len + RSTRING(rtext)->len);
++ 5 + RSTRING_LEN(rfield) + RSTRING_LEN(rtext));
+ sprintf(term_str, "%s:%s", field, text);
+ rstr = rb_str_new2(term_str);
+ free(term_str);
+--- ferret-0.11.6/ext/r_search.c~ 2007-11-24 00:26:33.000000000 +0100
++++ ferret-0.11.6/ext/r_search.c 2010-03-02 15:40:02.774187117 +0100
+@@ -1,5 +1,5 @@
+ #include "ferret.h"
+-#include <st.h>
++#include <ruby/st.h>
+ #include <rubysig.h>
+ #include <ctype.h>
+ #include <array.h>
+@@ -161,8 +161,8 @@
+ VALUE hit_ary = rb_ary_new2(td->size);
+
+ for (i = 0; i < td->size; i++) {
+- RARRAY(hit_ary)->ptr[i] = frt_get_hit(td->hits[i]);
+- RARRAY(hit_ary)->len++;
++ RARRAY_PTR(hit_ary)[i] = frt_get_hit(td->hits[i]);
++ RARRAY_LEN(hit_ary)++;
+ }
+
+ rtop_docs = rb_struct_new(cTopDocs,
+@@ -187,7 +187,7 @@
+ int i;
+ VALUE rhits = rb_funcall(self, id_hits, 0);
+ Searcher *sea = (Searcher *)DATA_PTR(rb_funcall(self, id_searcher, 0));
+- const int len = RARRAY(rhits)->len;
++ const int len = RARRAY_LEN(rhits);
+ char *str = ALLOC_N(char, len * 64 + 100);
+ char *s = str;
+ char *field = "id";
+@@ -203,7 +203,7 @@
+ s += strlen(s);
+
+ for (i = 0; i < len; i++) {
+- VALUE rhit = RARRAY(rhits)->ptr[i];
++ VALUE rhit = RARRAY_PTR(rhits)[i];
+ int doc_id = FIX2INT(rb_funcall(rhit, id_doc, 0));
+ char *value = "";
+ LazyDoc *lzd = sea->get_lazy_doc(sea, doc_id);
+@@ -280,7 +280,7 @@
+ VALUE rhit;
+ LazyDoc *lzd;
+ Searcher *sea = (Searcher *)DATA_PTR(rb_funcall(self, id_searcher, 0));
+- const int num_hits = RARRAY(rhits)->len;
++ const int num_hits = RARRAY_LEN(rhits);
+ int doc_id;
+ int len = 32768;
+ char *str = ALLOC_N(char, len);
+@@ -291,7 +291,7 @@
+ for (i = 0; i < num_hits; i++) {
+ if (i) *(s++) = ',';
+ *(s++) = '{';
+- rhit = RARRAY(rhits)->ptr[i];
++ rhit = RARRAY_PTR(rhits)[i];
+ doc_id = FIX2INT(rb_funcall(rhit, id_doc, 0));
+ lzd = sea->get_lazy_doc(sea, doc_id);
+ s = frt_lzd_load_to_json(lzd, &str, s, &len);
+@@ -1165,15 +1165,15 @@
+ {
+ int i;
+ char *t;
+- if (RARRAY(rterm)->len < 1) {
++ if (RARRAY_LEN(rterm) < 1) {
+ rb_raise(rb_eArgError, "Cannot add empty array to a "
+ "PhraseQuery. You must add either a string or "
+ "an array of strings");
+ }
+- t = StringValuePtr(RARRAY(rterm)->ptr[0]);
++ t = StringValuePtr(RARRAY_PTR(rterm)[0]);
+ phq_add_term(q, t, pos_inc);
+- for (i = 1; i < RARRAY(rterm)->len; i++) {
+- t = StringValuePtr(RARRAY(rterm)->ptr[i]);
++ for (i = 1; i < RARRAY_LEN(rterm); i++) {
++ t = StringValuePtr(RARRAY_PTR(rterm)[i]);
+ phq_append_multi_term(q, t);
+ }
+ break;
+@@ -1591,8 +1591,8 @@
+ {
+ Query *q = spanmtq_new(frt_field(rfield));
+ int i;
+- for (i = RARRAY(rterms)->len - 1; i >= 0; i--) {
+- spanmtq_add_term(q, StringValuePtr(RARRAY(rterms)->ptr[i]));
++ for (i = RARRAY_LEN(rterms) - 1; i >= 0; i--) {
++ spanmtq_add_term(q, StringValuePtr(RARRAY_PTR(rterms)[i]));
+ }
+ Frt_Wrap_Struct(self, NULL, &frt_q_free, q);
+ object_add(q, self);
+@@ -1716,8 +1716,8 @@
+ int i;
+ Query *clause;
+ Check_Type(v, T_ARRAY);
+- for (i = 0; i < RARRAY(v)->len; i++) {
+- Data_Get_Struct(RARRAY(v)->ptr[i], Query, clause);
++ for (i = 0; i < RARRAY_LEN(v); i++) {
++ Data_Get_Struct(RARRAY_PTR(v)[i], Query, clause);
+ spannq_add_clause(q, clause);
+ }
+ }
+@@ -1782,8 +1782,8 @@
+ int i;
+ Query *clause;
+ Check_Type(rclauses, T_ARRAY);
+- for (i = 0; i < RARRAY(rclauses)->len; i++) {
+- Data_Get_Struct(RARRAY(rclauses)->ptr[i], Query, clause);
++ for (i = 0; i < RARRAY_LEN(rclauses); i++) {
++ Data_Get_Struct(RARRAY_PTR(rclauses)[i], Query, clause);
+ spanoq_add_clause(q, clause);
+ }
+ }
+@@ -2277,8 +2277,8 @@
+ case 1:
+ if (TYPE(rfields) == T_ARRAY) {
+ int i;
+- for (i = 0; i < RARRAY(rfields)->len; i++) {
+- frt_sort_add(sort, RARRAY(rfields)->ptr[i], reverse);
++ for (i = 0; i < RARRAY_LEN(rfields); i++) {
++ frt_sort_add(sort, RARRAY_PTR(rfields)[i], reverse);
+ }
+ } else {
+ frt_sort_add(sort, rfields, reverse);
+@@ -2753,8 +2753,8 @@
+ VALUE rexcerpts = rb_ary_new2(size);
+
+ for (i = 0; i < size; i++) {
+- RARRAY(rexcerpts)->ptr[i] = rb_str_new2(excerpts[i]);
+- RARRAY(rexcerpts)->len++;
++ RARRAY_PTR(rexcerpts)[i] = rb_str_new2(excerpts[i]);
++ RARRAY_LEN(rexcerpts)++;
+ }
+ ary_destroy(excerpts, &free);
+ return rexcerpts;
+@@ -2870,10 +2870,10 @@
+ rsearcher = argv[i];
+ switch (TYPE(rsearcher)) {
+ case T_ARRAY:
+- capa += RARRAY(rsearcher)->len;
++ capa += RARRAY_LEN(rsearcher);
+ REALLOC_N(searchers, Searcher *, capa);
+- for (j = 0; j < RARRAY(rsearcher)->len; j++) {
+- VALUE rs = RARRAY(rsearcher)->ptr[j];
++ for (j = 0; j < RARRAY_LEN(rsearcher); j++) {
++ VALUE rs = RARRAY_PTR(rsearcher)[j];
+ Data_Get_Struct(rs, Searcher, s);
+ searchers[top++] = s;
+ }
================================================================
More information about the pld-cvs-commit
mailing list