tools/chise.i

   1 // chise.i
   2 //
   3 // Copyright (C) 2005,2006 KAMICHI Koichi.
   4 //
   5 // reference : http://www.swig.org/Doc1.3/Perl5.html
   6 //             sample.c included to libchise
   7
   8 %module chise
   9
  10 %{
  11 #include <concord.h>
  12 #include <chise.h>
  13 %}
  14
  15 %include concord.h
  16 %include chise.h
  17
  18 %inline %{
  19
  20 #include <concord.h>
  21 #include <chise.h>
  22
  23 unsigned char *get_uchar(char *argv){
  24   return (unsigned char *)argv;
  25 }
  26
  27 char *get_char(unsigned char *argv){
  28   return (char *)argv;
  29 }
  30
  31 unsigned char *feature;
  32 int feature_size = 102400;
  33 unsigned char *buffer;
  34 int buffer_size = 1024;
  35
  36 void clear_buffer(){
  37   int i;
  38   for(i = 0; i < buffer_size; i++){
  39     buffer[i] = 0;
  40   }
  41 }
  42
  43 void allocate_buffer(){
  44   feature = (unsigned char *)malloc(feature_size * sizeof(unsigned char));
  45   buffer = (unsigned char *)malloc(buffer_size * sizeof(unsigned char));
  46 }
  47 void free_buffer(){
  48   free(feature);
  49   free(buffer);
  50 }
  51
  52 static int
  53 name_map_func (CHISE_DS *ds, unsigned char *name)
  54 {
  55   strcat((char *)feature, (char *)name);
  56   strcat((char *)feature, (char *)"\n");
  57   return 0;
  58 }
  59 void listup_feature(CHISE_DS *ds){
  60   int i;
  61   for(i = 0; i < feature_size; i++){
  62     feature[i] = 0;
  63   }
  64   chise_ds_foreach_char_feature_name (ds, &name_map_func);
  65 }
  66
  67 %}
  68
  69 %perlcode %{
  70 sub new{
  71   my $class = shift;
  72   chise::allocate_buffer();
  73   my $chise_ds = chise::CHISE_DS_open($chise::CHISE_DS_Berkeley_DB,
  74                                       $chise::chise_system_db_dir,
  75                                       0,
  76                                       0755);
  77   chise::listup_feature($chise_ds);
  78   my @chise_feature = split(/\n/, chise::get_char($chise::feature));
  79   my $chise_newid = -1;
  80   return bless {
  81     chise_ds => $chise_ds,
  82     chise_feature => \@chise_feature,
  83     chise_newid => $chise_newid}, $class;
  84 }
  85 sub DESTROY{
  86   my $self = shift;
  87   chise::free_buffer();
  88   if(define($self->{chise_ds})){ # Strange to say, chise_ds has already unavailable
  89     chise::CHISE_DS_close($self->{chise_ds});
  90   }
  91 }
  92 sub get_feature_list{ # original
  93   my $self = shift;
  94   my $hash = $self->{chise_feature};
  95   return @$hash;
  96 }
  97 sub ds_get_ccs{
  98   my $self = shift;
  99   return chise::chise_ds_get_ccs($self->{chise_ds},
 100                                  chise::get_uchar($_[0]));
 101 }
 102 sub ds_get_feature{
 103   my $self = shift;
 104   return chise::chise_ds_get_feature($self->{chise_ds},
 105                                      chise::get_uchar($_[0]));
 106 }
 107 sub ds_get_property{
 108   my $self = shift;
 109   return chise::chise_ds_get_property($self->{chise_ds},
 110                                       chise::get_uchar($_[0]));
 111 }
 112 sub ds_decode_char{
 113   my $self = shift;
 114   return chise::chise_ds_decode_char($self->{chise_ds},
 115                                      chise::get_uchar($_[0]),
 116                                      $_[1]);
 117 }
 118 sub ccs_decode{
 119   my $self = shift;
 120   return chise::chise_ccs_decode($_[0],
 121                                  $_[1]);
 122 }
 123 sub feature_gets_property_value{ # use feature/property strings directly
 124   my $self = shift;
 125   chise::clear_buffer();
 126   chise::chise_feature_gets_property_value($self->ds_get_feature($_[0]),
 127                                            $self->ds_get_property($_[1]),
 128                                            $chise::buffer,
 129                                            $chise::buffer_size);
 130   return chise::get_char($chise::buffer);
 131 }
 132 sub feature_gets_property_value_by_handle{
 133   my $self = shift;
 134   chise::clear_buffer();
 135   chise::chise_feature_gets_property_value($_[0],
 136                                            $_[1],
 137                                            $chise::buffer,
 138                                            $chise::buffer_size);
 139   return chise::get_char($chise::buffer);
 140 }
 141 sub char_gets_feature_value{ # use feature string directly
 142   my $self = shift;
 143   chise::clear_buffer();
 144   chise::chise_char_gets_feature_value($_[0],
 145                                        $self->ds_get_feature($_[1]),
 146                                        $chise::buffer,
 147                                        $chise::buffer_size);
 148   return chise::get_char($chise::buffer);
 149 }
 150 sub char_gets_feature_value_by_handle{
 151   my $self = shift;
 152   chise::clear_buffer();
 153   chise::chise_char_gets_feature_value($_[0],
 154                                        $_[1],
 155                                        $chise::buffer,
 156                                        $chise::buffer_size);
 157   return chise::get_char($chise::buffer);
 158 }
 159 sub system_db_dir{
 160   my $self = shift;
 161   return chise::get_char($chise::chise_system_db_dir);
 162 }
 163 sub db_dir{
 164   my $self = shift;
 165   return chise::get_char($chise::chise_db_dir);
 166 }
 167 sub db_format_version{
 168   my $self = shift;
 169   return chise::get_char($chise::chise_db_format_version);
 170 }
 171 sub ds_location{
 172   my $self = shift;
 173   return chise::get_char(chise::chise_ds_location($self->{chise_ds}));
 174 }
 175 sub get_newid{ # original : search new char_id and update $chise_newid
 176   my $self = shift;
 177   if($self->{chise_newid} < 0){
 178     $self->{chise_newid} = 0x0F0000;
 179     my @feature = $self->get_feature_list();
 180     while(1){
 181       my $found = 0;
 182       foreach(@feature){
 183         if($self->char_gets_feature_value($self->{chise_newid}, $_) ne ""){
 184           $found = 1;
 185           last;
 186         }
 187       }
 188       if($found == 0){
 189         last;
 190       }
 191       $self->{chise_newid}++;
 192     }
 193   }
 194   return $self->{chise_newid};
 195 }
 196
 197 %}