trunk/w2t/w2t.c

/*
todo
*/
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <ctype.h>
#include <libgen.h>

#include "triplib.h"

#define   IGNORE_FILE_NAME   "ignore.txt"       /* トリップとして有効でない分の出力先 */

#define   MHCMARK   "#MHC"      /* mhc 用のマーク */

#define   MAX_LINE_LEN   1000   /* 行の最大 */

#define   MINTARG_DEF     7     /* ターゲットの最小文字数のデフォルト */
#define   MINTARG_MIN     1     /* ターゲットの最小文字数の最小 */
#define   MINTARG_MAX    10     /* ターゲットの最小文字数の最大 */

#define   MAXTARG_DEF    10     /* ターゲットの最大文字数のデフォルト */
#define   MAXTARG_MIN     1     /* ターゲットの最大文字数の最小 */
#define   MAXTARG_MAX    10     /* ターゲットの最大文字数の最大 */

#define   MINTANGO_DEF    3     /* 単語とみなす最小文字数のデフォルト */
#define   MINTANGO_MIN    1     /* 単語とみなす最小文字数の最小 */
#define   MINTANGO_MAX   10     /* 単語とみなす最小文字数の最大 */

#define   MINIC_MIN          1  /* 強制的に区別なしにする最小文字数の最小 */
#define   MINIC_MAX         10  /* 強制的に区別なしにする最小文字数の最大 */

int     pattern;        /* 展開指定 */
int     location;       /* 位置指定 */
int     headUpper;      /* 最初のアルファベットを大文字に、以降は小文字に */
int     tobiMode;       /* 飛石埋め */
int     yamaMode;       /* 山彦埋め */
int     sourenMode;     /* 双連埋め */
int     makeIgnore;     /* トリップとして有効でない分の出力 */
int     noSlash;        /* / を空白とみなす */
int     noDot;          /* . を空白とみなす */
int     verbose;        /* 饒舌モード */
int     minTarg;        /* ターゲットの最小文字数 */
int     maxTarg;        /* ターゲットの最大文字数 */
int     minTango;       /* 単語とみなす最小文字数 */
int     minIC;          /* 強制的に区別なしにする最小文字数 999 なら無効 */
int     yokiMode;       /* < >, <->, <'> などをよきにはからう */
int     doorMode;       /* ./ 埋めをした分は、全大文字のみに */
int     inwall;         /* wallChar で囲む */
int     wallChar;       /* 囲みに使う文字 */
int     reverse;        /* 逆読み */
int     mhcMark;        /* mhc 用マークの付加 */
int     repeatUme;      /* 最後の文字で埋め Baka -> Bakaaaaa */

unsigned char   *inputFileName;
FILE    *inputFile;

FILE    *ignoreFile;

int     lineNo;

#define   MAX_MARK_PI_LEN   100
unsigned char   mark[MAX_MARK_PI_LEN];
unsigned char   postit[MAX_MARK_PI_LEN];

#define   TOSEEK     0
#define   TOTARGET   1
#define   TOL2R      2
int     kind;

void
usage()
{
  switch ( kind ) {
   case TOSEEK:
    fprintf( stderr, "word2seek 1.9\n" );
    fprintf( stderr, "w2s [-e num] [-c num] [-w num] [-g num] [-u] [-s {2|4|5}] [-/] [-f] [-i] [-t] [-r] [-n] [-y] [-d {/|.}] [-m mark] [-p postit] [-R] [-k] [-v] [-h] [-?] [ifile]\n" );
    break;
   case TOTARGET:
    fprintf( stderr, "word2target 1.8\n" );
    fprintf( stderr, "w2t [-e num] [-c num] [-w num] [-g num] [-u] [-s {2|4|5}] [-/] [-f] [-i] [-t] [-r] [-n] [-y] [-d {/|.}] [-a] [-m mark] [-M] [-R] [-k] [-v] [-h] [-?] [ifile]\n" );
    break;
   case TOL2R:
    fprintf( stderr, "word2l2r 1.4\n" );
    fprintf( stderr, "w2l [-e num] [-c num] [-w num] [-u] [-s {2|4|5}] [-/] [-f] [-r] [-n] [-y] [-d {/|.}] [-R] [-k] [-v] [-h] [-?] [ifile]\n" );
    break;
  }
  fprintf( stderr, "何もオプションを指定しない場合、先頭指定で完全一致 + 3 パターン展開となります。\n" );
  fprintf( stderr, " -e num : ターゲットの最小文字数 (%d 〜 %d 、デフォルトは %d)\n",
          MINTARG_MIN, MINTARG_MAX, MINTARG_DEF );
  fprintf( stderr, " -c num : ターゲットの最大文字数 (%d 〜 %d 、デフォルトは %d)\n",
          MAXTARG_MIN, MAXTARG_MAX, MAXTARG_DEF );
  fprintf( stderr, " -w num : 単語とみなす最小文字数 (%d 〜 %d 、デフォルトは %d)\n",
          MINTANGO_MIN, MINTANGO_MAX, MINTANGO_DEF );
  if ( kind != TOL2R ) {
   fprintf( stderr, " -g num : 強制的に区別なしにする最小文字数 (%d 〜 %d 、デフォルトではしない)\n",
           MINIC_MIN, MINIC_MAX );
  }
  fprintf( stderr, " -u : 先頭のアルファベットを大文字に、残りを小文字に\n" );
  fprintf( stderr, " -s 2 : 飛石埋め\n" );
  fprintf( stderr, " -s 4 : 山彦埋め\n" );
  fprintf( stderr, " -s 5 : 双連埋め\n" );
  fprintf( stderr, " -/ : 単語を / で囲む\n" );
  fprintf( stderr, " -. : 単語を . で囲む\n" );
  fprintf( stderr, " ( -/ と -. は排他)\n" );
  fprintf( stderr, " -f : 完全一致\n" );
  if ( kind != TOL2R ) {
   fprintf( stderr, " -i : 大文字小文字区別なし\n" );
   fprintf( stderr, " -t : 後方指定\n" );
  }
  fprintf( stderr, " -r : 位置指定なし\n" );
  fprintf( stderr, " -n : トリップとして有効でない分を %s に出力\n", IGNORE_FILE_NAME );
  fprintf( stderr, " -y : 1 エントリ / 1 行とみなして、いろいろとよきにはからう\n" );
  fprintf( stderr, " -d / : 読み込んだ / を空白とみなす\n" );
  fprintf( stderr, " -d . : 読み込んだ . を空白とみなす\n" );
  if ( kind == TOTARGET ) {
   fprintf( stderr, " -a : ./ で埋めた時は、全大文字のみに\n" );
  }
  if ( kind == TOSEEK ) {
   fprintf( stderr, " -m mark : Unified Tripper 対応のマーク\n" );
   fprintf( stderr, " -p postit : Unified Tripper 対応の付箋\n" );
  }
  if ( kind == TOTARGET ) {
   fprintf( stderr, " -m mark : まあ、待て屋。ログマネージャ対応のマーク\n" );
   fprintf( stderr, " -M : まあ、待て屋。ヒットチェッカー用マークを付加\n" );
  }
  fprintf( stderr, " -R : 逆読み\n" );
  fprintf( stderr, " -k : 最後の文字繰り返し埋め\n" );
  fprintf( stderr, " -v : 饒舌モード\n" );
  fprintf( stderr, " -h : これを表示\n" );
  fprintf( stderr, " -? : これを表示\n" );
  fprintf( stderr, " ifile : 単語ファイル (省略時には、標準入力から)\n" );
}

void
getOption( ac, av )
int     ac;
char    *av[];
{
  extern char   *optarg;
  extern int    optind, opterr, optopt;
  int   optChar;

  pattern = PAT_3;
  location = LOC_HEAD;
  minTarg = MINTARG_DEF;
  maxTarg = MAXTARG_DEF;
  headUpper = TL_FALSE;
  tobiMode = TL_FALSE;
  yamaMode = TL_FALSE;
  sourenMode = TL_FALSE;
  minTango = MINTANGO_DEF;
  verbose = TL_FALSE;
  makeIgnore = TL_FALSE;
  noSlash = TL_FALSE;
  noDot = TL_FALSE;
  yokiMode = TL_FALSE;
  doorMode = TL_FALSE;
  inwall = TL_FALSE;
  wallChar = ' ';
  reverse = TL_FALSE;
  mark[0] = '\0';
  postit[0] = '\0';
  minIC = 999;
  mhcMark = TL_FALSE;
  repeatUme = TL_FALSE;
  while ( (optChar = getopt(ac, av, "e:c:w:g:us:/.fitrnyd:am:Mp:Rkvh?")) != EOF ) {
   switch ( optChar ) {
    case 'e':
     minTarg = atoi( optarg );
     if ( minTarg < MINTARG_MIN || minTarg > MINTARG_MAX ) {
      usage();
      exit( 1 );
     }
     break;
    case 'c':
     maxTarg = atoi( optarg );
     if ( maxTarg < MAXTARG_MIN || maxTarg > MAXTARG_MAX ) {
      usage();
      exit( 1 );
     }
     break;
    case 'w':
     minTango = atoi( optarg );
     if ( minTango < MINTANGO_MIN || minTango > MINTANGO_MAX ) {
      usage();
      exit( 1 );
     }
     break;
    case 'g':
     minIC = atoi( optarg );
     if ( minIC < MINIC_MIN || minIC > MINIC_MAX ) {
      usage();
      exit( 1 );
     }
     if ( kind == TOL2R ) {
      usage();
      exit( 1 );
     }
     break;
    case 'u': headUpper = TL_TRUE; break;
    case 's':
     switch ( optarg[0] ) {
      case '2': tobiMode = TL_TRUE; break;
      case '4': yamaMode = TL_TRUE; break;
      case '5': sourenMode = TL_TRUE; break;
      default:
       usage();
       exit( 1 );
     }
     break;
    case '/':
     if ( wallChar == '.' ) {
      usage();
      exit( 1 );
     }
     inwall = TL_TRUE;
     wallChar = '/';
     break;
    case '.':
     if ( wallChar == '/' ) {
      usage();
      exit( 1 );
     }
     inwall = TL_TRUE;
     wallChar = '.';
     break;
    case 'f': pattern = PAT_PERF; break;
    case 'i':
     pattern = PAT_ANY;
     if ( kind == TOL2R ) {
      usage();
      exit( 1 );
     }
     break;
    case 't':
     location = LOC_TAIL;
     if ( kind == TOL2R ) {
      usage();
      exit( 1 );
     }
     break;
    case 'r': location = LOC_ANY; break;
    case 'n': makeIgnore = TL_TRUE; break;
    case 'y': yokiMode = TL_TRUE; break;
    case 'd':
     switch ( optarg[0] ) {
      case '/': noSlash = TL_TRUE; break;
      case '.': noDot = TL_TRUE; break;
     }
     break;
    case 'a':
     if ( kind != TOTARGET ) {
      usage();
      exit( 1 );
     }
     doorMode = TL_TRUE;
     break;
    case 'm':
     if ( kind != TOSEEK && kind != TOTARGET ) {
      usage();
      exit( 1 );
     }
     strcpy( mark, optarg );
     break;
    case 'M':
     if ( kind != TOTARGET ) {
      usage();
      exit( 1 );
     }
     mhcMark = TL_TRUE;
     break;
    case 'p':
     if ( kind != TOSEEK ) {
      usage();
      exit( 1 );
     }
     strcpy( postit, optarg );
     break;
    case 'R': reverse = TL_TRUE; break;
    case 'k': repeatUme = TL_TRUE; break;
    case 'v': verbose = TL_TRUE; break;
    case 'h': case '?': usage(); exit( 0 ); break;
   }
  }

  switch ( ac - optind) {
   case 0:
    inputFileName = NULL;
    break;
   case 1:
    inputFileName = av[optind];
    break;
   default:
    usage();
    exit( 1 );
  }

  if ( verbose ) {
   fprintf( stderr, "ターゲットの最小文字数 : %d\n", minTarg );
   fprintf( stderr, "ターゲットの最大文字数 : %d\n", maxTarg );
   fprintf( stderr, "単語とみなす最小文字数 : %d\n", minTango );
   if ( headUpper ) {
    fprintf( stderr, "先頭大文字、残りを小文字に変換\n" );
   }
   if ( tobiMode ) {
    fprintf( stderr, "飛石埋め\n" );
   }
   if ( yamaMode ) {
    fprintf( stderr, "山彦埋め\n" );
   }
   if ( sourenMode ) {
    fprintf( stderr, "双連埋め\n" );
   }
   switch ( pattern ) {
    case PAT_PERF: fprintf( stderr, "完全一致\n" );  break;
    case PAT_ANY:  fprintf( stderr, "大文字小文字区別なし\n" ); break;
    case PAT_3:    fprintf( stderr, "完全一致 + 3 パターン展開\n" );  break;
   }
   switch ( location ) {
    case LOC_HEAD: fprintf( stderr, "先頭指定\n" );  break;
    case LOC_ANY:  fprintf( stderr, "位置指定なし\n" ); break;
    case LOC_TAIL: fprintf( stderr, "末尾指定\n" );  break;
   }
   if ( kind == TOSEEK || kind == TOTARGET ) {
    if ( mark[0] != '\0' ) {
     fprintf( stderr, "マークとして、%s を使用\n", mark );
    }
    if ( postit[0] != '\0' ) {
     fprintf( stderr, "付箋として、%s を使用\n", postit );
    }
    if ( mhcMark ) {
     /* target の場合のみだけど、seek なら mhcMark は偽なのでおｋ */
     fprintf( stderr, "mhc 用マークを付加\n" );
    }
   }
   if ( makeIgnore ) {
    fprintf( stderr, "トリップとして有効でない分は、%s ファイルへ出力\n",
            IGNORE_FILE_NAME );
   }
   if ( noSlash ) {
    fprintf( stderr, "読み込んだ / は空白とみなす\n" );
   }
   if ( noDot ) {
    fprintf( stderr, "読み込んだ . は空白とみなす\n" );
   }
   if ( yokiMode ) {
    fprintf( stderr, "読み込んだ空白と - と ' を適切に処理\n" );
   }
   if ( doorMode ) {
    fprintf( stderr, "./ で埋めた時には、全大文字のみに\n" );
   }
   if ( inwall ) {
    fprintf( stderr, "%c で囲む\n", wallChar );
   }
   if ( reverse ) {
    fprintf( stderr, "逆読み (マニア向けｗ)\n" );
   }
   if ( repeatUme ) {
    fprintf( stderr, "最後の文字繰り返し埋め\n" );
   }
  }
}

void
writeL2r( word )
unsigned char   *word;
{
  static int    firstCall = TL_TRUE;
  static unsigned char  head[2];

  if ( firstCall ) {
   firstCall = TL_FALSE;
   head[1] = '\0';
   switch ( location ) {
    case LOC_HEAD:
      switch ( pattern ) {
       case PAT_PERF: head[0] = '&'; break;
       case PAT_3:    head[0] = '^'; break;
      }
      break;
    case LOC_ANY:
      switch ( pattern ) {
       case PAT_PERF: head[0] = '@'; break;
       case PAT_3:    head[0] = '\0'; break;
      }
      break;
   }
  }

  printf( "%s%s\n", head, word );
}

void
writeSeek( word )
unsigned char   *word;
{
  static int    firstCall = TL_TRUE;
  static unsigned char  loc[2], pat[2];
  int   wordLen;

  if ( firstCall ) {
   firstCall = TL_FALSE;
   loc[1] = '\0';
   switch ( location ) {
    case LOC_HEAD: loc[0] = '^';  break;
    case LOC_ANY:  loc[0] = '\0'; break;
    case LOC_TAIL: loc[0] = '>';  break;
   }
   pat[1] = '\0';
   switch ( pattern ) {
    case PAT_PERF: pat[0] = '*';  break;
    case PAT_ANY:  pat[0] = '\0'; break;
    case PAT_3:    pat[0] = '+';  break;
   }
  }

  wordLen = strlen( word );
  if ( minIC <= wordLen ) {
   printf( "%s%s", loc, word );
  } else {
   printf( "%s%s%s", loc, word, pat );
  }
  if ( mark[0] != '\0' ) {
   printf( "\t/M%s", mark );
  }
  if ( postit[0] != '\0' ) {
   printf( "\t/P%s", postit );
  }
  printf( "\n" );
}

void
writeTarget( word )
unsigned char   *word;
{
  static int    firstCall = TL_TRUE;
  static unsigned char  head[2], tail[2];
  unsigned char *threePat[3];
  int   wordLen;
  int   i;
  int   needTailCheck;
  unsigned char tailChar;

  if ( firstCall ) {
   firstCall = TL_FALSE;
   head[1] = '\0';
   tail[1] = '\0';
   switch ( location ) {
    case LOC_HEAD: head[0] = '^';  tail[0] = '\0'; break;
    case LOC_ANY:  head[0] = '\0'; tail[0] = '\0'; break;
    case LOC_TAIL: head[0] = '\0'; tail[0] = '$';  break;
   }
  }

  wordLen = strlen( word );
  tailChar = word[wordLen - 1];
  needTailCheck = (location == LOC_TAIL || wordLen == TRIP_LEN);

  if ( minIC <= wordLen || pattern == PAT_ANY ) {
   /* 区別なし */
   if ( needTailCheck && !istailic[word[wordLen - 1]] ) {
    return;
   }
   printf( "%s", head );
   for ( i = 0; i < wordLen - 1; i++ ) {
    if ( isalpha( word[i] ) ) {
     printf( "[%c%c]", tolower( word[i] ), toupper( word[i] ) );
    } else {
     putchar( word[i] );
    }
   }
   /* 最後の一文字は、末尾かどうかで処理が変わる */
   if ( needTailCheck ) {
    if ( istail[tolower( tailChar )] ) {
     putchar( tolower( tailChar ) );
    } else {
     putchar( toupper( tailChar ) );
    }
   } else {
    if ( isalpha( tailChar ) ) {
     printf( "[%c%c]", tolower( tailChar ), toupper( tailChar ) );
    } else {
     putchar( tailChar );
    }
   }
   printf( "%s", tail );
   if ( mark[0] != '\0' ) {
    printf( "\t#%s", mark );
   }
   if ( mhcMark ) {
    printf( "\t%s", MHCMARK );
   }
   printf( "\n" );
  } else if ( pattern == PAT_PERF ) {
   /* 完全 */
   if ( (needTailCheck && istail[tailChar]) || !needTailCheck ) {
    printf( "%s%s%s", head, word, tail );
    if ( mark[0] != '\0' ) {
     printf( "\t#%s", mark );
    }
    if ( mhcMark ) {
     printf( "\t%s", MHCMARK );
    }
    printf( "\n" );
   }
  } else if ( pattern == PAT_3 ) {
   /* 3 パターン */
   /* オリジナルが全小/全大/先大のどれかなら出力しない */
   /* 全大とまとめられる場合もあるけど、まいっか */
   if ( !doorMode ) {
    if ( (needTailCheck && istail[tailChar]) || !needTailCheck ) {
     if ( reverse ) {
      make3PatternR( word, threePat );
     } else {
      make3Pattern( word, threePat );
     }
     for ( i = 0; i < 3; i++ ) {
      if ( threePat[i] == NULL ) {
       goto NEXT;
      }
     }
     printf( "%s%s%s", head, word, tail );
     if ( mark[0] != '\0' ) {
      printf( "\t#%s", mark );
     }
     if ( mhcMark ) {
      printf( "\t%s", MHCMARK );
     }
     printf( "\n" );
    }
    NEXT:
    /* 9[aA]bcd : 最初に現れるアルファベットのみ大小、残り小 */
    /* 逆読みの場合は、最後に現れる(r */
    if ( (needTailCheck && istail[tolower(tailChar)]) || !needTailCheck ) {
     int        alphaIdx;
     printf( "%s", head );
     if ( reverse ) {
      for ( alphaIdx = wordLen - 1; alphaIdx >= 0; alphaIdx-- ) {
       if ( isalpha( word[alphaIdx] ) ) { break; }
      }
     } else {
      for ( alphaIdx = 0; alphaIdx < wordLen; alphaIdx++ ) {
       if ( isalpha( word[alphaIdx] ) ) { break; }
      }
     }
     for ( i = 0; i < wordLen; i++ ) {
      if ( i == alphaIdx ) {
       putchar( '[' );
       putchar( tolower( word[i] ) );
       putchar( toupper( word[i] ) );
       putchar( ']' );
      } else {
       putchar( tolower( word[i] ) );
      }
     }
     printf( "%s", tail );
     if ( mark[0] != '\0' ) {
      printf( "\t#%s", mark );
     }
     if ( mhcMark ) {
      printf( "\t%s", MHCMARK );
     }
     printf( "\n" );
    }
   }
   /* ABCD : 全大 */
   if ( (needTailCheck && istail[toupper(tailChar)]) || !needTailCheck ) {
    printf( "%s", head );
    for ( i = 0; i < wordLen; i++ ) {
     putchar( toupper( word[i] ) );
    }
    printf( "%s", tail );
    if ( mark[0] != '\0' ) {
     printf( "\t#%s", mark );
    }
    if ( mhcMark ) {
     printf( "\t%s", MHCMARK );
    }
    printf( "\n" );
   }
  }
}

void
writeIt( word )
unsigned char   *word;
{
  unsigned char tmpWord[MAX_LINE_LEN];
  int   wordLen;

  strcpy( tmpWord, word );
  tmpWord[maxTarg] = '\0';
  wordLen = strlen( tmpWord );
  if ( wordLen == TRIP_LEN ) {
   if ( pattern == PAT_PERF ) {
    if ( !istail[tmpWord[TRIP_LEN - 1]] ) {
     return;
    }
   } else {
    if ( !istailic[tmpWord[TRIP_LEN - 1]] ) {
     return;
    }
   }
  }

  switch ( kind ) {
   case TOSEEK:
    writeSeek( tmpWord );
    break;
   case TOTARGET:
    writeTarget( tmpWord );
    break;
   case TOL2R:
    writeL2r( tmpWord );
    break;
  }
}

void
ume( line, delim )
unsigned char   *line;
unsigned char   delim;
{
  int   i;
  unsigned char ume[MAX_LINE_LEN];

  for ( i = 0; line[i] != '\0'; i++ ) {
   ume[i] = line[i];
  }
  for ( ; i < minTarg; i++ ) {
   ume[i] = delim;
  }
  ume[i] = '\0';
  writeIt( ume );
}

void
tobi( line, delim )
unsigned char   *line;
unsigned char   delim;
{
  int   i, j;
  unsigned char tobi1[MAX_LINE_LEN], tobi2[MAX_LINE_LEN];

  j = 0;
  for ( i = 0; line[i] != '\0'; i++ ) {
   tobi1[j] = delim;
   tobi2[j] = line[i];
   j++;
   tobi1[j] = line[i];
   tobi2[j] = delim;
   j++;
  }
  tobi2[j] = '\0';
  tobi1[j++] = delim;
  tobi1[j] = '\0';
  tobi1[10] = '\0';
  ume( tobi1, delim );
  if ( delim != '/' ) {
   ume( tobi2, delim );
  } else {
   if ( strlen( line ) <= 4 ) {
    j = 0;
    for ( i = 0; line[i] != '\0'; i++ ) {
     tobi1[j++] = line[i];
     tobi1[j++] = '.';
     tobi1[j++] = '.';
    }
    tobi1[j] = '\0';
    tobi1[10] = '\0';
    ume( tobi1, delim );
   }
  }
}

void
yamaSub( yama )
unsigned char   *yama;
{
  ume( yama, '.' );
  if ( strlen( yama ) < minTarg ) {
   ume( yama, '/' );
  }
}

void
yama( line )
unsigned char   *line;
{
  unsigned char yama[MAX_LINE_LEN];
  int   wordLen;

  strcpy( yama, line );
  strcat( yama, line );
  yamaSub( yama );

  wordLen = strlen( line );
  switch ( wordLen ) {
   case 2:
    strcpy( yama, line );
    strcat( yama, line );
    strcat( yama, line );
    strcat( yama, line );
    yamaSub( yama );
    break;
   case 3:
    strcpy( yama, line );
    strcat( yama, line );
    strcat( yama, line );
    yamaSub( yama );
    break;
  }
}

void
souren( line )
unsigned char   *line;
{
  int   i, j;
  unsigned char souren[MAX_LINE_LEN];

  j = 0;
  for ( i = 0; line[i] != '\0'; i++ ) {
   souren[j++] = line[i];
   souren[j++] = line[i];
  }
  souren[j] = '\0';
  ume( souren, '.' );
  if ( strlen( souren ) < minTarg ) {
   ume( souren, '/' );
  }
}

void
addWord( word )
unsigned char   *word;
{
  int   i;
  int   wordLen;

  wordLen = strlen( word );
  if ( wordLen < minTango || wordLen > TRIP_LEN ) {
   if ( makeIgnore ) {
    fprintf( ignoreFile, "%d : %s (文字数)\n", lineNo, word );
   }
   return;
  }
  if ( wordLen == TRIP_LEN ) {
   if ( pattern == PAT_PERF ) {
    if ( !istail[word[TRIP_LEN - 1]] ) {
     if ( makeIgnore ) {
      fprintf( ignoreFile, "%d : %s (末尾文字)\n", lineNo, word );
     }
     return;
    }
   } else {
    if ( !istailic[word[TRIP_LEN - 1]] ) {
     if ( makeIgnore ) {
      fprintf( ignoreFile, "%d : %s (末尾文字)\n", lineNo, word );
     }
     return;
    }
   }
  }

  if ( headUpper ) {
   for ( i = 0; word[i] != '\0'; i++ ) {
    if ( isalpha( word[i] ) ) {
     word[i] = toupper( word[i] );
     break;
    }
   }
   i++;
   for ( ; word[i] != '\0'; i++ ) {
    word[i] = tolower( word[i] );
   }
  }
  if ( tobiMode || yamaMode || sourenMode ) {
   if ( wordLen <= (TRIP_LEN / 2) ) {
    if ( tobiMode ) {
     tobi( word, '.' );
     tobi( word, '/' );
    }
    if ( yamaMode ) {
     yama( word );
    }
    if ( sourenMode ) {
     souren( word );
    }
   }
  } else {
   if ( wordLen < minTarg ) {
    if ( repeatUme ) {
     ume( word, word[wordLen - 1] );
    } else {
     ume( word, '.' );
     ume( word, '/' );
    }
   } else {
    writeIt( word );
   }
  }
}

void
makeIt()
{
  int   i, j, wordIndex1, wordIndex3;
  int   toUpper;
  int   lineLen;
  unsigned char line[MAX_LINE_LEN], tmpLine[MAX_LINE_LEN],
                tmpWord[MAX_LINE_LEN],
                word1[MAX_LINE_LEN], word2[MAX_LINE_LEN], word3[MAX_LINE_LEN];
  unsigned char *linePtr, *strHead;

  if ( inputFileName == NULL ) {
   inputFile = stdin;
  } else {
   if ( (inputFile = fopen( inputFileName, "r" )) == NULL ) {
    fprintf( stderr, "%s が読めません。\n", inputFileName );
    exit( 1 );
   }
  }
  if ( makeIgnore ) {
   if ( (ignoreFile = fopen( IGNORE_FILE_NAME, "w" )) == NULL ) {
    fprintf( stderr, "%s に書けません。\n", IGNORE_FILE_NAME );
    exit( 1 );
   }
  }

  lineNo = 0;
  while ( fgets( line, MAX_LINE_LEN, inputFile ) != NULL ) {
   lineNo++;
   if ( line[0] == '#' ) {
    /* 先頭が # の行はコメントとして無視 */
    continue;
   }
   lineLen = delCr( line );

   /*
    先頭の空白を捨てつつ、連続する空白を一個にまとめて、末尾の空白も捨てる
    */
   i = 0;
   j = 0;
   while ( i < lineLen ) {
    if ( line[i] == ' ' || line[i] == '\t' ) {
     tmpLine[j++] = ' ';
#if 0
     if ( j != 0 ) {
      if ( tmpLine[j-1] != '.' ) {
       tmpLine[j++] = ' ';
      }
     }
#endif /* 0 */
     while ( line[i] == ' ' || line[i] == '\t' ) {
      i++;
     }
    } else {
     tmpLine[j++] = line[i++];
    }
   }
   if ( tmpLine[j-1] == ' ' ) {
    j--;
   }
   tmpLine[j] = '\0';
   strcpy( line, tmpLine );
   lineLen = j;
#ifdef OLDDEBUG
   printf( "line = <%s>, lineLen = %d\n", line, lineLen );
   exit( 0 );
#endif /* DEBUG */

   if ( reverse ) {
    unsigned char       work;
#ifdef OLDDEBUG
    printf( "reverse before : <%s>\n", line );
#endif /* DEBUG */
/*
 abc 0,2
 abcd 0,3 1,2
*/
    for ( i = 0; i < lineLen / 2; i++ ) {
     work = line[i];
     line[i] = line[lineLen - i - 1];
     line[lineLen - i - 1] = work;
    }
#ifdef OLDDEBUG
    printf( "reverse after : <%s>\n", line );
#endif /* DEBUG */
   }
   if ( inwall ) {
    line[lineLen+1] = wallChar;
    line[lineLen+2] = '\0';
    for ( i = lineLen; i > 0; i-- ) {
     line[i] = line[i-1];
    }
    line[0] = wallChar;
    lineLen += 2; 
   }
#ifdef OLDDEBUG
   printf( "line = <%s>\n", line );
#endif /* DEBUG */
   if ( yokiMode ) {
    int needYoki;
    needYoki = TL_FALSE;
    for ( i = 0; i < lineLen; i++ ) {
     if ( line[i] == '-' || line[i] == ' ' ||
          line[i] == '\'' || line[i] == ',' ) {
      needYoki = TL_TRUE;
      break;
     } else {
      if ( !istrip[line[i]] ) {
       fprintf( stderr, "トリップとして有効でない文字 (%c) が %d 行目に。\n",
                line[i], lineNo );
       needYoki = TL_TRUE;
       break;
      }
     }
    }
    if ( needYoki ) {
     /* ' と , は捨てる。. の後ろのスペースも捨てる。!istrip[] な文字も捨てる */
     wordIndex1 = 0;
     for ( i = 0; line[i] != '\0'; i++ ) {
      if ( line[i] != '\'' && line[i] != ',' ) {
       if ( line[i] == ' ' ) {
        if ( wordIndex1 != 0 ) {
         if ( tmpWord[wordIndex1-1] != '.' ) {
          tmpWord[wordIndex1] = line[i];
          wordIndex1++;
         }
        }
       } else {
        if ( istrip[line[i]] ) {
         tmpWord[wordIndex1] = line[i];
         wordIndex1++;
        }
       }
      }
     }
     tmpWord[wordIndex1] = '\0';
#ifdef OLDDEBUG
     printf( "after del <'> : tmpWord = <%s>\n", tmpWord );
#endif /* DEBUG */
     /* <->, < > : . / 無 (先大) */
     wordIndex1 = wordIndex3 = 0;
     toUpper = TL_TRUE;
     for ( i = 0; tmpWord[i] != '\0'; i++ ) {
      if ( tmpWord[i] == '-' || tmpWord[i] == ' ' ) {
       word1[wordIndex1] = '.';
       word2[wordIndex1] = '/';
       wordIndex1++;
       toUpper = TL_TRUE;
      } else {
       if ( toUpper ) {
        word1[wordIndex1] = toupper( tmpWord[i] );
        word2[wordIndex1] = toupper( tmpWord[i] );
        word3[wordIndex3] = toupper( tmpWord[i] );
        toUpper = TL_FALSE;
       } else {
        word1[wordIndex1] = tmpWord[i];
        word2[wordIndex1] = tmpWord[i];
        word3[wordIndex3] = tmpWord[i];
       }
       wordIndex1++;
       wordIndex3++;
      }
     }
     word1[wordIndex1] = '\0';
     word2[wordIndex1] = '\0';
     word3[wordIndex3] = '\0';
     addWord( word1 );
     if ( strcmp( word1, word2 ) != 0 ) {
      addWord( word2 );
      addWord( word3 );
     }
#ifdef OLDDEBUG
     printf( "word1 = <%s>, word2 = <%s>, word3 = <%s>\n",
             word1, word2, word3 );
#endif /* DEBUG */
    } else {
     addWord( line );
    }
   } else {
    for ( linePtr = line + lineLen - 1; linePtr >= line; linePtr-- ) {
     if ( !istrip[*linePtr] ) {
      *linePtr = '\0';
     }
     if ( noSlash && *linePtr == '/' ) {
      *linePtr = '\0';
     }
     if ( noDot && *linePtr == '.' ) {
      *linePtr = '\0';
     }
    }
    for ( i = 0; i < lineLen; i++ ) {
     if ( line[i] != '\0' ) {
#ifdef OLDDEBUG
      printf( "word = <%s>\n", line + i );
#endif /* DEBUG */
      addWord( line + i );
      for ( ; i < lineLen; i++ ) {
       if ( line[i] == '\0' ) {
        break;
       }
      }
     }
    }
   }
  }

  if ( makeIgnore ) {
   fclose( ignoreFile );
  }
  fclose( inputFile );
}

main( ac, av )
int     ac;
char    *av[];
{
  char  *myName;

  myName = basename( av[0] );
  switch ( myName[2] ) {
   case 't': /* w2t */
    kind = TOTARGET; break;
   case 's': /* w2s */
    kind = TOSEEK; break;
   case 'l': /* w2l */
    kind = TOL2R; break;
   default:
    fprintf( stderr, "ここはだれ？わたしはどこ？\n" );
    exit( 1 );
  }
#ifdef OLDDEBUG
  printf( "myName = <%s>, kind = %d\n", myName, kind );
#endif /* DEBUG */

  getOption( ac, av );

  makeIt();

  exit( 0 );
}