annotate Wnn/jserver/jikouho.c @ 25:466fe6732d8d

- fixed more NULL pointer related errata - suppress warnings

/*
 *  $Id: jikouho.c,v 1.6 2002/05/12 22:51:16 hiroo Exp $
 */

/*
 * FreeWnn is a network-extensible Kana-to-Kanji conversion system.
 * This file is part of FreeWnn.
 * 
 * Copyright Kyoto University Research Institute for Mathematical Sciences
 *                 1987, 1988, 1989, 1990, 1991, 1992
 * Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1999
 * Copyright ASTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992
 * Copyright FreeWnn Project 1999, 2000, 2002
 *
 * Maintainer:  FreeWnn Project   <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/************************************************
 *      小文節次候補取りだし                    *
 ************************************************/
#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include        <stdio.h>
#include        <ctype.h>
#if STDC_HEADERS
#  include	<stdlib.h>
#endif /* STDC_HEADERS */

#include        "commonhd.h"
#include        "de_header.h"
#include        "jdata.h"
#include        "fzk.h"
#include        "kaiseki.h"

static struct JKT_SBN *find_jktsbn ();
static int cmp_dsd_sbn (), cnt_jkt_sbn (), get_suuji_kouho (), get_eisuu_kouho (), get_kigou_kouho ();

static int
jkt_sbn (yomi_sno, yomi_eno, endvect, endvect1, tjktsbn, bnst_num, parent)
     int yomi_sno;
     int yomi_eno;
     int endvect;               /* 終端ベクタ */
     int endvect1;              /* 終端ベクタ */
     struct JKT_SBN **tjktsbn;  /* 小文節解析結果 */
     int bnst_num;
     struct JKT_SBN *parent;    /* 親の幹語ノード */
{
  register int fzkcnt, ii, jktcnt;
  register int i;
  struct JKT_SBN *jktsbn;
  struct JKT_SBN *jktsbn_top;
  struct ICHBNP *ichbnpbp;
  int cnt;
  int gijiflag = 0;

  struct SYO_BNSETSU *getsbnsp ();
  struct SYO_BNSETSU *giji_sbn;

  if (yomi_sno == yomi_eno)
    return (NOTHING);

  jktcnt = 0;
  if (fzk_ckvt (endvect) == NO && fzk_ckvt (endvect1) == NO)
    return (NOTHING);
  fzkcnt = fzk_kai (&bun[yomi_sno], &bun[yomi_eno], endvect, endvect1, &ichbnpbp);
  if (fzkcnt <= 0)
    return (fzkcnt);            /* ERROR */
  for (ii = 0; ii < fzkcnt; ii++)
    getfzkoh (ichbnpbp, ii)->offset += yomi_sno;

  jktsbn_top = NULL;

  for (ii = 0; ii < fzkcnt; ii++)
    {                           /* 辞書引き */
      i = getfzkoh (ichbnpbp, ii)->offset;
      if (jmtp[i] == (struct jdata **) UN_KNOWN)
        {                       /* もう引いた? */
          jmt_set (i);
        }
    }

  if ((giji_sbn = getsbnsp ()) == NO)
    return (-1);                /* ERROR */

  giji_sbn->bend_m = yomi_sno;
  if (getgiji (yomi_sno, yomi_eno, giji_sbn, ichbnpbp, fzkcnt, bnst_num) >= 0)
    {
      if ((giji_sbn->j_c == yomi_eno - 1) && (giji_sbn->hinsi_fk != katakanago_no && giji_sbn->hinsi_fk != giji_no && giji_sbn->hinsi_fk != fuzokugo_no))
        {
          if (get_zen_giji (giji_sbn, &jktsbn) < 0)
            return (-1);
          jktsbn->parent = parent;
          jktsbn->kbcnt = bnst_num;
          jktsbn_top = jktsbn;
          gijiflag = 1;
          jktcnt = 1;
        }
    }
  freesbn (giji_sbn);

  if ((cnt = jkt_sbn_one (yomi_sno, yomi_eno, &jktsbn_top, bnst_num, parent, ichbnpbp, fzkcnt)) < 0)
    return (-1);
  jktcnt += cnt;

#ifndef NO_KANA
  if (gijiflag == 0)
    {                           /* ひらがな候補 */
      if ((jktsbn = get_hira_kouho (&jktsbn_top, yomi_sno, yomi_eno)) < (struct JKT_SBN *) 0)
        return (-1);
      if (jktsbn != NULL)
        {
          jktsbn->parent = parent;
          jktsbn->bend_m = yomi_sno;
          jktsbn->kbcnt = bnst_num;
          jktcnt++;
        }
    }
#endif /* NO_KANA */

  *tjktsbn = jktsbn_top;
  freeibsp (ichbnpbp);
  return (jktcnt);
}

int
jkt_sbn_one (yomi_sno, yomi_eno, jktsbn_top, bnst_num, parent, ichbnpbp, fzkcnt)
     int yomi_sno;
     int yomi_eno;
     struct JKT_SBN **jktsbn_top;
     int bnst_num;              /* これまでに解析した小文節数 */
     struct JKT_SBN *parent;    /* 親の幹語ノード */
     struct ICHBNP *ichbnpbp;
     register int fzkcnt;
{
  register int ii, hyokaval, hyokaval0, hinsidt, jktcnt;
  int hinsidt_fk;               /* 複合品詞のセーブ */
  unsigned short *hinsi_buf;
  struct jdata *jentptr;
  register int i,               /* 幹語の終わりのインデックス */
    t;
  struct JKT_SBN *jktsbn;
  register struct JKT_SONE *jktsone;
  int ll;
  struct fzkkouho *fzkptr;

  int connect_flg;

  jktcnt = 0;

  for (ii = 0; ii < fzkcnt; ii++)
    {                           /* 付属語 */
      fzkptr = getfzkoh (ichbnpbp, ii);
      i = fzkptr->offset;
      jentptr = (i > yomi_eno - 1) ? (struct jdata *) NULL : (struct jdata *) C (i, yomi_eno - 1);
      for (; jentptr; jentptr = jentptr->jptr)
        {                       /* 辞書 */
          for (t = 0; t < (jentptr->kosuu); t++)
            {                   /* 幹語 */
#ifdef  CONVERT_with_SiSheng
              hyokaval = hyoka1 (jentptr->hindo[t],
                                 (jentptr->hindo_in == 0 ? 0 : jentptr->hindo_in[t]),
                                 diff_sisheng (jentptr->sisheng[t], jentptr->sisheng_int), yomi_eno - yomi_sno / 2 - i / 2, dic_table[jentptr->jishono].nice);
#else
              hyokaval = hyoka1 (jentptr->hindo[t], (jentptr->hindo_in == 0 ? 0 : jentptr->hindo_in[t]), yomi_eno - i, yomi_eno - yomi_sno, dic_table[jentptr->jishono].nice);
#endif /* CONVERT_with_SiSheng */
              hinsidt_fk = hinsidt = jentptr->hinsi[t];
              if ((ll = wnn_get_fukugou_component_body (hinsidt_fk, &hinsi_buf)) == 0)
                {
                  error1 ("wnn_get_fukugou_component:erroe in jkt_sbn_one.\n");
                  return (-1);
                }
              for (; ll > 0; ll--)
                {
                  hinsidt = *hinsi_buf;
                  hinsi_buf++;
                  /* ここから後は単純品詞だけ考えればいい */
                  connect_flg = kan_ck_vector (hinsidt, fzkptr->vector);
                  if (!(jentptr->hindo_in && (jentptr->hindo_in[t] & 0x7f) == 0x7f) && ((jentptr->hindo[t] & 0x7f) != 0x7f) &&
                      /*コメントアウトされた辞書エントリ */
                      (connect_flg != NO || (bnst_num == 1 && kan_ck_vector (hinsidt, getfzkoh1 (ichbnpbp, ii)->vector) == WNN_CONNECT_BK)))
                    {

                      if (bnst_num == 1)
                        /* endvect に接続できないものは評価値を下げる */
                        hyokaval0 = (connect_flg != NO) ? hyokaval : _DIVID (hyokaval, 2);
                      else if (parent != NULL)
                        {
                          /* 前の文節が endvect に接続できないものは、
                             評価値を下げる */
                          struct JKT_SONE *tmp;
                          hyokaval0 = _DIVID (hyokaval, 2);
                          for (tmp = parent->sbn; tmp != NULL; tmp = tmp->lnk_br)
                            {
                              if (tmp->status_bkwd == YES)
                                {
                                  /* 実は接続できた */
                                  hyokaval0 = hyokaval;
                                  break;
                                }
                            }
                        }
                      else
                        hyokaval0 = hyokaval;

                      if ((jktsone = getjktsone ()) == NO)
                        return (-1);    /* ERROR */
                      jktsone->i_jc = i;
                      jktsone->v_jc = hyokaval0;
                      jktsone->jentptr = jentptr;
                      jktsone->t_jc = t;
                      jktsone->hinsi_fk = hinsidt_fk;
                      jktsone->status_bkwd = connect_flg;
                      if ((jktsbn = find_jktsbn (jktsbn_top, jktsone, hinsidt, yomi_eno - 1)) < (struct JKT_SBN *) 0)
                        return (-1);
                      if (jktsbn != NULL)
                        {
                          jktsbn->parent = parent;
                          jktsbn->bend_m = yomi_sno;
                          jktsbn->kbcnt = bnst_num;
                          jktcnt++;
                        }
                    }           /* 接続できる */
                }               /* 単純品詞 */
            }                   /* 幹語 */
        }                       /* 辞書 */
#if     !defined(NO_KANA) && !defined(KOREAN)
      /* カタカナ候補 */
      if ((jktsbn = get_kata_kouho (jktsbn_top, yomi_sno, yomi_eno, i, fzkptr->vector, getfzkoh1 (ichbnpbp, ii)->vector, ii)) < (struct JKT_SBN *) 0)
        return (-1);
      if (jktsbn != NULL)
        {
          jktsbn->parent = parent;
          jktsbn->bend_m = yomi_sno;
          jktsbn->kbcnt = bnst_num;
          jktcnt++;
        }
#endif /* !defined(NO_KANA) && !defined(KOREAN) */
    }                           /* 付属語 */
  return (jktcnt);
}

#if     !defined(NO_KANA) && !defined(KOREAN)
/* カタカナ候補 */
struct JKT_SBN *
get_kata_kouho (jktsbn_top, yomi_sno, yomi_eno, i_jc, vector, vector1, hyouka)
     struct JKT_SBN **jktsbn_top;
     int yomi_sno, yomi_eno, i_jc;
     int *vector;
     int *vector1;
     int hyouka;
{
  struct JKT_SONE *jktsone;
  int connect_flg;

  if (!isjhira (bun[i_jc]) && !BAR_CODE (bun[i_jc]) && (i_jc + 1 == yomi_eno || !isjhira (bun[i_jc + 1])))
    return (NULL);

  if (i_jc != yomi_eno && !(touten (bun[i_jc])) && !(kuten (bun[i_jc])))
    {
      if (kan_ck_vector (giji_no, vector) == WNN_CONNECT_BK)
        {
          connect_flg = WNN_CONNECT_BK;
        }
      else if (kan_ck_vector (giji_no, vector1) == WNN_NOT_CONNECT_BK)
        {
          return (NULL);
        }
      else
        {
          connect_flg = WNN_NOT_CONNECT_BK;
        }
      if ((jktsone = getjktsone ()) == NULL)
        return (NULL);
      jktsone->i_jc = i_jc;
      jktsone->jentptr = NULL;
      jktsone->t_jc = WNN_KATAKANA;     /* カタカナ */
      jktsone->v_jc = (yomi_eno - i_jc) * KATA_HYOUKA;
      jktsone->hinsi_fk = giji_no;
      jktsone->status_bkwd = connect_flg;
      return (find_jktsbn (jktsbn_top, jktsone, giji_no, yomi_eno - 1));
    }
  else
    {
      return (NULL);
    }
}
#endif /* !defined(NO_KANA) && !defined(KOREAN) */

struct JKT_SBN *
get_hira_kouho (jktsbn_top, yomi_sno, yomi_eno)
     struct JKT_SBN **jktsbn_top;
     int yomi_sno, yomi_eno;
{
  struct JKT_SONE *jktsone;

  if ((jktsone = getjktsone ()) == NULL)
    return ((struct JKT_SBN *) -1);
  jktsone->i_jc = yomi_sno;
  jktsone->jentptr = NULL;
  jktsone->t_jc = WNN_HIRAGANA; /* ひらがな候補 */
#ifdef KOREAN
  jktsone->hinsi_fk = katakanago_no;    /* Hangul */
#else
  jktsone->hinsi_fk = giji_no;
#endif
  jktsone->v_jc = (yomi_eno - yomi_sno) * HIRA_HYOUKA;
  jktsone->status_bkwd = WNN_NOT_CONNECT_BK;
  return (find_jktsbn (jktsbn_top, jktsone, giji_no, yomi_eno - 1));
}

static struct JKT_SBN *
find_jktsbn (jktsbn, jktsone, hinsi, j_c)
     struct JKT_SBN **jktsbn;
     struct JKT_SONE *jktsone;
     int hinsi;
     int j_c;
{
  register struct JKT_SBN *sbn;
  struct JKT_SBN *tsbn;
  register struct JKT_SONE *sone;
  int v_jc;
  int kangovect;

  kangovect = ft->kango_hinsi_area[hinsi];
  sbn = *jktsbn;
  if (sbn == NULL || sbn->j_c != j_c || sbn->kangovect > kangovect)
    {
      if ((sbn = getjktsbn ()) == NO)
        return ((struct JKT_SBN *) -1);
      sbn->lnk_br = *jktsbn;
      *jktsbn = sbn;
      sbn->j_c = j_c;
      sbn->sbn = jktsone;
      sbn->kangovect = kangovect;
      return (sbn);
    }
  while (sbn != NULL && sbn->j_c == j_c)
    {
      if (sbn->kangovect == kangovect)
        {
          /* 評価値で SORT */
          v_jc = jktsone->v_jc;
          sone = sbn->sbn;
          if (sone == NULL || sone->v_jc < v_jc)
            {
              sbn->sbn = jktsone;
              jktsone->lnk_br = sone;
              return NULL;
            }
          while (sone)
            {
              if (sone->lnk_br == NULL || sone->lnk_br->v_jc < v_jc)
                {
                  jktsone->lnk_br = sone->lnk_br;
                  sone->lnk_br = jktsone;
                  return NULL;
                }
              sone = sone->lnk_br;
            }
        }
      else if (sbn->lnk_br == NULL || sbn->lnk_br->j_c != j_c || sbn->lnk_br->kangovect > kangovect)
        {
          if ((tsbn = getjktsbn ()) == NO)
            return ((struct JKT_SBN *) -1);
          tsbn->lnk_br = sbn->lnk_br;
          sbn->lnk_br = tsbn;
          tsbn->sbn = jktsone;
          tsbn->kangovect = kangovect;
          tsbn->j_c = j_c;
          return (tsbn);
        }
      sbn = sbn->lnk_br;
    }
  return (NULL);
}

/**************************************************
 * jkt_get_syo : 次候補 all 取りだし 小文節
 **************************************************/
int
#ifdef  NO_FZK
jkt_get_syo (yomi_sno, yomi_eno, beginvect, endvect, endvect1, dsd_sbn)
#else
jkt_get_syo (yomi_sno, yomi_eno, beginvect, fzkchar, endvect, endvect1, dsd_sbn)
#endif                          /* NO_FZK */
     int yomi_sno;
     int yomi_eno;
     int beginvect;             /* 前端ベクタ(-1:文節先頭、-2:なんでも)品詞No. */
#ifndef NO_FZK
     w_char *fzkchar;
#endif /* NO_FZK */
     int endvect;               /* 終端ベクタ */
     int endvect1;              /* 終端ベクタ */
     struct DSD_SBN **dsd_sbn;
{
  struct DSD_SBN *d_sbn;
  struct JKT_SBN *tjktsbn = NULL;  /* 小文節解析結果 */
  register int cnt = 0;         /* 次候補数 */
  register struct JKT_SBN *jktsbn;
  struct JKT_SBN *next_sbn;
  register struct JKT_SONE *sone_p;
  int sbn_cnt;
  int divid;

  if (c_env->fzk_fid == -1)
    {
      wnn_errorno = WNN_FZK_FILE_NO_LOAD;
      return (-1);
    }

  ft = (struct FT *) files[c_env->fzk_fid].area;

  if (jkt_sbn (yomi_sno, yomi_eno, endvect, endvect1, &tjktsbn, 1, (struct JKT_SBN *) 0) < 0)
    {
      init_work_areas ();
      return (-1);
    }

  sbn_cnt = cnt_jkt_sbn (tjktsbn);
  if ((*dsd_sbn = d_sbn = get_dsd_sbn (sbn_cnt)) <= (struct DSD_SBN *) 0)
    {
      init_work_areas ();
      return (-1);
    }
  for (jktsbn = tjktsbn; jktsbn != NULL;)
    {
      next_sbn = jktsbn->lnk_br;
      for (sone_p = jktsbn->sbn; sone_p != NULL; sone_p = sone_p->lnk_br)
        {
          d_sbn->bun_m = jktsbn->bend_m;
          d_sbn->bun_jc = jktsbn->j_c;
          d_sbn->i_jc = sone_p->i_jc;
          d_sbn->jentptr = sone_p->jentptr;
          d_sbn->t_jc = sone_p->t_jc;
          d_sbn->hinsi = sone_p->hinsi_fk;
          d_sbn->kangovect = jktsbn->kangovect;
          d_sbn->status_bkwd = sone_p->status_bkwd;
          divid = get_jkt_status (jktsbn->kangovect, beginvect,
#ifndef NO_FZK
                                  fzkchar,
#endif /* NO_FZK */
                                  &(jktsbn->status));
          d_sbn->v_jc = DIVID_HYOUKA (sone_p->v_jc, divid);
          if (sone_p->jentptr == NULL && jktsbn->status == WNN_NOT_CONNECT)
            d_sbn->status = WNN_GIJI;
          else
            d_sbn->status = jktsbn->status;
          cnt++;
          d_sbn++;
        }
      freejktsbn (jktsbn);
      jktsbn = next_sbn;
    }
  qsort ((char *) *dsd_sbn, cnt, sizeof (struct DSD_SBN), cmp_dsd_sbn);
  return (cnt);
}

static int
cmp_dsd_sbn (sbn1, sbn2)
     struct DSD_SBN *sbn1;
     struct DSD_SBN *sbn2;
{
  return (sbn2->v_jc - sbn1->v_jc);
}

static int
cnt_jkt_sbn (sbn)
     register struct JKT_SBN *sbn;
{
  register int cnt;
  cnt = 0;
  while (sbn)
    {
      cnt += cnt_sone (sbn->sbn);
      sbn = sbn->lnk_br;
    }
  return (cnt);
}

int
get_zen_giji (giji_sbn, jktsbn)
     struct SYO_BNSETSU *giji_sbn;
     struct JKT_SBN **jktsbn;
{
  int hinsi;
  hinsi = giji_sbn->hinsi_fk;

  if ((*jktsbn = getjktsbn ()) == NULL)
    return (-1);
  if (((*jktsbn)->sbn = getjktsone ()) == NULL)
    return (-1);

  (*jktsbn)->j_c = giji_sbn->j_c;
  (*jktsbn)->bend_m = giji_sbn->bend_m;
  (*jktsbn)->kangovect = giji_sbn->kangovect;
  (*jktsbn)->sbn->i_jc = giji_sbn->i_jc;
  (*jktsbn)->sbn->v_jc = giji_sbn->v_jc;
  (*jktsbn)->sbn->jentptr = NULL;
  (*jktsbn)->sbn->t_jc = giji_sbn->t_jc;
  (*jktsbn)->sbn->hinsi_fk = giji_sbn->hinsi_fk;
  (*jktsbn)->sbn->status_bkwd = giji_sbn->status_bkwd;

  if ((*jktsbn)->sbn->hinsi_fk == fuzokugo_no)
    return (1);
  if (hinsi == suuji_no)
    return (get_suuji_kouho (*jktsbn));
  if (isascii (bun[(*jktsbn)->sbn->i_jc]))
    {
      if (hinsi == eisuu_no)
        return (get_eisuu_kouho (*jktsbn));
      else
        return (get_kigou_kouho (*jktsbn));
    }
  else
    {
      return (1);
    }
}

static struct JKT_SONE *
cp_sone (d_sone, s_sone)
     register struct JKT_SONE *d_sone, *s_sone;
{
  if ((d_sone->lnk_br = getjktsone ()) == NO)
    return ((struct JKT_SONE *) -1);
  d_sone = d_sone->lnk_br;
  d_sone->i_jc = s_sone->i_jc;
  d_sone->v_jc = s_sone->v_jc - 10;     /* 第1候補より評価値を下げる */
  d_sone->jentptr = NULL;
  d_sone->hinsi_fk = s_sone->hinsi_fk;
  d_sone->status_bkwd = s_sone->status_bkwd;
  return (d_sone);
}

/* 半角数字 */
static int
get_suuji_kouho (jktsbn)
     register struct JKT_SBN *jktsbn;
{
  register struct JKT_SONE *jktsone;
  int hinsi;
  int len;

  hinsi = jktsbn->sbn->t_jc;
  len = jktsbn->j_c - jktsbn->sbn->i_jc;
  if (isspace (bun[jktsbn->j_c]) || isjspace (bun[jktsbn->j_c]))
    len--;

  if ((jktsone = cp_sone (jktsbn->sbn, jktsbn->sbn)) < (struct JKT_SONE *) 0)
    return (-1);

  if (hinsi != WNN_NUM_HAN)
    {
      jktsone->t_jc = WNN_NUM_HAN;      /* 半角数字 */
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  if (hinsi != WNN_NUM_ZEN)
    {
      jktsone->t_jc = WNN_NUM_ZEN;      /* １２３ */
      if (len < 0 && hinsi == WNN_NUM_KAN)
        return (3);
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  if (hinsi != WNN_NUM_KAN)
    {
      jktsone->t_jc = WNN_NUM_KAN;      /* 一二三 */
      if (len < 0)
        return (3);
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  if (hinsi != WNN_NUM_KANSUUJI)
    {
      jktsone->t_jc = WNN_NUM_KANSUUJI; /* 百二十三 */
      if (len < 3 && hinsi == WNN_NUM_KANOLD)
        return (5);
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  if (hinsi != WNN_NUM_KANOLD)
    {
      jktsone->t_jc = WNN_NUM_KANOLD;   /* 壱百弐拾参 */
      jktsone->v_jc -= 2;       /* 評価値をちょっと下げる */
      if (len < 3)
        return (5);
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  if (hinsi != WNN_NUM_ZENCAN)
    {
      jktsone->t_jc = WNN_NUM_ZENCAN;   /* １，２３４ */
      if (hinsi == WNN_NUM_HANCAN)
        return (7);
      if ((jktsone = cp_sone (jktsone, jktsbn->sbn)) < (struct JKT_SONE *) 0)
        return (-1);
    }
  jktsone->t_jc = WNN_NUM_HANCAN;       /* 1,234 */
  return (7);
}

static int
get_eisuu_kouho (jktsbn)
     struct JKT_SBN *jktsbn;
{
  struct JKT_SONE *jktsone;
  if ((jktsone = cp_sone (jktsbn->sbn, jktsbn->sbn)) < (struct JKT_SONE *) 0)
    return (-1);

  if (jktsbn->sbn->t_jc == WNN_ALP_ZEN)
    jktsone->t_jc = WNN_ALP_HAN;
  else
    jktsone->t_jc = WNN_ALP_ZEN;
  return (2);
}

static int
get_kigou_kouho (jktsbn)
     struct JKT_SBN *jktsbn;
{
  struct JKT_SONE *jktsone;
  if ((jktsone = cp_sone (jktsbn->sbn, jktsbn->sbn)) < (struct JKT_SONE *) 0)
    return (-1);

  if (jktsbn->sbn->t_jc == WNN_KIG_JIS)
    jktsone->t_jc = WNN_KIG_HAN;
  else
    jktsone->t_jc = WNN_KIG_JIS;
  return (2);
}