kpengine/kpengine.c

   1 /* Modified by Paul Goins:
   2  * This file contains modifications so it will compile without GTK
   3  * dependencies and to make it better work with wxKanjipad.
   4  */
   5 /* KanjiPad - Japanese handwriting recognition front end
   6  * Copyright (C) 1997 Owen Taylor
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include "jstroke.h"
  24 #include <ctype.h>
  25
  26 #define MAX_STROKES 32
  27 #define BUFLEN 1024
  28 #ifndef PATH_MAX //FIXME: this is not found if debug mode is used (-pedantic ?)
  29 # define PATH_MAX BUFLEN
  30 #endif
  31
  32 static StrokeDic stroke_dicts[MAX_STROKES];
  33 static char *progname;
  34 static char *data_dir;
  35
  36 void
  37 load_database()
  38 {
  39         char buf[PATH_MAX];
  40         char fname[PATH_MAX];
  41         int at_db;
  42         FILE *fd;
  43         char *dir=0;
  44
  45         if(data_dir)
  46         {
  47                 int len = strlen(data_dir)+1;
  48                 dir = malloc(sizeof(char)*(len));
  49                 strncpy(dir, data_dir, len);
  50         }
  51         else
  52         {
  53                 /* Default to current directory if no data dir is specified. */
  54                 dir = malloc(sizeof(char)*9);
  55                 strcpy(dir, "kanjipad");
  56                 dir[8]=0;
  57         }
  58
  59         for(at_db=0;at_db<MAX_STROKES;++at_db)
  60                 stroke_dicts[at_db]=0;
  61
  62         for(at_db=0;at_db<MAX_STROKES;++at_db)
  63         {
  64                 int len = strlen(dir) + 12; /* dir len + ##.unistrok (11 chars)
  65                                                                            + sep char = dir len + 12 */
  66                 if(len<1 || len>=PATH_MAX)
  67                 {
  68                         fprintf(stderr,"Failed to format path\n");
  69                         if(dir) free(dir);
  70                         exit(-5);
  71                 }
  72
  73 #ifdef __MSWINDOWS__
  74                 char separator = '\\';
  75 #else
  76                 char separator = '/';
  77 #endif
  78                 sprintf(fname,"%s%c%02d.unistrok",dir,separator,at_db);
  79
  80                 fd = fopen(fname,"r");
  81                 if(fd)
  82                 {
  83                         StrokeDicEntryList **ppnext=&stroke_dicts[at_db];
  84
  85                         while( fgets(buf,PATH_MAX,fd) )
  86                         {
  87                                 unsigned long unicode_point;
  88                                 char *begin;
  89                                 char *next_pchr;
  90                                 char *pchr = buf;
  91                                 StrokeDicEntryList *plist=0;
  92
  93                                 if( pchr[0]=='#')
  94                                         continue;
  95
  96                                 unicode_point = strtol(pchr,&next_pchr,16);
  97
  98                                 if(pchr==next_pchr)
  99                                 {
 100                                         fprintf(stderr,"Failed to parse line:\n\"%s\"\n",pchr);
 101                                         continue;
 102                                 }
 103                                 pchr=next_pchr;
 104
 105                                 if(unicode_point<0x3300 ||
 106                                         unicode_point>0x2FA1F)
 107                                 {
 108                                         fprintf(stderr,"Unicode out of range for Kanji: 0x%08lX\n"
 109                                                         "file \"%s\"\n\"%s\" ",
 110                                                         unicode_point,
 111                                                         fname,
 112                                                         buf
 113                                                         );
 114                                         continue;
 115                                 }
 116
 117                                 plist = malloc(sizeof(StrokeDicEntryList));
 118
 119                                 if(!plist)
 120                                 {
 121                                         mem_err:
 122                                         fprintf(stderr,"out of memory\n");
 123                                         if(dir) free(dir);
 124                                         exit(-1);
 125                                 }
 126
 127                                 plist->m_next=0;
 128                                 plist->m_entry.m_character=malloc(20);
 129                                 if(!plist->m_entry.m_character)
 130                                         goto mem_err;
 131                                 //plist->m_entry.m_character[ucs4toutf8(unicode_point,plist->m_entry.m_character)]=0;
 132                                 sprintf(plist->m_entry.m_character,"%lu",unicode_point);
 133
 134                                 //Strokes
 135                                 while(*pchr!='|')
 136                                 {
 137                                         if( !*pchr || *pchr=='\n')
 138                                         {
 139                                                 fail_no_strokes:
 140                                                 fprintf(stderr,"Failed to parse line: No Strokes\n\"%s\"\n",buf);
 141                                                 free(plist->m_entry.m_character);
 142                                                 free(plist);
 143                                                 continue;
 144                                         }
 145                                         ++pchr;
 146                                 }
 147                                 ++pchr;
 148
 149                                 while(*pchr==' '||*pchr=='\t')
 150                                         ++pchr;
 151                                 begin=pchr;
 152                                 while(*pchr && *pchr!='#' && *pchr!='|' && *pchr!='\n')
 153                                         ++pchr;
 154                                 if(pchr==begin)
 155                                         goto fail_no_strokes;
 156                                 plist->m_entry.m_strokes=malloc(pchr-begin+1);
 157                                 if(!plist->m_entry.m_strokes)
 158                                         goto mem_err;
 159                                 strncpy(plist->m_entry.m_strokes,begin,pchr-begin);
 160                                 plist->m_entry.m_strokes[pchr-begin]=0;
 161
 162                                 //Filter
 163                                 plist->m_entry.m_filters=0;
 164                                 while(*pchr!='|')
 165                                 {
 166                                         if( !*pchr || *pchr=='\n')
 167                                                 break;
 168                                         ++pchr;
 169                                 }
 170                                 if(*pchr=='|')
 171                                 {
 172                                         ++pchr;
 173                                         //Possible Filter
 174                                         while(*pchr==' '||*pchr=='\t')
 175                                                 ++pchr;
 176                                         begin=pchr;
 177                                         while(*pchr && *pchr!='#' && *pchr!='\n')
 178                                                 ++pchr;
 179                                         if(pchr!=begin)
 180                                         {
 181                                                 plist->m_entry.m_filters=malloc(pchr-begin+1);
 182                                                 if(!plist->m_entry.m_filters)
 183                                                         goto mem_err;
 184                                                 strncpy(plist->m_entry.m_filters, begin,pchr-begin);
 185                                                 plist->m_entry.m_filters[pchr-begin]=0;
 186                                         }
 187                                 }
 188
 189                                 //line accepted
 190                                 *ppnext=plist;
 191                                 ppnext=&plist->m_next;
 192 /*
 193 fprintf(stderr,"Loaded %s\n",plist->m_entry.m_character);
 194 fprintf(stderr,"Strokes:--%s--\n",plist->m_entry.m_strokes);
 195 if(plist->m_entry.m_filters)
 196 {
 197         fprintf(stderr,"Filters:--%s--\n",plist->m_entry.m_filters);
 198         break;
 199 }
 200 */
 201                         }
 202
 203                         fclose(fd);
 204                 }
 205
 206         }
 207         free(dir);
 208 }
 209
 210 int
 211 process_strokes (FILE *file)
 212 {
 213     RawStroke strokes[MAX_STROKES];
 214     char *buffer = malloc(BUFLEN);
 215     int buflen = BUFLEN;
 216     int nstrokes = 0;
 217
 218     /* Read in strokes from standard in, all points for each stroke
 219      *  strung together on one line, until we get a blank line
 220      */
 221
 222     while (1)
 223     {
 224         char *p,*q;
 225         int len;
 226
 227         if (!fgets(buffer, buflen, file))
 228             return 0;
 229
 230                 len=strlen(buffer);
 231         while( (buffer[len-1] != '\n') )
 232         {
 233 //fprintf(stderr,"READ PARTIAL (%d so far)\n",buflen-1);
 234 //fflush(stderr);
 235                         if(buflen < 2*len)
 236                         {
 237                 buflen += BUFLEN;
 238                     buffer = realloc(buffer, buflen);
 239                         }
 240             if (!fgets(buffer+len, buflen-len, file))
 241                 return 0;
 242                         len=strlen(buffer);
 243         }
 244
 245 //fprintf(stderr,"parsing %d bytes\n",strlen(buffer));
 246 //fflush(stderr);
 247         len = 0;
 248         p = buffer;
 249
 250         while (1) {
 251             while (isspace ((unsigned char) *p)) p++;
 252             if (*p == 0)
 253                 break;
 254             strokes[nstrokes].m_x[len] = strtol (p, &q, 0);
 255             if (p == q)
 256                 break;
 257             p = q;
 258
 259             while (isspace ((unsigned char) *p)) p++;
 260             if (*p == 0)
 261                 break;
 262             strokes[nstrokes].m_y[len] = strtol (p, &q, 0);
 263             if (p == q)
 264                 break;
 265             p = q;
 266
 267             len++;
 268         }
 269
 270         if (len == 0)
 271             break;
 272
 273         strokes[nstrokes].m_len = len;
 274         nstrokes++;
 275         if (nstrokes == MAX_STROKES)
 276             break;
 277 //fprintf(stderr,"added strok (%d)\n",nstrokes);
 278     }
 279
 280     if (nstrokes != 0 && nstrokes < MAX_STROKES && stroke_dicts[nstrokes])
 281     {
 282 //fprintf(stderr,"attempting %d stroke lookup\n",nstrokes);
 283         int i;
 284         ListMem *top_picks;
 285         StrokeScorer *scorer = StrokeScorerCreate (stroke_dicts[nstrokes],
 286                                strokes, nstrokes);
 287         if (scorer)
 288         {
 289             StrokeScorerProcess(scorer, -1);
 290             top_picks = StrokeScorerTopPicks(scorer);
 291             StrokeScorerDestroy(scorer);
 292
 293             printf("K");
 294             for (i=0;i<(int)top_picks->m_argc;i++)
 295             {
 296                 if (i)
 297                     printf(" ");
 298                 printf("%s",top_picks->m_argv[i]);
 299             }
 300
 301             free(top_picks);
 302         }
 303         printf("\n");
 304
 305         fflush(stdout);
 306     }
 307         else
 308         {
 309                 fprintf(stderr,"Invalid number of strokes: %d\n",nstrokes);
 310         }
 311     return 1;
 312 }
 313
 314 void
 315 usage ()
 316 {
 317         fprintf(stderr, "Usage: %s [-f/--data-dir DIR]\n", progname);
 318         exit (1);
 319 }
 320
 321 int
 322 real_main(int argc, char **argv)
 323 {
 324         int i;
 325         char *p = progname = argv[0];
 326         while (*p)
 327     {
 328                 if (*p == '/') progname = p+1;
 329                 p++;
 330     }
 331
 332         for (i=1; i<argc; i++)
 333         {
 334                 if (!strcmp(argv[i], "--data-dir") ||
 335                         !strcmp(argv[i], "-d"))
 336                 {
 337                         i++;
 338                         if (i < argc)
 339                                 data_dir = argv[i];
 340                         else
 341                                 usage();
 342                 }
 343                 else
 344                 {
 345                         usage();
 346                 }
 347         }
 348
 349         load_database();
 350
 351         while (process_strokes (stdin))
 352                 ;
 353
 354         return 0;
 355 }
 356
 357 #ifdef __MSWINDOWS__
 358 #include <windows.h>
 359
 360 /* To avoid a console window coming up while running our
 361  * program, on Win32, we act as a GUI app... a WinMain()
 362  * and no main().
 363  */
 364 #ifdef __GNUC__
 365 #  ifndef _stdcall
 366 #    define _stdcall  __attribute__((stdcall))
 367 #  endif
 368 #endif
 369
 370 int _stdcall
 371 WinMain (struct HINSTANCE__ *hInstance,
 372          struct HINSTANCE__ *hPrevInstance,
 373          char               *lpszCmdLine,
 374          int                 nCmdShow)
 375 {
 376   return real_main (__argc, __argv);
 377 }
 378 #else
 379 int
 380 main(int argc, char **argv)
 381 {
 382   return real_main (argc, argv);
 383 }
 384 #endif