~ubuntu-branches/ubuntu/precise/cuneiform/precise

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rstr/src/contools.c

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk
  • Date: 2010-09-14 15:53:54 UTC
  • mto: (5.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20100914155354-i3uu2woc5aucphax
Tags: upstream-1.0.0+dfsg
Import upstream version 1.0.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
4
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
5
Разрешается повторное распространение и использование как в виде исходного кода,
 
6
так и в двоичной форме, с изменениями или без, при соблюдении следующих условий:
 
7
 
 
8
      * При повторном распространении исходного кода должны оставаться указанное
 
9
        выше уведомление об авторском праве, этот список условий и последующий
 
10
        отказ от гарантий.
 
11
      * При повторном распространении двоичного кода в документации и/или в
 
12
        других материалах, поставляемых при распространении, должны сохраняться
 
13
        указанная выше информация об авторском праве, этот список условий и
 
14
        последующий отказ от гарантий.
 
15
      * Ни название Cognitive Technologies, ни имена ее сотрудников не могут
 
16
        быть использованы в качестве средства поддержки и/или продвижения
 
17
        продуктов, основанных на этом ПО, без предварительного письменного
 
18
        разрешения.
 
19
 
 
20
ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ ДРУГИМИ ЛИЦАМИ "КАК
 
21
ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ,
 
22
ВКЛЮЧАЯ ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ, НО НЕ
 
23
ОГРАНИЧИВАЯСЬ ИМИ. НИ ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
 
24
МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, НИ В КОЕМ СЛУЧАЕ НЕ
 
25
НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ ИЛИ
 
26
ПОСЛЕДОВАВШИЕ УБЫТКИ, СВЯЗАННЫЕ С ИСПОЛЬЗОВАНИЕМ ИЛИ ПОНЕСЕННЫЕ ВСЛЕДСТВИЕ
 
27
НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ ПОТЕРИ ДАННЫХ, ИЛИ ДАННЫЕ,
 
28
СТАВШИЕ НЕГОДНЫМИ, ИЛИ УБЫТКИ И/ИЛИ ПОТЕРИ ДОХОДОВ, ПОНЕСЕННЫЕ ИЗ-ЗА ДЕЙСТВИЙ
 
29
ТРЕТЬИХ ЛИЦ И/ИЛИ ОТКАЗА ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ,
 
30
НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМИ СЛУЧАЯМИ), НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ДАЖЕ ЕСЛИ ТАКОЙ
 
31
ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
32
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
61
61
#include "lang.h"
62
62
 
63
63
 
64
 
static INT LiliI                (cell *);
65
 
static INT bon_to_dig           (cell *);
66
 
static BOOL apostr_ll           (cell *);
67
 
static void inc_or_dec_slash    (cell *wc, INT numv);
68
 
extern BYTE langUkr;
69
 
extern BYTE langSer;
 
64
static int16_t LiliI                (cell *);
 
65
static int16_t bon_to_dig           (cell *);
 
66
static Bool apostr_ll           (cell *);
 
67
static void inc_or_dec_slash    (cell *wc, int16_t numv);
 
68
extern uchar langUkr;
 
69
extern uchar langSer;
70
70
 
71
 
INT check_numb_2_9 (BYTE c)
 
71
int16_t check_numb_2_9 (uchar c)
72
72
//
73
73
//      This procedure checks symbol to be number.
74
74
//      Number means >=2 and <=9 since 0 and 1 could be confused.
79
79
                   return FALSE;
80
80
 }
81
81
 
82
 
 INT check_numb_0_9(BYTE c)
 
82
 int16_t check_numb_0_9(uchar c)
83
83
//
84
84
//      This procedure checks symbol to be number.
85
85
//
91
91
                               return 0;
92
92
 }
93
93
 
94
 
 INT check_upper(BYTE c)
 
94
 int16_t check_upper(uchar c)
95
95
//
96
96
//  This procedure checks symbol to be capital letter,
97
97
//      that means A-Z.
424
424
        return FALSE;
425
425
 }
426
426
 
427
 
 INT check_lower(BYTE c)
 
427
 int16_t check_lower(uchar c)
428
428
//
429
429
//  This procedure checks symbol to be lower case letter,
430
430
//      that means a-z.
769
769
 return FALSE;
770
770
 }
771
771
 
772
 
 INT check_foreign_language_ligature(BYTE c)
 
772
 int16_t check_foreign_language_ligature(uchar c)
773
773
//
774
774
//  This procedure checks symbol to be foreign language ligature.
775
775
//
827
827
                   return FALSE;
828
828
 }
829
829
 
830
 
INT check_foreign_language_ligature_slavic(BYTE c)
 
830
int16_t check_foreign_language_ligature_slavic(uchar c)
831
831
//
832
832
//  This procedure checks symbol to be foreign lahguage ligature.
833
833
//
869
869
                   return FALSE;
870
870
 }
871
871
 
872
 
 INT check_alphanum(BYTE c)
 
872
 int16_t check_alphanum(uchar c)
873
873
//
874
874
//      This procedure checks symbol to be letter or number.
875
875
//      that means 0-9, A-Z, a-z, $.
880
880
 if (c == '$')                 return 1;
881
881
 if (c == '%')                 return 1;
882
882
 
883
 
  // ������ ����� ��� ������� ��� ���� ������ // 07.09.2000 E.P.
 
883
  // Теперь макры лиг годятся для всех языков // 07.09.2000 E.P.
884
884
 if ( ( c == liga_qm ) || ( c == liga_exm ) ||
885
885
      ( c == liga_inv_qm )||
886
886
      ( c == liga_inv_exm )
887
887
         )
888
888
    return FALSE;
889
889
 
890
 
 // ��������� ���� // 07.09.2000 E.P.
 
890
 // Остальные лиги // 07.09.2000 E.P.
891
891
 if (is_liga(c))
892
892
         return 1;
893
893
 
945
945
 return 0;
946
946
}
947
947
 
948
 
 INT check_lowerconson(BYTE c)
 
948
 int16_t check_lowerconson(uchar c)
949
949
//
950
950
//      This procedure checks symbol to be lowercase consonant,
951
951
//      that means b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,y,z.
1065
1065
 
1066
1066
}
1067
1067
 
1068
 
void test_irish_name_cur_sym( INT Let )
 
1068
void test_irish_name_cur_sym( int16_t Let )
1069
1069
{
1070
1070
    switch ( fl_beg_irish_name )
1071
1071
    {
1087
1087
        break;
1088
1088
 
1089
1089
      case LOWER_C  :
1090
 
        if ( check_upper( (BYTE)Let )  )
 
1090
        if ( check_upper( (uchar)Let )  )
1091
1091
          fl_beg_irish_name = AFTER_C;
1092
1092
        else
1093
1093
          fl_beg_irish_name = NO_IRISH_NAME;
1106
1106
 void test_O_and_slash()
1107
1107
{
1108
1108
cell *C;
1109
 
INT nv;
 
1109
int16_t nv;
1110
1110
 
1111
1111
 C = cell_f();
1112
1112
 while ((C=C->nextl)->nextl)
1129
1129
    // Oleg : 06-09-1994 : not exist '698' - bonus 0
1130
1130
   else
1131
1131
    { // Oleg : 06-09-1994 : exist any '698'-version
1132
 
    nv=get_nvers(C,'�');
 
1132
    nv=get_nvers(C,'Ћ');
1133
1133
    if( nv>=0 )
1134
1134
      cell_bonus(C, &(C->vers[nv]), -2);            // monus O
1135
1135
    }
1146
1146
 }
1147
1147
}
1148
1148
 
1149
 
static void inc_or_dec_slash(cell *wc, INT numv)
 
1149
static void inc_or_dec_slash(cell *wc, int16_t numv)
1150
1150
//
1151
1151
//  This procedure decreases probability '/' if its neighbour letters are
1152
1152
//   italic ( to prefer 'l' or 'I' ) and
1155
1155
//
1156
1156
 {
1157
1157
 cell  *cprev, *cnext;
1158
 
 BOOL   no_Il = (get_nvers(wc, 'I')==-1) && (get_nvers(wc, 'l')==-1 && wc->vers[numv].let=='/');
 
1158
 Bool   no_Il = (get_nvers(wc, 'I')==-1) && (get_nvers(wc, 'l')==-1 && wc->vers[numv].let=='/');
1159
1159
 
1160
1160
  if ( wc->vers[0].prob - wc->vers[numv].prob > REFUSE_BOUND )
1161
1161
   return;
1163
1163
  cnext = wc->next;
1164
1164
  if ( !((cprev->flg & c_f_let) && (cnext->flg & c_f_let)) ) return;
1165
1165
  if ( ((cprev->font|cprev->font_new) & c_fp_it) && ((cnext->font|cnext->font_new) & c_fp_it) )
1166
 
   { cell_bonus(wc, &(wc->vers[numv]), (INT)(no_Il?2:-BONUS_SLASH)); goto IDS_Sort; }
 
1166
   { cell_bonus(wc, &(wc->vers[numv]), (int16_t)(no_Il?2:-BONUS_SLASH)); goto IDS_Sort; }
1167
1167
  if ( ((cprev->font|cprev->font_new) & c_fp_str) && ((cnext->font|cnext->font_new) & c_fp_str) )
1168
 
    cell_bonus(wc, &(wc->vers[numv]), (INT)(no_Il?2:BONUS_SLASH));
 
1168
    cell_bonus(wc, &(wc->vers[numv]), (int16_t)(no_Il?2:BONUS_SLASH));
1169
1169
IDS_Sort:
1170
1170
  sort_vers(wc);
1171
1171
 }
1172
1172
 
1173
 
INT english_context_process( cell* C )
 
1173
int16_t english_context_process( cell* C )
1174
1174
{
1175
 
INT return_code, nv;
 
1175
int16_t return_code, nv;
1176
1176
 
1177
1177
  return_code = NO_ACTION;
1178
1178
 
1220
1220
    return  return_code;
1221
1221
}
1222
1222
 
1223
 
static INT LiliI(cell *NC)
 
1223
static int16_t LiliI(cell *NC)
1224
1224
//
1225
1225
//      This procedure gives bonus to 'I' in one letter word.
1226
1226
//
1227
1227
 {
1228
 
 INT i;
 
1228
 int16_t i;
1229
1229
 version *v;
1230
1230
 
1231
1231
 bon_to_dig(NC);                    // monus to non- "1"
1247
1247
 return 1;
1248
1248
 }
1249
1249
 
1250
 
static INT bon_to_dig(cell *NC)
 
1250
static int16_t bon_to_dig(cell *NC)
1251
1251
//
1252
1252
//      This procedure gives bonus to digits in one letter word.
1253
1253
//
1254
1254
 {
1255
 
 INT i;
 
1255
 int16_t i;
1256
1256
 version *v;
1257
1257
 
1258
1258
 for (i=0,v=NC->vers; i < NC->nvers; i++,v++)
1267
1267
 return 1;
1268
1268
 }
1269
1269
 
1270
 
static BOOL apostr_ll(cell *NC)
 
1270
static Bool apostr_ll(cell *NC)
1271
1271
//
1272
1272
//      This procedure gives bonus to ll in two letters word
1273
1273
//      if there is after apostrophe. Example: he'll
1274
1274
//      ON ENTRY: NC - address of cell for first letter.
1275
1275
//
1276
1276
{
1277
 
 INT i;
 
1277
 int16_t i;
1278
1278
 version *v;
1279
1279
 
1280
1280
 for (i=0,v=NC->vers; i < NC->nvers; i++,v++)
1304
1304
 return TRUE;
1305
1305
}
1306
1306
 
1307
 
INT franch_context_process( cell* C )
 
1307
int16_t franch_context_process( cell* C )
1308
1308
{
1309
 
INT return_code;
1310
 
INT i, nvI, nvl, nvs;
 
1309
int16_t return_code;
 
1310
int16_t i, nvI, nvl, nvs;
1311
1311
 
1312
1312
  return_code = NO_ACTION;
1313
1313
 
1377
1377
  return return_code;
1378
1378
}
1379
1379
 
1380
 
INT german_context_process( cell* C )
 
1380
int16_t german_context_process( cell* C )
1381
1381
{
1382
 
INT return_code;
 
1382
int16_t return_code;
1383
1383
cell * wc;
1384
 
BYTE i, wp;
1385
 
INT  nv_c, nv_h, nv_b;
 
1384
uchar i, wp;
 
1385
int16_t  nv_c, nv_h, nv_b;
1386
1386
 
1387
1387
    return_code = NO_ACTION;
1388
1388
 
1427
1427
    return return_code;
1428
1428
}
1429
1429
 
1430
 
INT swedish_context_process     ( cell* C )
 
1430
int16_t swedish_context_process     ( cell* C )
1431
1431
{
1432
 
INT return_code;
 
1432
int16_t return_code;
1433
1433
 
1434
1434
    swed_lju_flag = FALSE;
1435
1435
    return_code = NO_ACTION;
1442
1442
    }
1443
1443
    if ( n_ltr > 2 )        // Process 'lju' at start of word
1444
1444
    {
1445
 
      INT nv_l, nv_j, nv_u;
 
1445
      int16_t nv_l, nv_j, nv_u;
1446
1446
 
1447
1447
      nv_l = get_nvers( C, 'l');
1448
1448
      if ( nv_l < 0 ) goto SwCP_Ret;
1468
1468
    return return_code;
1469
1469
}
1470
1470
 
1471
 
INT spanish_context_process     ( cell* C )
 
1471
int16_t spanish_context_process     ( cell* C )
1472
1472
{
1473
 
INT return_code;
 
1473
int16_t return_code;
1474
1474
 
1475
1475
    return_code = NO_ACTION;
1476
1476
    if ( n_ltr > 2 )
1483
1483
    return return_code;
1484
1484
}
1485
1485
 
1486
 
INT get_nvers ( cell *A, INT Let )
 
1486
int16_t get_nvers ( cell *A, int16_t Let )
1487
1487
{
1488
 
INT n;
 
1488
int16_t n;
1489
1489
  for ( n = 0; n < A->nvers; n++)
1490
1490
   {
1491
1491
    if (  A->vers[n].let == Let )
1494
1494
  return -1;
1495
1495
}
1496
1496
 
1497
 
void vers_to_first_place ( cell *A, INT nver)
 
1497
void vers_to_first_place ( cell *A, int16_t nver)
1498
1498
{
1499
1499
version *v, wver;
1500
1500
 v = A->vers;