xapian-bindings/lua/util.i

   1 /* lua/util.i: custom lua typemaps for xapian-bindings
   2  *
   3  * Copyright (C) 2011 Xiaona Han
   4  * Copyright (C) 2011,2012,2017 Olly Betts
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  19  * USA
  20  */
  21
  22 // "end" is a keyword in Lua, so we rename it to "_end"
  23 %rename("_end") end;
  24
  25 %rename("__tostring") get_description;
  26
  27 %{
  28 #if LUA_VERSION_NUM-0 >= 502
  29 // luaL_typerror was removed in Lua 5.2.
  30 int luaL_typerror (lua_State *L, int narg, const char *tname) {
  31   const char *msg = lua_pushfstring(L, "%s expected, got %s",
  32                                     tname, luaL_typename(L, narg));
  33   return luaL_argerror(L, narg, msg);
  34 }
  35 #endif
  36 %}
  37
  38 %define SUB_CLASS(NS, CLASS)
  39 %{
  40 class lua##CLASS : public NS::CLASS {
  41     int r;
  42     lua_State* L;
  43
  44   public:
  45     lua##CLASS(lua_State* S) {
  46         L = S;
  47         if (!lua_isfunction(L, -1)) {
  48             luaL_typerror(L, -1, "function");
  49         }
  50         r = luaL_ref(L, LUA_REGISTRYINDEX);
  51     }
  52
  53     ~lua##CLASS() {
  54         luaL_unref(L, LUA_REGISTRYINDEX, r);
  55     }
  56
  57     bool operator()(const std::string &term) const {
  58         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
  59         if (!lua_isfunction(L, -1)) {
  60             luaL_typerror(L, -1, "function");
  61         }
  62
  63         lua_pushlstring(L, (char *)term.c_str(), term.length());
  64         if (lua_pcall(L, 1, 1, 0) != 0) {
  65             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
  66         }
  67         if (!lua_isboolean(L, -1)) {
  68             luaL_error(L, "function must return a boolean");
  69         }
  70         bool result = lua_toboolean(L, -1);
  71         lua_pop(L, 1);
  72         return result;
  73     }
  74 };
  75 %}
  76
  77 %enddef
  78
  79 SUB_CLASS(Xapian, ExpandDecider)
  80 SUB_CLASS(Xapian, Stopper)
  81
  82 %{
  83 class luaMatchDecider : public Xapian::MatchDecider {
  84     int r;
  85     lua_State* L;
  86
  87   public:
  88     luaMatchDecider(lua_State* S) {
  89         L = S;
  90         if (!lua_isfunction(L, -1)) {
  91             luaL_typerror(L, -1, "function");
  92         }
  93         r = luaL_ref(L, LUA_REGISTRYINDEX);
  94     }
  95
  96     ~luaMatchDecider() {
  97         luaL_unref(L, LUA_REGISTRYINDEX, r);
  98     }
  99
 100     bool operator()(const Xapian::Document &doc) const {
 101         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 102         if (!lua_isfunction(L, -1)) {
 103             luaL_typerror(L, -1, "function");
 104         }
 105
 106         SWIG_NewPointerObj(L, &doc, SWIGTYPE_p_Xapian__Document, 0);
 107         if (lua_pcall(L, 1, 1, 0) != 0) {
 108             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 109         }
 110         if (!lua_isboolean(L, -1)) {
 111             luaL_error(L, "function must return a boolean");
 112         }
 113         bool result = lua_toboolean(L, -1);
 114         lua_pop(L, 1);
 115         return result;
 116     }
 117 };
 118 %}
 119
 120 %{
 121 class luaStemImplementation : public Xapian::StemImplementation {
 122     int r;
 123     lua_State* L;
 124
 125   public:
 126     luaStemImplementation(lua_State* S) {
 127         L = S;
 128         if (!lua_isfunction(L, -1)) {
 129             luaL_typerror(L, -1, "function");
 130         }
 131         r = luaL_ref(L, LUA_REGISTRYINDEX);
 132     }
 133
 134     ~luaStemImplementation() {
 135         luaL_unref(L, LUA_REGISTRYINDEX, r);
 136     }
 137
 138     std::string operator()(const std::string &word) {
 139         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 140         if (!lua_isfunction(L, -1)) {
 141             luaL_typerror(L, -1, "function");
 142         }
 143
 144         lua_pushlstring(L, (char *)word.c_str(), word.length());
 145         if (lua_pcall(L, 1, 1, 0) != 0) {
 146             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 147         }
 148         if (!lua_isstring(L, -1)) {
 149             luaL_error(L, "function must return a string");
 150         }
 151         size_t len;
 152         const char * p = lua_tolstring(L, -1, &len);
 153         std::string result(p, len);
 154         lua_pop(L, 1);
 155         return result;
 156     }
 157
 158     std::string get_description() const {
 159         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 160         if (!lua_isfunction(L, -1)) {
 161             luaL_typerror(L, -1, "function");
 162         }
 163
 164         if (lua_pcall(L, 0, 1, 0) != 0) {
 165             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 166         }
 167         if (!lua_isstring(L, -1)) {
 168             luaL_error(L, "function must return a string");
 169         }
 170
 171         size_t len;
 172         const char * p = lua_tolstring(L, -1, &len);
 173         std::string result(p, len);
 174         lua_pop(L, 1);
 175         return result;
 176     }
 177 };
 178 %}
 179
 180 %{
 181 class luaKeyMaker : public Xapian::KeyMaker {
 182     int r;
 183     lua_State* L;
 184
 185   public:
 186     luaKeyMaker(lua_State* S) {
 187         L = S;
 188         if (!lua_isfunction(L, -1)) {
 189             luaL_typerror(L, -1, "function");
 190         }
 191         r = luaL_ref(L, LUA_REGISTRYINDEX);
 192     }
 193
 194     ~luaKeyMaker() {
 195         luaL_unref(L, LUA_REGISTRYINDEX, r);
 196     }
 197
 198     std::string operator()(const Xapian::Document &doc) const {
 199         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 200         if (!lua_isfunction(L, -1)) {
 201             luaL_typerror(L, -1, "function");
 202         }
 203
 204         SWIG_NewPointerObj(L, &doc, SWIGTYPE_p_Xapian__Document, 0);
 205         if (lua_pcall(L, 1, 1, 0) != 0) {
 206             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 207         }
 208         if (!lua_isstring(L, -1)) {
 209             luaL_error(L, "function must return a string");
 210         }
 211         size_t len;
 212         const char * p = lua_tolstring(L, -1, &len);
 213         std::string result(p, len);
 214         lua_pop(L, 1);
 215         return result;
 216     }
 217 };
 218 %}
 219
 220 %{
 221 class luaRangeProcessor : public Xapian::RangeProcessor {
 222     int r;
 223     lua_State* L;
 224
 225   public:
 226     luaRangeProcessor(lua_State* S) {
 227         L = S;
 228         if (!lua_isfunction(L, -1)) {
 229             luaL_typerror(L, -1, "function");
 230         }
 231         r = luaL_ref(L, LUA_REGISTRYINDEX);
 232     }
 233
 234     ~luaRangeProcessor() {
 235         luaL_unref(L, LUA_REGISTRYINDEX, r);
 236     }
 237
 238     Xapian::Query operator()(const std::string& begin, const std::string& end) {
 239         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 240         if (!lua_isfunction(L, -1)) {
 241             luaL_typerror(L, -1, "function");
 242         }
 243
 244         lua_pushlstring(L, (char *)begin.c_str(), begin.length());
 245         lua_pushlstring(L, (char *)end.c_str(), end.length());
 246
 247         if (lua_pcall(L, 2, 1, 0) != 0) {
 248             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 249         }
 250
 251         // Allow the function to return a string or Query object.
 252         if (lua_isstring(L, -1)) {
 253             size_t len;
 254             const char * p = lua_tolstring(L, -1, &len);
 255             std::string result(p, len);
 256             lua_pop(L, 1);
 257             return Xapian::Query(result);
 258         }
 259
 260         Xapian::Query *subq = 0;
 261         if (!lua_isuserdata(L, -1) ||
 262             SWIG_ConvertPtr(L, -1, (void **)&subq,
 263                             SWIGTYPE_p_Xapian__Query, 0) == -1) {
 264             lua_pop(L, 1);
 265             luaL_error(L, "function must return a string or Query object");
 266         }
 267
 268         lua_pop(L, 1);
 269         return *subq;
 270     }
 271 };
 272 %}
 273
 274 %{
 275 class luaValueRangeProcessor : public Xapian::ValueRangeProcessor {
 276     int r;
 277     lua_State* L;
 278
 279   public:
 280     luaValueRangeProcessor(lua_State* S) {
 281         L = S;
 282         if (!lua_isfunction(L, -1)) {
 283             luaL_typerror(L, -1, "function");
 284         }
 285         r = luaL_ref(L, LUA_REGISTRYINDEX);
 286     }
 287
 288     ~luaValueRangeProcessor() {
 289         luaL_unref(L, LUA_REGISTRYINDEX, r);
 290     }
 291
 292     Xapian::valueno operator()(std::string &begin, std::string &end) {
 293         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 294         if (!lua_isfunction(L, -1)) {
 295             luaL_typerror(L, -1, "function");
 296         }
 297
 298         lua_pushlstring(L, (char *)begin.c_str(), begin.length());
 299         lua_pushlstring(L, (char *)end.c_str(), end.length());
 300
 301         if (lua_pcall(L, 2, 1, 0) != 0) {
 302             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 303         }
 304         if (!lua_isnumber(L, -1)) {
 305             luaL_error(L, "function must return a number");
 306         }
 307         Xapian::valueno result(lua_tonumber(L, -1));
 308         lua_pop(L, 1);
 309         return result;
 310     }
 311 };
 312 %}
 313
 314 %{
 315 class luaFieldProcessor : public Xapian::FieldProcessor {
 316     int r;
 317     lua_State* L;
 318
 319   public:
 320     luaFieldProcessor(lua_State* S) {
 321         L = S;
 322         if (!lua_isfunction(L, -1)) {
 323             luaL_typerror(L, -1, "function");
 324         }
 325         r = luaL_ref(L, LUA_REGISTRYINDEX);
 326     }
 327
 328     ~luaFieldProcessor() {
 329         luaL_unref(L, LUA_REGISTRYINDEX, r);
 330     }
 331
 332     Xapian::Query operator()(const std::string &str) {
 333         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 334         if (!lua_isfunction(L, -1)) {
 335             luaL_typerror(L, -1, "function");
 336         }
 337
 338         lua_pushlstring(L, (char *)str.c_str(), str.length());
 339
 340         if (lua_pcall(L, 1, 1, 0) != 0) {
 341             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 342         }
 343
 344         // Allow the function to return a string or Query object.
 345         if (lua_isstring(L, -1)) {
 346             size_t len;
 347             const char * p = lua_tolstring(L, -1, &len);
 348             std::string result(p, len);
 349             lua_pop(L, 1);
 350             return Xapian::Query(result);
 351         }
 352
 353         Xapian::Query *subq = 0;
 354         if (!lua_isuserdata(L, -1) ||
 355             SWIG_ConvertPtr(L, -1, (void **)&subq,
 356                             SWIGTYPE_p_Xapian__Query, 0) == -1) {
 357             lua_pop(L, 1);
 358             luaL_error(L, "function must return a string or Query object");
 359         }
 360
 361         lua_pop(L, 1);
 362         return *subq;
 363     }
 364 };
 365 %}
 366
 367 %{
 368 class luaMatchSpy : public Xapian::MatchSpy {
 369     int r;
 370     lua_State* L;
 371
 372   public:
 373     luaMatchSpy(lua_State* S) {
 374         L = S;
 375         if (!lua_isfunction(L, -1)) {
 376             luaL_typerror(L, -1, "function");
 377         }
 378         r = luaL_ref(L, LUA_REGISTRYINDEX);
 379     }
 380
 381     ~luaMatchSpy() {
 382         luaL_unref(L, LUA_REGISTRYINDEX, r);
 383     }
 384
 385     void operator()(const Xapian::Document &doc, double wt) {
 386         lua_rawgeti(L, LUA_REGISTRYINDEX, r);
 387         if (!lua_isfunction(L, -1)) {
 388             luaL_typerror(L, -1, "function");
 389         }
 390
 391         SWIG_NewPointerObj(L, &doc, SWIGTYPE_p_Xapian__Document, 0);
 392         SWIG_NewPointerObj(L, &wt, SWIGTYPE_p_Xapian__Weight, 0);
 393         if (lua_pcall(L, 2, 1, 0) != 0) {
 394             luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 395         }
 396     }
 397 };
 398 %}
 399
 400 %define SUB_CLASS_TYPEMAPS(NS, CLASS)
 401
 402 %typemap(typecheck, precedence=100) NS::CLASS * {
 403     void *ptr;
 404     if (lua_isfunction(L, $input) || (SWIG_isptrtype(L, $input) && !SWIG_ConvertPtr(L, $input, (void **) &ptr, $descriptor(NS::CLASS *), 0))) {
 405         $1 = 1;
 406     } else {
 407         $1 = 0;
 408     }
 409 }
 410 %typemap(in) NS::CLASS * {
 411     if (lua_isfunction(L, $input)) {
 412         $1 = new lua##CLASS(L);
 413     } else {
 414         if (!SWIG_IsOK(SWIG_ConvertPtr(L, $input, (void**)&$1, $descriptor(NS::CLASS *), 0))) {
 415             SWIG_fail;
 416         }
 417     }
 418 }
 419
 420 %enddef
 421 SUB_CLASS_TYPEMAPS(Xapian, MatchDecider)
 422 SUB_CLASS_TYPEMAPS(Xapian, ExpandDecider)
 423 SUB_CLASS_TYPEMAPS(Xapian, Stopper)
 424 SUB_CLASS_TYPEMAPS(Xapian, StemImplementation)
 425 SUB_CLASS_TYPEMAPS(Xapian, KeyMaker)
 426 SUB_CLASS_TYPEMAPS(Xapian, RangeProcessor)
 427 SUB_CLASS_TYPEMAPS(Xapian, ValueRangeProcessor)
 428 SUB_CLASS_TYPEMAPS(Xapian, FieldProcessor)
 429
 430 %luacode {
 431 function xapian.Iterator(begin, _end)
 432         local iter = begin;
 433         local isFirst = 1
 434         return function()
 435                 if iter:equals(_end) then
 436                         return nil
 437                 else
 438                         if isFirst == 1 then
 439                                 isFirst = 0;
 440                                 return iter
 441                         else
 442                                 iter:next()
 443                                 if iter:equals(_end) then
 444                                         return nil
 445                                 end
 446                                 return iter
 447                         end
 448                 end
 449         end
 450 end
 451 }
 452
 453 #define XAPIAN_MIXED_SUBQUERIES_BY_ITERATOR_TYPEMAP
 454
 455 %typemap(typecheck, precedence=500) (XapianSWIGQueryItor qbegin, XapianSWIGQueryItor qend) {
 456     $1 = lua_istable(L, $input);
 457     /* FIXME: if we add more array typemaps, we'll need to check the elements
 458      * of the array here to disambiguate. */
 459 }
 460
 461 %{
 462 class XapianSWIGQueryItor {
 463     lua_State* L;
 464     int index;
 465     int i;
 466
 467   public:
 468     typedef std::random_access_iterator_tag iterator_category;
 469     typedef Xapian::Query value_type;
 470     typedef Xapian::termcount_diff difference_type;
 471     typedef Xapian::Query * pointer;
 472     typedef Xapian::Query & reference;
 473
 474     XapianSWIGQueryItor() { }
 475
 476     void begin(lua_State * S, int index_) {
 477         L = S;
 478         index = index_;
 479         i = 0;
 480     }
 481
 482     void end(lua_State * S, int index_, int n) {
 483         L = S;
 484         index = index_;
 485         i = n;
 486     }
 487
 488     void end() {
 489         i = 0;
 490     }
 491
 492     XapianSWIGQueryItor & operator++() {
 493         ++i;
 494         return *this;
 495     }
 496
 497     Xapian::Query operator*() const {
 498         lua_rawgeti(L, index, i+1);
 499         if (lua_isstring(L, -1)) {
 500             size_t len = 0;
 501             const char *p = lua_tolstring(L, -1, &len);
 502             lua_pop(L,1);
 503             return Xapian::Query(string(p, len));
 504         }
 505
 506         Xapian::Query *subq = 0;
 507         if (!lua_isuserdata(L, -1) ||
 508             SWIG_ConvertPtr(L, -1, (void **)&subq,
 509                             SWIGTYPE_p_Xapian__Query, 0) == -1) {
 510             lua_pop(L, 1);
 511             luaL_argerror(L, index,
 512                           "elements must be Query objects or strings");
 513         }
 514
 515         lua_pop(L, 1);
 516         return *subq;
 517     }
 518
 519     bool operator==(const XapianSWIGQueryItor & o) {
 520         return i == o.i;
 521     }
 522
 523     bool operator!=(const XapianSWIGQueryItor & o) {
 524         return !(*this == o);
 525     }
 526
 527     difference_type operator-(const XapianSWIGQueryItor &o) const {
 528         return i - o.i;
 529     }
 530 };
 531
 532 %}
 533
 534 %typemap(in) (XapianSWIGQueryItor qbegin, XapianSWIGQueryItor qend) {
 535     if (lua_istable(L, $input)) {
 536         $1.begin(L, $input);
 537         $2.end(L, $input, lua_rawlen(L, $input));
 538     } else {
 539         $1.end();
 540         $2.end();
 541     }
 542 }
 543
 544 %define OUTPUT_ITERATOR_METHODS(NS, CLASS, ITERATOR_CLASS, ITERATOR_BEGIN, ITERATOR_END, DEREF_METHOD, PARAMETER_NAME, PARAMETER_VALUE)
 545
 546 %extend NS::CLASS {
 547     std::pair<NS::ITERATOR_CLASS , NS::ITERATOR_CLASS> DEREF_METHOD(PARAMETER_NAME) {
 548         return std::make_pair($self->ITERATOR_BEGIN(PARAMETER_VALUE), $self->ITERATOR_END(PARAMETER_VALUE));
 549     }
 550 }
 551
 552 %typemap(out) std::pair<NS::ITERATOR_CLASS, NS::ITERATOR_CLASS> {
 553     lua_getglobal(L, "xapian");
 554     lua_pushstring(L, "Iterator");
 555     lua_gettable(L, -2);
 556     lua_remove(L, -2);
 557
 558     if (!lua_isfunction(L, -1)) {
 559         luaL_typerror(L, -1, "function");
 560     }
 561
 562     NS::ITERATOR_CLASS * begin = new NS::ITERATOR_CLASS((const NS::ITERATOR_CLASS &)$1.first);
 563     SWIG_NewPointerObj(L, (void *) begin, $descriptor(NS::ITERATOR_CLASS *), 1);
 564
 565     NS::ITERATOR_CLASS * end = new NS::ITERATOR_CLASS((const NS::ITERATOR_CLASS &)$1.second);
 566     SWIG_NewPointerObj(L, (void *) end, $descriptor(NS::ITERATOR_CLASS *), 1);
 567
 568     if (lua_pcall(L, 2, 1, 0) != 0) {
 569         luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 570     }
 571
 572     SWIG_arg++;
 573 }
 574
 575 %enddef
 576
 577 OUTPUT_ITERATOR_METHODS(Xapian, Query, TermIterator, get_terms_begin, get_terms_end, get_terms, void, )
 578
 579 OUTPUT_ITERATOR_METHODS(Xapian, QueryParser, TermIterator, stoplist_begin, stoplist_end, stoplist, void, )
 580
 581 OUTPUT_ITERATOR_METHODS(Xapian, ESet, ESetIterator, begin, end, terms, void, )
 582
 583 OUTPUT_ITERATOR_METHODS(Xapian, MSet, MSetIterator, begin, end, items, void, )
 584
 585 OUTPUT_ITERATOR_METHODS(Xapian, Document, TermIterator, termlist_begin, termlist_end, termlist, void, )
 586 OUTPUT_ITERATOR_METHODS(Xapian, Document, ValueIterator, values_begin, values_end, values, void, )
 587
 588 OUTPUT_ITERATOR_METHODS(Xapian, Enquire, TermIterator, get_matching_terms_begin, get_matching_terms_end, get_matching_terms, Xapian::docid did, did)
 589 OUTPUT_ITERATOR_METHODS(Xapian, Enquire, TermIterator, get_matching_terms_begin, get_matching_terms_end, get_matching_terms, const MSetIterator &it, it)
 590
 591 OUTPUT_ITERATOR_METHODS(Xapian, ValueCountMatchSpy, TermIterator, values_begin, values_end, values, void, )
 592 OUTPUT_ITERATOR_METHODS(Xapian, ValueCountMatchSpy, TermIterator, top_values_begin, top_values_end, top_values, size_t maxvalues, maxvalues)
 593
 594 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, allterms_begin, allterms_end, allterms, void, )
 595 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, spellings_begin, spellings_end, spellings, void, )
 596 OUTPUT_ITERATOR_METHODS(Xapian, Database, PostingIterator, postlist_begin, postlist_end, postlist, const std::string &tname, tname)
 597 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, termlist_begin, termlist_end, termlist, Xapian::docid did, did)
 598 OUTPUT_ITERATOR_METHODS(Xapian, Database, ValueIterator, valuestream_begin, valuestream_end, valuestream, Xapian::valueno slot, slot)
 599 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, allterms_begin, allterms_end, allterms, const std::string &prefix, prefix)
 600 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, synonyms_begin, synonyms_end, synonyms, const std::string &term, term)
 601 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, synonym_keys_begin, synonym_keys_end, synonym_keys, const std::string &prefix, prefix)
 602 OUTPUT_ITERATOR_METHODS(Xapian, Database, TermIterator, metadata_keys_begin, metadata_keys_end, metadata_keys, const std::string &prefix, prefix)
 603
 604 %extend Xapian::Database {
 605     std::pair<Xapian::PositionIterator , Xapian::PositionIterator> positionlist(Xapian::docid did, const std::string &tname) {
 606         return std::make_pair($self->positionlist_begin(did, tname), $self->positionlist_end(did, tname));
 607     }
 608 }
 609
 610 %typemap(out) std::pair<Xapian::PositionIterator, Xapian::PositionIterator> {
 611     lua_getglobal(L, "xapian");
 612     lua_pushstring(L, "Iterator");
 613     lua_gettable(L, -2);
 614     lua_remove(L, -2);
 615
 616     if (!lua_isfunction(L, -1)) {
 617         luaL_typerror(L, -1, "function");
 618     }
 619
 620     Xapian::PositionIterator * begin = new Xapian::PositionIterator((const Xapian::PositionIterator &)$1.first);
 621     SWIG_NewPointerObj(L, (void *) begin, SWIGTYPE_p_Xapian__PositionIterator, 1);
 622
 623     Xapian::PositionIterator * end = new Xapian::PositionIterator((const Xapian::PositionIterator &)$1.second);
 624     SWIG_NewPointerObj(L, (void *) end, SWIGTYPE_p_Xapian__PositionIterator, 1);
 625
 626     if (lua_pcall(L, 2, 1, 0) != 0) {
 627         luaL_error(L, "error running function: %s", lua_tostring(L, -1));
 628     }
 629
 630     SWIG_arg++;
 631 }