Changeset 2019

Show
Ignore:
Timestamp:
02/18/08 23:34:02 (3 months ago)
Author:
karpet
Message:

split XS out into separate files; move more from XS to C; TODO figure out saner refcnt solution

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • libswish3/trunk/bindings/perl/3.xs

    r2018 r2019  
    1616PROTOTYPES: enable 
    1717 
     18# TODO more from libswish3.h                
     19# constants            
     20BOOT: 
     21        { 
     22        HV *stash; 
     23   
     24        stash = gv_stashpv("SWISH::3",       TRUE); 
     25        newCONSTSUB(stash, "SWISH_PROP",           newSVpv(SWISH_PROP, 0)); 
     26        newCONSTSUB(stash, "SWISH_PROP_MAX",       newSVpv(SWISH_PROP_MAX, 0)); 
     27        newCONSTSUB(stash, "SWISH_PROP_SORT",      newSVpv(SWISH_PROP_SORT, 0)); 
     28        newCONSTSUB(stash, "SWISH_META",           newSVpv(SWISH_META, 0)); 
     29        newCONSTSUB(stash, "SWISH_MIME",           newSVpv(SWISH_MIME, 0)); 
     30        newCONSTSUB(stash, "SWISH_PARSERS",        newSVpv(SWISH_PARSERS, 0)); 
     31        newCONSTSUB(stash, "SWISH_INDEX",          newSVpv(SWISH_INDEX, 0)); 
     32        newCONSTSUB(stash, "SWISH_ALIAS",          newSVpv(SWISH_ALIAS, 0)); 
     33        newCONSTSUB(stash, "SWISH_WORDS",          newSVpv(SWISH_WORDS, 0)); 
     34        newCONSTSUB(stash, "SWISH_PROP_RECCNT",    newSVpv(SWISH_PROP_RECCNT, 0)); 
     35        newCONSTSUB(stash, "SWISH_PROP_RANK",      newSVpv(SWISH_PROP_RANK, 0)); 
     36        newCONSTSUB(stash, "SWISH_PROP_DOCID",     newSVpv(SWISH_PROP_DOCID, 0)); 
     37        newCONSTSUB(stash, "SWISH_PROP_DOCPATH",   newSVpv(SWISH_PROP_DOCPATH, 0)); 
     38        newCONSTSUB(stash, "SWISH_PROP_DBFILE",    newSVpv(SWISH_PROP_DBFILE, 0)); 
     39        newCONSTSUB(stash, "SWISH_PROP_TITLE",     newSVpv(SWISH_PROP_TITLE, 0)); 
     40        newCONSTSUB(stash, "SWISH_PROP_SIZE",      newSVpv(SWISH_PROP_SIZE, 0)); 
     41        newCONSTSUB(stash, "SWISH_PROP_MTIME",     newSVpv(SWISH_PROP_MTIME, 0)); 
     42        newCONSTSUB(stash, "SWISH_PROP_DESCRIPTION",newSVpv(SWISH_PROP_DESCRIPTION, 0)); 
     43        newCONSTSUB(stash, "SWISH_PROP_CONNECTOR", newSVpv(SWISH_PROP_CONNECTOR, 0)); 
     44        newCONSTSUB(stash, "SWISH_PROP_STRING",    newSViv(SWISH_PROP_STRING)); 
     45        newCONSTSUB(stash, "SWISH_PROP_DATE",      newSViv(SWISH_PROP_DATE)); 
     46        newCONSTSUB(stash, "SWISH_PROP_INT",       newSViv(SWISH_PROP_INT)); 
     47        } 
     48 
     49 
    1850swish_3* 
    1951init(CLASS) 
    …… 
    2759    CODE: 
    2860        stash   = newHV(); 
    29         s3  = swish_init_swish3( &sp_handler, newRV_inc((SV*)stash) ); 
     61        s3      = swish_init_swish3( &sp_handler, newRV_inc((SV*)stash) ); 
    3062        s3->ref_cnt = 1; 
    3163         
    …… 
    83115     
    84116    CODE: 
    85         RETVAL = newSVpv( (const char*)swish_slurp_file((xmlChar*)filename), 0 ); 
     117        buf     = swish_slurp_file((xmlChar*)filename); 
     118        RETVAL  = newSVpv( (const char*)buf, 0 ); 
     119        swish_xfree(buf); 
    86120         
    87121    OUTPUT: 
    …… 
    168202 
    169203    // set_config 
    170     case 1:  self->config = (swish_Config*)sp_ptr_from_object(ST(1)); 
     204    case 1:  swish_free_config(self->config); 
     205             self->config = (swish_Config*)sp_ptr_from_object(ST(1)); 
    171206             break; 
    172207              
    173208    // get_config    
    174     case 2:  RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, CONFIG_CLASS_KEY), (IV)self->config); 
     209    case 2:  self->config->ref_cnt++; 
     210             RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, CONFIG_CLASS_KEY), (IV)self->config); 
    175211             break; 
    176212 
    177213    // set_analyzer 
    178     case 3:  self->analyzer = (swish_Analyzer*)sp_ptr_from_object(ST(1)); 
     214    case 3:  swish_free_analyzer(self->analyzer); 
     215             self->analyzer = (swish_Analyzer*)sp_ptr_from_object(ST(1)); 
    179216             break; 
    180217 
    181218    // get_analyzer 
    182     case 4:  RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, ANALYZER_CLASS_KEY), (IV)self->analyzer); 
     219    case 4:  self->analyzer->ref_cnt++; 
     220             RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, ANALYZER_CLASS_KEY), (IV)self->analyzer); 
    183221             break; 
    184222 
    185223    // set_parser 
    186     case 5:  self->parser = (swish_Parser*)sp_ptr_from_object(ST(1)); 
     224    case 5:  swish_free_parser(self->parser); 
     225             self->parser = (swish_Parser*)sp_ptr_from_object(ST(1)); 
    187226             break; 
    188227            
    189228    // get_parser   
    190     case 6:  RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, PARSER_CLASS_KEY), (IV)self->parser); 
     229    case 6:  self->parser->ref_cnt++; 
     230             RETVAL = sp_ptr_to_object(sp_hvref_fetch_as_char(stash, PARSER_CLASS_KEY), (IV)self->parser); 
    191231             break; 
    192232 
    …… 
    280320    OUTPUT: 
    281321        RETVAL 
    282          
    283  
    284 ########################################################################################## 
    285  
    286 MODULE = SWISH::3       PACKAGE = SWISH::3::Constants 
    287  
    288 PROTOTYPES: enable 
    289  
    290 # TODO more from libswish3.h                
    291 # constants            
    292 BOOT: 
    293         { 
    294         HV *stash; 
    295    
    296         stash = gv_stashpv("SWISH::3::Constants",       TRUE); 
    297         newCONSTSUB(stash, "SWISH_PROP",           newSVpv(SWISH_PROP, 0)); 
    298         newCONSTSUB(stash, "SWISH_PROP_MAX",       newSVpv(SWISH_PROP_MAX, 0)); 
    299         newCONSTSUB(stash, "SWISH_PROP_SORT",      newSVpv(SWISH_PROP_SORT, 0)); 
    300         newCONSTSUB(stash, "SWISH_META",           newSVpv(SWISH_META, 0)); 
    301         newCONSTSUB(stash, "SWISH_MIME",           newSVpv(SWISH_MIME, 0)); 
    302         newCONSTSUB(stash, "SWISH_PARSERS",        newSVpv(SWISH_PARSERS, 0)); 
    303         newCONSTSUB(stash, "SWISH_INDEX",          newSVpv(SWISH_INDEX, 0)); 
    304         newCONSTSUB(stash, "SWISH_ALIAS",          newSVpv(SWISH_ALIAS, 0)); 
    305         newCONSTSUB(stash, "SWISH_WORDS",          newSVpv(SWISH_WORDS, 0)); 
    306         newCONSTSUB(stash, "SWISH_PROP_RECCNT",    newSVpv(SWISH_PROP_RECCNT, 0)); 
    307         newCONSTSUB(stash, "SWISH_PROP_RANK",      newSVpv(SWISH_PROP_RANK, 0)); 
    308         newCONSTSUB(stash, "SWISH_PROP_DOCID",     newSVpv(SWISH_PROP_DOCID, 0)); 
    309         newCONSTSUB(stash, "SWISH_PROP_DOCPATH",   newSVpv(SWISH_PROP_DOCPATH, 0)); 
    310         newCONSTSUB(stash, "SWISH_PROP_DBFILE",    newSVpv(SWISH_PROP_DBFILE, 0)); 
    311         newCONSTSUB(stash, "SWISH_PROP_TITLE",     newSVpv(SWISH_PROP_TITLE, 0)); 
    312         newCONSTSUB(stash, "SWISH_PROP_SIZE",      newSVpv(SWISH_PROP_SIZE, 0)); 
    313         newCONSTSUB(stash, "SWISH_PROP_MTIME",     newSVpv(SWISH_PROP_MTIME, 0)); 
    314         newCONSTSUB(stash, "SWISH_PROP_DESCRIPTION",newSVpv(SWISH_PROP_DESCRIPTION, 0)); 
    315         newCONSTSUB(stash, "SWISH_PROP_CONNECTOR", newSVpv(SWISH_PROP_CONNECTOR, 0)); 
    316         newCONSTSUB(stash, "SWISH_PROP_STRING",    newSViv(SWISH_PROP_STRING)); 
    317         newCONSTSUB(stash, "SWISH_PROP_DATE",      newSViv(SWISH_PROP_DATE)); 
    318         newCONSTSUB(stash, "SWISH_PROP_INT",       newSViv(SWISH_PROP_INT)); 
    319         } 
    320  
    321  
    322 # *************************************************************************************/ 
    323  
    324 MODULE = SWISH::3               PACKAGE = SWISH::3::Config       
    325  
    326 PROTOTYPES: enable 
    327  
    328 AV* 
    329 keys(self) 
    330     swish_Config* self 
    331      
    332     CODE: 
    333         RETVAL = sp_get_xml2_hash_keys(self->conf); 
    334      
    335     OUTPUT: 
    336         RETVAL 
    337  
    338  
    339 # translate xml2 hashes into Perl hashes -- NOTE these are effectively read-only hashes 
    340 # you must use add() and delete() to actually write to the active config in memory 
    341 HV* 
    342 subconfig(self,key) 
    343     swish_Config* self 
    344     char* key 
    345      
    346     PREINIT: 
    347         xmlHashTablePtr sc; 
    348          
    349     CODE: 
    350         sc      = swish_subconfig_hash(self, (xmlChar*)key); 
    351         RETVAL  = sp_xml2_hash_to_perl_hash(sc); 
    352  
    353     OUTPUT: 
    354         RETVAL 
    355  
    356   
    357  
    358 int 
    359 debug(self) 
    360     swish_Config* self 
    361      
    362     CODE: 
    363         RETVAL = swish_debug_config(self); 
    364          
    365     OUTPUT: 
    366         RETVAL 
    367  
    368  
    369 swish_Config * 
    370 new(CLASS) 
    371     char* CLASS; 
    372      
    373     PREINIT: 
    374         HV* stash; 
    375  
    376     CODE: 
    377         RETVAL = swish_init_config(); 
    378         RETVAL->ref_cnt++; 
    379         stash = newHV(); 
    380         RETVAL->stash = newRV_inc((SV*)stash); 
    381          
    382     OUTPUT: 
    383         RETVAL 
    384  
    385  
    386  
    387 void 
    388 add(self, conf_file) 
    389     swish_Config* self 
    390         char *  conf_file 
    391      
    392     CODE: 
    393         swish_add_config((xmlChar*)conf_file, self); 
    394        
    395        
    396 void 
    397 delete(self, key) 
    398     swish_Config* self 
    399     char* key 
    400      
    401     CODE: 
    402         warn("delete() not yet implemented\n"); 
    403          
    404 void 
    405 subconfig_delete(self, key, subconf) 
    406     swish_Config* self 
    407     char* key 
    408     xmlHashTablePtr subconf 
    409      
    410     CODE: 
    411         warn("subconfig_delete() not yet implemented\n"); 
    412  
    413 void 
    414 DESTROY(self) 
    415     swish_Config* self 
    416      
    417     CODE: 
    418         if (SWISH_DEBUG) { 
    419             warn("DESTROYing swish_Config object %s  [%d] [ref_cnt = %d]",  
    420                 SvPV(ST(0), PL_na), self, self->ref_cnt); 
    421         } 
    422          
    423 int 
    424 refcount(obj) 
    425     SV* obj; 
    426      
    427     CODE: 
    428         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    429      
    430     OUTPUT: 
    431         RETVAL 
    432          
    433          
    434 # ******************************************************************************* 
    435  
    436 MODULE = SWISH::3       PACKAGE = SWISH::3::Analyzer 
    437  
    438 PROTOTYPES: enable 
    439  
    440  
    441 swish_Analyzer * 
    442 new(CLASS, config) 
    443     char*           CLASS; 
    444     swish_Config*   config; 
    445      
    446     PREINIT: 
    447         HV* stash; 
    448  
    449     CODE: 
    450         //RETVAL = swish_init_analyzer((swish_Config*)sp_ptr_from_object( (SV*)config )); 
    451         RETVAL = swish_init_analyzer(config); 
    452         RETVAL->ref_cnt = 1; 
    453         stash = newHV(); 
    454         RETVAL->stash = newRV_inc((SV*)stash); 
    455          
    456     OUTPUT: 
    457         RETVAL 
    458  
    459  
    460 # accessors/mutators 
    461 void 
    462 _set_or_get(self, ...) 
    463     swish_Analyzer* self; 
    464 ALIAS: 
    465     set_regex           = 1 
    466     get_regex           = 2 
    467     set_token_handler   = 3 
    468     get_token_handler   = 4 
    469 PREINIT: 
    470     SV*             stash; 
    471     SV*             RETVAL; 
    472 PPCODE: 
    473 { 
    474      
    475     //warn("number of items %d for ix %d", items, ix); 
    476      
    477     START_SET_OR_GET_SWITCH 
    478  
    479     // set_regex 
    480     case 1:  self->regex = ST(1); 
    481              break; 
    482               
    483     // TODO test refcnt 
    484     // get_regex 
    485     case 2:  RETVAL  = SvREFCNT_inc( self->regex ); 
    486              break; 
    487               
    488     // TODO set token_handler    
    489          
    490     END_SET_OR_GET_SWITCH 
    491 } 
    492  
    493  
    494 void 
    495 DESTROY(self) 
    496     swish_Analyzer* self 
    497      
    498     CODE: 
    499         if (SWISH_DEBUG) { 
    500             warn("DESTROYing swish_Analyzer object %s  [%d] [ref_cnt = %d]",  
    501                 SvPV(ST(0), PL_na), self, self->ref_cnt); 
    502         } 
    503  
    504  
    505  
    506  
    507 # tokenize() from Perl space uses same C func as tokenizer callback 
    508 swish_WordList * 
    509 tokenize(self, str, ...) 
    510     SV* self; 
    511     SV* str; 
    512      
    513     PREINIT: 
    514         char* CLASS; 
    515         xmlChar* metaname;    
    516         xmlChar* context; 
    517         unsigned int word_pos; 
    518         unsigned int offset; 
    519         xmlChar* buf; 
    520          
    521     CODE: 
    522         CLASS       = WORDLIST_CLASS; 
    523         metaname    = (xmlChar*)SWISH_DEFAULT_METANAME;    
    524         context     = (xmlChar*)SWISH_DEFAULT_METANAME; 
    525         word_pos    = 0; 
    526         offset      = 0; 
    527         buf         = (xmlChar*)SvPV(str, PL_na); 
    528          
    529         // TODO reimplement as hashref arg 
    530                  
    531         if (!SvUTF8(str)) 
    532         { 
    533             if (swish_is_ascii(buf)) 
    534                 SvUTF8_on(str);     /* flags original SV ?? */ 
    535             else 
    536                 croak("%s is not flagged as a UTF-8 string and is not ASCII", buf); 
    537         } 
    538          
    539         if ( items > 2 ) 
    540         { 
    541             word_pos = (int)SvIV(ST(2)); 
    542              
    543             if ( items > 3 ) 
    544                 offset = (int)SvIV(ST(3)); 
    545                  
    546             if ( items > 4 ) 
    547                 metaname = (xmlChar*)SvPV(ST(4), PL_na); 
    548                  
    549             if ( items > 5 ) 
    550                 context = (xmlChar*)SvPV(ST(5), PL_na); 
    551                  
    552             //warn ("word_pos %d  offset %d  metaname %s  context %s\n", word_pos, offset, metaname, context ); 
    553                  
    554         } 
    555                          
    556         RETVAL = sp_tokenize( 
    557                         (swish_Analyzer*)sp_ptr_from_object(self), 
    558                         buf, 
    559                         word_pos, 
    560                         offset, 
    561                         metaname, 
    562                         context 
    563                         ); 
    564          
    565         RETVAL->ref_cnt++; 
    566          
    567         /* TODO do we need to worry about free()ing metaname and context ?? */ 
    568                          
    569     OUTPUT: 
    570         RETVAL 
    571  
    572  
    573  
    574 # tokenize_isw() uses native libswish3 tokenizer 
    575 swish_WordList * 
    576 tokenize_isw(self, str, ...) 
    577     SV* self; 
    578     SV* str; 
    579  
    580     PREINIT: 
    581         char* CLASS; 
    582         xmlChar* metaname = (xmlChar*)SWISH_DEFAULT_METANAME;    
    583         xmlChar* context  = (xmlChar*)SWISH_DEFAULT_METANAME; 
    584         unsigned int word_pos    = 0; 
    585         unsigned int offset      = 0; 
    586         xmlChar* buf = (xmlChar*)SvPV(str, PL_na); 
    587          
    588     CODE: 
    589         CLASS = WORDLIST_CLASS; 
    590          
    591         if (!SvUTF8(str)) 
    592         { 
    593             if (swish_is_ascii(buf)) 
    594                 SvUTF8_on(str);     /* flags original SV ?? */ 
    595             else 
    596                 croak("%s is not flagged as a UTF-8 string and is not ASCII", buf); 
    597         } 
    598          
    599         if ( items > 2 ) 
    600         { 
    601             word_pos = (int)SvIV(ST(2)); 
    602              
    603             if ( items > 3 ) 
    604                 offset = (int)SvIV(ST(3)); 
    605                  
    606             if ( items > 4 ) 
    607                 metaname = (xmlChar*)SvPV(ST(4), PL_na); 
    608                  
    609             if ( items > 5 ) 
    610                 context = (xmlChar*)SvPV(ST(5), PL_na); 
    611                  
    612         } 
    613                  
    614         swish_init_words(); /* in case it wasn't initialized elsewhere... */ 
    615         RETVAL = swish_tokenize( 
    616                         (swish_Analyzer*)sp_ptr_from_object(self), 
    617                         buf, 
    618                         word_pos, 
    619                         offset, 
    620                         metaname, 
    621                         context 
    622                         ); 
    623          
    624         RETVAL->ref_cnt++; 
    625          
    626         /* TODO do we need to worry about free()ing metaname and context ?? */ 
    627                          
    628     OUTPUT: 
    629         RETVAL 
    630  
    631 int 
    632 refcount(obj) 
    633     SV* obj; 
    634      
    635     CODE: 
    636         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    637      
    638     OUTPUT: 
    639         RETVAL 
    640          
    641          
    642 # ******************************************************************************* 
    643      
    644 MODULE = SWISH::3               PACKAGE = SWISH::3::WordList 
    645  
    646 PROTOTYPES: enable 
    647          
    648 swish_Word * 
    649 next(self) 
    650     swish_WordList* self 
    651      
    652     PREINIT: 
    653         char* CLASS; 
    654      
    655     CODE: 
    656         CLASS = WORD_CLASS; 
    657          
    658         if (self->current == NULL) { 
    659             self->current = self->head; 
    660         } 
    661         else { 
    662             self->current = self->current->next; 
    663         } 
    664         RETVAL = self->current; 
    665          
    666     OUTPUT: 
    667         RETVAL 
    668  
    669  
    670 SV* 
    671 nwords(self) 
    672     swish_WordList* self; 
    673      
    674     CODE: 
    675         RETVAL = newSViv( self->nwords ); 
    676          
    677     OUTPUT: 
    678         RETVAL 
    679      
    680      
    681 void 
    682 debug(self) 
    683     swish_WordList* self; 
    684      
    685     CODE: 
    686         swish_debug_wordlist( self ); 
    687          
    688  
    689  
    690 void 
    691 DESTROY(self) 
    692     swish_WordList* self 
    693      
    694     CODE: 
    695         self->ref_cnt--; 
    696         if (self->ref_cnt < 1) { 
    697             swish_free_wordlist(self); 
    698         } 
    699          
    700 int 
    701 refcount(obj) 
    702     SV* obj; 
    703      
    704     CODE: 
    705         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    706      
    707     OUTPUT: 
    708         RETVAL 
    709          
    710  
    711 # ******************************************************************************* 
    712      
    713 MODULE = SWISH::3               PACKAGE = SWISH::3::Word 
    714  
    715 PROTOTYPES: enable 
    716  
    717 SV* 
    718 word (self) 
    719         swish_Word *    self;    
    720     CODE: 
    721         RETVAL = newSVpvn( (char*)self->word, strlen((char*)self->word) ); 
    722          
    723     OUTPUT: 
    724         RETVAL 
    725          
    726  
    727 SV* 
    728 metaname (self) 
    729         swish_Word *    self; 
    730     CODE: 
    731         RETVAL = newSVpvn( (char*)self->metaname, strlen((char*)self->metaname) ); 
    732          
    733     OUTPUT: 
    734         RETVAL 
    735          
    736 SV* 
    737 context (self) 
    738         swish_Word *    self; 
    739     CODE: 
    740         RETVAL = newSVpvn( (char*)self->context, strlen((char*)self->context) ); 
    741          
    742     OUTPUT: 
    743         RETVAL 
    744          
    745  
    746 SV* 
    747 position (self) 
    748         swish_Word *    self; 
    749     CODE: 
    750         RETVAL = newSViv( self->position ); 
    751          
    752     OUTPUT: 
    753         RETVAL 
    754  
    755 SV* 
    756 start_offset(self) 
    757         swish_Word *    self; 
    758     CODE: 
    759         RETVAL = newSViv( self->start_offset ); 
    760          
    761     OUTPUT: 
    762         RETVAL 
    763  
    764 SV* 
    765 end_offset(self) 
    766         swish_Word *    self; 
    767     CODE: 
    768         RETVAL = newSViv( self->end_offset ); 
    769          
    770     OUTPUT: 
    771         RETVAL 
    772  
    773  
    774 int 
    775 refcount(obj) 
    776     SV* obj; 
    777      
    778     CODE: 
    779         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    780      
    781     OUTPUT: 
    782         RETVAL 
    783          
    784  
    785 # ******************************************************************************* 
    786      
    787 MODULE = SWISH::3               PACKAGE = SWISH::3::Doc 
    788  
    789 PROTOTYPES: enable 
    790  
    791 SV* 
    792 mtime(self) 
    793     swish_DocInfo* self; 
    794      
    795     CODE: 
    796         RETVAL = newSViv( self->mtime ); 
    797          
    798     OUTPUT: 
    799         RETVAL 
    800          
    801 SV* 
    802 size(self) 
    803     swish_DocInfo* self; 
    804      
    805     CODE: 
    806         RETVAL = newSViv( self->size ); 
    807          
    808     OUTPUT: 
    809         RETVAL 
    810          
    811 SV* 
    812 nwords(self) 
    813     swish_DocInfo* self; 
    814      
    815     CODE: 
    816         RETVAL = newSViv( self->nwords ); 
    817          
    818     OUTPUT: 
    819         RETVAL 
    820  
    821  
    822 SV* 
    823 encoding(self) 
    824         swish_DocInfo * self; 
    825     CODE: 
    826         RETVAL = newSVpvn( (char*)self->encoding, strlen((char*)self->encoding) ); 
    827          
    828     OUTPUT: 
    829         RETVAL 
    830  
    831 SV* 
    832 uri(self) 
    833         swish_DocInfo * self; 
    834     CODE: 
    835         RETVAL = newSVpvn( (char*)self->uri, strlen((char*)self->uri) ); 
    836          
    837     OUTPUT: 
    838         RETVAL 
    839  
    840 SV* 
    841 ext(self) 
    842         swish_DocInfo * self; 
    843     CODE: 
    844         RETVAL = newSVpvn( (char*)self->ext, strlen((char*)self->ext) ); 
    845          
    846     OUTPUT: 
    847         RETVAL 
    848          
    849 SV* 
    850 mime(self) 
    851         swish_DocInfo * self; 
    852     CODE: 
    853         RETVAL = newSVpvn( (char*)self->mime, strlen((char*)self->mime) ); 
    854          
    855     OUTPUT: 
    856         RETVAL 
    857          
    858  
    859 SV* 
    860 parser(self) 
    861         swish_DocInfo * self; 
    862     CODE: 
    863         RETVAL = newSVpvn( (char*)self->parser, strlen((char*)self->parser) ); 
    864          
    865     OUTPUT: 
    866         RETVAL 
    867  
    868 int 
    869 refcount(obj) 
    870     SV* obj; 
    871      
    872     CODE: 
    873         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    874      
    875     OUTPUT: 
    876         RETVAL 
    877          
    878  
    879 # ******************************************************************************* 
    880      
    881 MODULE = SWISH::3               PACKAGE = SWISH::3::Data 
    882  
    883 PROTOTYPES: enable 
    884  
    885  
    886 swish_3* 
    887 s3(self) 
    888     swish_ParseData* self 
    889      
    890     PREINIT: 
    891         char* CLASS; 
    892  
    893     CODE: 
    894         CLASS  = sp_get_objects_class((SV*)self->s3); 
    895         RETVAL = self->s3; 
    896          
    897     OUTPUT: 
    898         RETVAL 
    899          
    900     CLEANUP: 
    901         SvREFCNT_inc(RETVAL); 
    902  
    903  
    904 swish_Config* 
    905 config(self) 
    906     swish_ParseData* self 
    907      
    908         PREINIT: 
    909         char* CLASS; 
    910  
    911     CODE: 
    912         CLASS  = sp_hvref_fetch_as_char(self->s3->stash, CONFIG_CLASS_KEY); 
    913         RETVAL = self->s3->config; 
    914         RETVAL->ref_cnt++; 
    915          
    916     OUTPUT: 
    917         RETVAL 
    918          
    919          
    920 SV* 
    921 property(self, p) 
    922     swish_ParseData* self; 
    923     xmlChar* p; 
    924      
    925         PREINIT: 
    926         xmlBufferPtr buf; 
    927          
    928     CODE: 
    929         buf = xmlHashLookup(self->properties->hash, p); 
    930         RETVAL = newSVpvn((char*)xmlBufferContent(buf), xmlBufferLength(buf)); 
    931          
    932     OUTPUT: 
    933         RETVAL 
    934          
    935 HV* 
    936 properties(self) 
    937     swish_ParseData* self 
    938      
    939     CODE: 
    940         RETVAL = sp_nb_to_hash( self->properties ); 
    941          
    942     OUTPUT: 
    943         RETVAL 
    944          
    945  
    946 HV* 
    947 metanames(self) 
    948     swish_ParseData* self 
    949      
    950     CODE: 
    951         RETVAL = sp_nb_to_hash( self->metanames ); 
    952          
    953     OUTPUT: 
    954         RETVAL 
    955         
    956  
    957  
    958 swish_DocInfo * 
    959 doc(self) 
    960     swish_ParseData* self 
    961      
    962     PREINIT: 
    963         char* CLASS; 
    964          
    965     CODE: 
    966         CLASS = "SWISH::3::Doc"; 
    967         RETVAL = self->docinfo; 
    968          
    969     OUTPUT: 
    970         RETVAL 
    971  
    972  
    973 swish_WordList * 
    974 wordlist(self) 
    975     swish_ParseData* self 
    976      
    977     PREINIT: 
    978         char* CLASS; 
    979          
    980     CODE: 
    981         CLASS = WORDLIST_CLASS; 
    982          
    983 # MUST increment refcnt 2x so that SWISH::3::Parser::WordList::DESTROY 
    984 # does not free it. 
    985         self->wordlist->ref_cnt += 2; 
    986         RETVAL = self->wordlist; 
    987          
    988     OUTPUT: 
    989         RETVAL 
    990          
    991      
    992 # must decrement refcount for stashed SWISH::3::Parser object 
    993 # since we increment it in parse_buf() and parse_file() 
    994 # TODO: this way of doing it doesn't work. 
    995 # but isn't it a potential mem leak to just _inc in parse_*() without 
    996 # _dec somewhere else? just means that the SWISH::3::Parser object 
    997 # may never get garbage collected. 
    998 #void 
    999 #DESTROY(self) 
    1000 #    swish_ParseData* self; 
    1001 #     
    1002 #    CODE: 
    1003 #        SvREFCNT_dec( self->user_data ); 
    1004          
    1005 int 
    1006 refcount(obj) 
    1007     SV* obj; 
    1008      
    1009     CODE: 
    1010         RETVAL = SvREFCNT((SV*)SvRV(obj)); 
    1011      
    1012     OUTPUT: 
    1013         RETVAL 
    1014          
    1015  
     322 
     323 
     324 
     325# include the other .xs files 
     326INCLUDE: XS/Config.xs 
     327INCLUDE: XS/Analyzer.xs 
     328INCLUDE: XS/WordList.xs 
     329INCLUDE: XS/Word.xs 
     330INCLUDE: XS/Doc.xs 
     331INCLUDE: XS/Data.xs 
     332 

  • libswish3/trunk/bindings/perl/Makefile.PL

    r2014 r2019  
    22 
    33WriteMakefile( 
    4     NAME              => 'SWISH::3', 
    5     VERSION_FROM      => 'lib/SWISH/3.pm', 
    6     PREREQ_PM         => { 
    7                 'Test::More'  => 0, 
    8                 'Devel::Peek' => 0, 
    9                 'Data::Dump'  => 0, 
    10     },  
    11     H                 => [qw( xs_helpers.c xs_boiler.h headers.h macros.h )], 
    12     ($] >= 5.005 ?      
    13       (ABSTRACT_FROM  => 'lib/SWISH/3.pm', 
    14        AUTHOR         => 'Peter Karman <perl@peknet.com>') : ()), 
    15     LIBS              => ['-L/usr/lib -L/usr/local/lib -lswish3 -lxml2'], 
    16     DEFINE            => '', # e.g., '-DHAVE_SOMETHING' 
    17     INC               => '-I/usr/include -I/usr/local/include -I/usr/include/libxml2 -I/usr/local/include/libxml2 -I.', 
    18         # Un-comment this if you add C files to link with later: 
     4    NAME         => 'SWISH::3', 
     5    VERSION_FROM => 'lib/SWISH/3.pm', 
     6    PREREQ_PM    => { 
     7        'Test::More'  => 0, 
     8        'Devel::Peek' => 0, 
     9        'Data::Dump'  => 0, 
     10    }, 
     11    H => [qw( xs_helpers.c xs_boiler.h headers.h macros.h )], 
     12    (   $] >= 5.005 
     13        ? ( ABSTRACT_FROM => 'lib/SWISH/3.pm', 
     14            AUTHOR        => 'Peter Karman <perl@peknet.com>' 
     15            ) 
     16        : () 
     17    ), 
     18    LIBS => ['-L/usr/lib -L/usr/local/lib -lswish3 -lxml2'], 
     19    DEFINE => '',    # e.g., '-DHAVE_SOMETHING' 
     20    INC => 
     21        '-I/usr/include -I/usr/local/include -I/usr/include/libxml2 -I/usr/local/include/libxml2 -I.', 
     22 
     23    # Un-comment this if you add C files to link with later: 
    1924    # OBJECT            => '$(O_FILES)', # link all the C files too 
    2025); 
     26 
     27sub MY::postamble { 
     28    return "\$(XS_FILES): " 
     29        . join( " ", <XS/*.xs> ) 
     30        . "\n\ttouch \$(XS_FILES)"; 
     31} 

  • libswish3/trunk/bindings/perl/lib/SWISH/3.pm

    r2018 r2019  
    1 package SWISH::3; 
    2  
    3 use 5.008_003; 
    41use strict; 
    52use warnings; 
     3use 5.008_003; 
     4 
     5package SWISH::3; 
    66 
    77our $VERSION = '0.01'; 
    88 
    9 #$ENV{SWISH3} = 1; # should be set by libswish3 in swish.c but doesn't seem to. 
     9# set by libswish3 in swish.c but that happens after %ENV has been 
     10# initialized at Perl compile time. 
     11$ENV{SWISH3} = 1; 
    1012 
    1113use Carp; 
    …… 
    1315use Devel::Peek; 
    1416 
    15 use XSLoader; 
     17use base qw( Exporter ); 
     18 
     19use constant SWISH_DOC_FIELDS => 
     20    qw( mtime size encoding mime uri nwords ext parser ); 
     21use constant SWISH_WORD_FIELDS => 
     22    qw( word position metaname context start_offset end_offset ); 
     23 
     24# load the XS at runtime, since we need $VERSION 
     25require XSLoader; 
    1626XSLoader::load( __PACKAGE__, $VERSION ); 
    17 use SWISH::3::Config; 
    18 use SWISH::3::Constants; 
     27 
     28# our symbol table is populated with newCONSTSUB in 3.xs 
     29# directly from libswish3.h, so we just grep the symbol table. 
     30my @constants = ( grep {m/^SWISH_/} keys %SWISH::3:: ); 
     31 
     32our %EXPORT_TAGS = ( 'constants' => [@constants], ); 
     33our @EXPORT_OK = ( @{ $EXPORT_TAGS{'constants'} } ); 
    1934 
    2035# convenience accessors 
    …… 
    8499 
    85100    select(STDERR); 
    86  
    87101    print '~' x 80, "\n"; 
    88102 
    …… 
    93107        my $v    = $data->property($p); 
    94108        my $type = $props->{$p}; 
    95  
    96109        print "    <$p type='$type'>$v</$p>\n"; 
    97110    } 
    98111 
    99112    print "Doc\n"; 
    100     for my $d ( SWISH_DOC_FIELDS() ) { 
     113    for my $d (SWISH_DOC_FIELDS) { 
    101114        printf( "%15s: %s\n", $d, $data->doc->$d ); 
    102115    } 
    …… 
    105118    while ( my $swishword = $data->wordlist->next ) { 
    106119        print '-' x 50, "\n"; 
    107         for my $w ( SWISH_WORD_FIELDS() ) { 
     120        for my $w (SWISH_WORD_FIELDS) { 
    108121            printf( "%15s: %s\n", $w, $swishword->$w ); 
    109122        } 

  • libswish3/trunk/bindings/perl/macros.h

    r2015 r2019  
    1313#define WORDLIST_CLASS      "SWISH::3::WordList" 
    1414#define WORD_CLASS          "SWISH::3::Word" 
     15#define DOC_CLASS           "SWISH::3::Doc" 
    1516#define SELF_KEY            "sp_self" 
    1617#define CONFIG_KEY          "sp_config" 

  • libswish3/trunk/bindings/perl/t/06constants.t

    r2014 r2019  
    11use Test::More tests => 3; 
    22 
    3 use SWISH::3::Constants; 
     3use SWISH::3 qw( :constants ); 
    44 
    55is( SWISH_MIME,                'MIME',          SWISH_MIME ); 

  • libswish3/trunk/bindings/perl/t/08-handler.t

    r2018 r2019  
    33use_ok('SWISH::3'); 
    44 
    5 ok( my $s3 = SWISH::3->new(), "new parser" ); 
     5ok( my $s3 = SWISH::3->new( handler => sub { diag("got data: $_[0]") } ), 
     6    "new parser" ); 
    67ok( $s3->parse("t/test.html"), "parse HTML" ); 
    78ok( $s3->parse("t/test.xml"),  "parse XML" ); 

  • libswish3/trunk/bindings/perl/t/10tokenize.t

    r2018 r2019  
    1 use Test::More tests => 9; 
     1use Test::More tests => 7; 
    22 
    3 use_ok('SWISH::3'); 
    4 use_ok('SWISH::3::Constants'); 
     3use SWISH::3 qw( :constants ); 
    54 
    65ok( my $s3 = SWISH::3->new, "new s3" ); 
    …… 
    3029 
    3130    #diag( '=' x 60 ); 
    32     for my $w ( SWISH_WORD_FIELDS() ) { 
     31    for my $w (SWISH_WORD_FIELDS) { 
    3332 
    3433        #diag( sprintf( "%15s: %s\n", $w, $swishword->$w ) ); 

  • libswish3/trunk/bindings/perl/t/11get_set_parser.t

    r2014 r2019  
    2424); 
    2525ok( my $conf2 = $s3->get_config, "get conf2" ); 
     26diag("config = $config"); 
     27diag("conf1 = $conf1"); 
     28diag("conf2 = $conf2"); 
    2629 
    2730ok( my $ana1 = $s3->get_analyzer, "get initial analyzer" ); 

  • libswish3/trunk/bindings/perl/t/20metanames.t

    r2014 r2019  
    11use Test::More tests => 22; 
     2use Data::Dump qw( dump ); 
    23 
    34use_ok('SWISH::3'); 
    …… 
    2627    my $data = shift; 
    2728 
    28     #    diag(dump($data->metanames)); 
     29    #diag(dump($data->metanames)); 
     30 
    2931    #$data->wordlist->debug; 
    3032 
     33 
    3134} 

  • libswish3/trunk/bindings/perl/xs_helpers.c

    r2018 r2019  
    3838static void     sp_SV_is_qr( SV *qr ); 
    3939static void     sp_debug_token( swish_Token *token ); 
     40static HV*      sp_get_config_subconfig( swish_Config* config, const char* key ); 
     41static swish_Config*    sp_new_config(); 
     42static swish_Analyzer*  sp_new_analyzer(); 
    4043 
    4144static void 
    …… 
    627630    warn("end       = %d\n", token->end); 
    628631} 
     632 
     633static HV* 
     634sp_get_config_subconfig( swish_Config* config, const char* key ) 
     635{    
     636    return sp_xml2_hash_to_perl_hash( swish_subconfig_hash( config, (xmlChar*)key ) ); 
     637} 
     638 
     639static swish_Config* 
     640sp_new_config() 
     641{ 
     642    HV* stash; 
     643    swish_Config* config; 
     644     
     645    stash  = newHV(); 
     646    config = swish_init_config(); 
     647    config->ref_cnt++; 
     648    config->stash = newRV_inc((SV*)stash); 
     649    sp_hvref_store( config->stash, SELF_KEY, sp_ptr_to_object(CONFIG_CLASS, (IV)config) ); 
     650     
     651    return config; 
     652}