← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk, c-assert.diff, slovenian-slv.diff
  • Date: 2011-01-26 21:53:07 UTC
  • mfrom: (5.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110126215307-62x61mcesr607qb7
Tags: 1.0.0+dfsg-2
http://bugs.debian.org/608345
http://bugs.debian.org/572061
http://bugs.debian.org/602512
* Upload to unstable.
* Explicitly build-depend on pkg-config. Thanks to Stefano Rivera for the
  bug report.
* Add Vcs-* fields.
* Use the standard C assert() macro, rather than custom Cuneiform one.
  [c-assert.diff]
* Pass CFLAGS, CXXFLAGS and LDFLAGS (get from dpkg-buildflags) to cmake
  (closes: #608345). Thanks to Sami Liedes for the bug report.
  + Build depend on dpkg-dev (>= 1.15.7).
* Pass --parallel to dh.
  + Bump debhelper minimum version to 7.4.10.
* Update debian/copyright to the latest DEP-5 version.
* Bump year in debian/copyright.
* Explicitly link to GraphicsMagick (rather than via the ImageMagick
  compatibility layer).
* Don't ship /usr/lib/cuneiform/*.so symlinks. These libraries are
  considered private, at least until #598616 is fixed.
* Rename some private variables in debian/rules to make them lowercase.
* Update patch headers.
* Provide proper ‘build-arch’ and ‘build-indep’ targets in debian/rules.
* Document input format in the manual page (closes: #572061). Thanks to
  Janusz S. Bień for the bug report.
* Use ‘slv’ (rather than ‘slo’) as language code for Slovenian.
  [slovenian-slv.diff]
* Fix package description: Slovenian is supported, Slovak is not.
* Improve documentation of the language (-l) option (closes: #602512).
  Thanks to Jari Aalto for the bug report.
* Install reasons file for vrms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rstr/src/tools.c
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:
58
58
#include <stdio.h>
59
59
#include <stdlib.h>
60
60
#include <string.h>
61
 
#include "nt_types.h"
 
61
 
62
62
#include "struct.h"
63
63
#include "status.h"
64
64
#include "func.h"
69
69
#include "p2libr.h"
70
70
#include "ccomdefs.h"
71
71
 
72
 
LONG  EVNRecog_lp(/*c_comp*/CCOM_comp *ec, BYTE * lp, INT lth, BYTE *res    );
73
 
extern BYTE db_status;  // snap presence byte
74
 
extern BYTE db_trace_flag;  // 2 - more detailed estimate (ALT-F7)
75
 
extern CHAR db_pass;
76
 
extern INT nIncline;
 
72
int32_t  EVNRecog_lp(/*c_comp*/CCOM_comp *ec, uchar * lp, int16_t lth, uchar *res    );
 
73
extern uchar db_status; // snap presence byte
 
74
extern uchar db_trace_flag;  // 2 - more detailed estimate (ALT-F7)
 
75
extern char db_pass;
 
76
extern int16_t nIncline;
77
77
extern void ErrorExit(int Code);
78
78
//#define NUMBER_OF_CELLS (0x30000/sizeof (cell))
79
 
extern PBYTE ED_file_bound,ED_file_end/* memory_pool_end*/;
80
 
static PBYTE kit_start, kit_curr;
 
79
extern puchar ED_file_bound,ED_file_end/* memory_pool_end*/;
 
80
static puchar kit_start, kit_curr;
81
81
 
82
82
static cell first_cell, last_cell;
83
83
static cell * empty_cell, * free_cell_chain, * cell_boundary;
84
84
extern c_comp wcomp;
85
85
extern version * start_rec, * rec_ptr;
86
 
extern INT lpool_lth;
87
 
extern BYTE lpool[];
 
86
extern int16_t lpool_lth;
 
87
extern uchar lpool[];
88
88
 
89
 
static PBYTE save_kit(PBYTE c, INT l);
90
 
static void rest_kit(PBYTE s, PBYTE k);
91
 
static INT second_recog(cell *c);
92
 
static INT vers_to_cell(cell *c);
93
 
static PBYTE comp_to_kit(MN * mn);
 
89
static puchar save_kit(puchar c, int16_t l);
 
90
static void rest_kit(puchar s, puchar k);
 
91
static int16_t second_recog(cell *c);
 
92
static int16_t vers_to_cell(cell *c);
 
93
static puchar comp_to_kit(MN * mn);
94
94
static void comp_from_kit(cell *c);
95
95
 
96
 
static BYTE il1_pool[8192]={0}; // 19.07.2001 E.P.
 
96
static uchar il1_pool[8192]={0};        // 19.07.2001 E.P.
97
97
 
98
 
CHAR deb_messages[]="Virtal shape set\0Skeleton match got\0"
 
98
char deb_messages[]="Virtal shape set\0Skeleton match got\0"
99
99
                                "Create scaled shape\0"
100
100
                                "Vectorization in progress\0"
101
101
                                "Pattern matching: est = %d\0"
109
109
                                "Tilting done\0"
110
110
                                "Shape oscilation: %d\0"
111
111
                                "Phase shift found\0";
112
 
extern BYTE work_raster_1[];
 
112
extern uchar work_raster_1[];
113
113
 
114
114
 
115
115
/*======================= Memory management ===========================*/
116
 
PBYTE il1_pool_ptr() { return il1_pool; }
117
 
PBYTE t_raster() { return work_raster_1; }
 
116
puchar il1_pool_ptr() { return il1_pool; }
 
117
puchar t_raster() { return work_raster_1; }
118
118
 
119
119
/*====================== Cell internal actions =======================*/
120
120
 
122
122
cell * cell_l() { return & last_cell; }
123
123
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
124
124
//AK debug
125
 
// ��������� ������� � �������� �� ���������
 
125
// Проверяем цепочку и пытаемся ее поправить
126
126
void AKCheckChain()
127
127
{
128
128
        cell * ForwardChain;
133
133
        cell * LossCell;
134
134
        cell * Cicle;
135
135
 
136
 
        // ��������� ������� ������
 
136
        // проверяем цепочку вперед
137
137
        for ( Back = cell_f(), ForwardChain = cell_f()->next;
138
138
              ForwardChain != cell_l() && ForwardChain->next != NULL;
139
139
                  ForwardChain = ForwardChain->next )
140
140
        {
141
 
                // ��������� �� �������������
 
141
                // проверяем на зацикленность
142
142
                for ( Cicle = cell_f();
143
143
                      Cicle != ForwardChain;
144
144
                          Cicle = Cicle->next )
145
145
                        if (ForwardChain->next == Cicle)
146
 
                        {       //���� �������������...
 
146
                        {       //если зацикливается...
147
147
                                ForwardChain = NULL;
148
148
                                break;
149
149
                        }
150
 
                // �������� �������� �����
 
150
                // проверка обратной связи
151
151
                if ( ForwardChain->prev != Back )
152
152
                {
153
153
                        LossCell = ForwardChain->prev;
157
157
                Back = ForwardChain;
158
158
        }
159
159
 
160
 
        // ���� ������ �� �����...
 
160
        // если прошли до конца...
161
161
        if ( ForwardChain == cell_l() )
162
162
                return;
163
 
        // ��� �� ������...
 
163
        // или не прошли...
164
164
        if ( ForwardChain->prev != Back )
165
165
                ForwardChain->prev = Back;
166
166
 
167
 
        // ��������� ������� ������
 
167
        // проверяем цепочку надзад
168
168
        for ( Back = cell_l(), BackwardChain = cell_l()->prev;
169
169
              BackwardChain != cell_f() && BackwardChain->prev != NULL;
170
170
                  BackwardChain = BackwardChain->prev )
171
171
        {
172
 
                // �������� �������� �����
 
172
                // проверка обратной связи
173
173
                if ( BackwardChain->next != Back )
174
174
                {
175
 
                        // �������, ���� ���� ��������
 
175
                        // смотрим, куда идет апендикс
176
176
                        for ( BackTwo = BackwardChain, Appendix = BackwardChain->next;
177
177
                              Appendix != cell_l() && Appendix->next != NULL;
178
178
                                  Appendix = Appendix->next )
183
183
                                        Appendix->prev = BackTwo;
184
184
                                }
185
185
                        }
186
 
                        // ���� �� ��������� ����� �� ������ �� ������, �� ���������
 
186
                        // если по апендиксу дошли до обрыва от начала, то соединяем
187
187
                        if ( Appendix == ForwardChain )
188
188
                        {
189
189
                                ForwardChain->next = Back;
190
190
                                Back->prev = ForwardChain;
191
191
                                return;
192
192
                        }
193
 
                        // ���� ����� ��������� �� ����� �� ������...
 
193
                        // если конец апендикса не обрыв от начала...
194
194
                        if ( Appendix != cell_l() )
195
195
                        {
196
196
                                Appendix->next = Back;
198
198
                                BackwardChain = Back;
199
199
                        }
200
200
                }
201
 
                // ��������� �� ���������� next
 
201
                // проверяем на потерянный next
202
202
                if ( BackwardChain->prev == ForwardChain )
203
203
                {
204
204
                        ForwardChain->next = BackwardChain;
207
207
                Back = BackwardChain;
208
208
        }
209
209
 
210
 
        // ���� �� ������ �� ������...
 
210
        // Если не прошли до начала...
211
211
        if ( BackwardChain != cell_f() )
212
212
        {
213
213
                ForwardChain->next = BackwardChain;
215
215
                return;
216
216
        }
217
217
 
218
 
        // ���� ����� ������ �� ������, � ������ ������ �� ������,
219
 
        // �� ���� ��������� �� ������, ������������ ��� � ������
220
 
        // (�� ������ ������ ��������, ������� �� �������� �����
 
218
        // Если назад прошли до начала, а вперед только до обрыва,
 
219
        // то есть аппендикс от начала, пристраеваем его в начало
 
220
        // (на всякий случай проверим, остался ли апендикс целым
221
221
        if ( BackwardChain == cell_f()  && ForwardChain != cell_l() )
222
222
        {
223
223
                ForwardChain->next = Back;
225
225
        }
226
226
}
227
227
////////////////////////////////////////////////////////////////////////////////////////////////////////////
228
 
// �������. ���� �� ����� cell � �������
229
 
INT AKCellInChain(cell * Cell)
 
228
// смотрим. есть ли такой cell в цепочке
 
229
int16_t AKCellInChain(cell * Cell)
230
230
{
231
231
        cell * Count;
232
232
 
233
 
        // ��������� ������� �� ������ ������������ ��� ������
 
233
        // проверяем цепочку на случай зацикливания или обрыва
234
234
        AKCheckChain();
235
235
 
236
236
        for (Count = cell_f(); Count != cell_l(); Count=Count->next)
249
249
void AKTryChainRecover( cell ** c )
250
250
{
251
251
        AKCheckChain();
252
 
        // ���� ������ ������� �� �������� ����������,
253
 
        // ���������, ��������� �� c � �������
 
252
        // если правка цепочки не принесла результата,
 
253
        // проверяем, находится ли c в цепочке
254
254
        if ( (*c)->next == NULL )
255
255
        {
256
 
                // ���� ���, ��������� ��������� � ����������, ����� � ������
 
256
                // если нет, попробуем вернуться к предыдущей, иначе к началу
257
257
                if ( !AKCellInChain(*c) )
258
258
                {
259
259
                        if ( AKCellInChain((*c)->prev) )
270
270
{
271
271
        cell * Count;
272
272
        char   Let;
273
 
        //BYTE   Prob;
 
273
        //uchar   Prob;
274
274
        int    i;
275
275
 
276
 
        // ��������� ������� �� ������ ������������ ��� ������
 
276
        // проверяем цепочку на случай зацикливания или обрыва
277
277
        AKCheckChain();
278
278
 
279
279
        for (Count = cell_f()->next; Count != cell_l(); Count=Count->next)
283
283
                        Let = Count->vers[i].let;
284
284
 
285
285
                        if ( !proplet(Let) /*&& Let != bad_char*/ )
286
 
                        { // ���� ������ �� �� ����
 
286
                        { // если символ не от сюда
287
287
                                Count->vers[i].let  = 0;                 //bad_char;
288
288
                                Count->vers[i].prob = 0;
289
289
                        }
312
312
 if (c->flg & (c_f_let+c_f_bad)) c->flg=c_f_bad;
313
313
 }
314
314
 
315
 
void sort_v_vect(INT n, version *v0)
 
315
void sort_v_vect(int16_t n, version *v0)
316
316
 {
317
317
 version *v,*vs,*vm;
318
 
 BYTE l;
 
318
 uchar l;
319
319
 
320
320
 for (vs=v0+1,vm=v0+n; vs<vm; vs++)
321
321
  for (v=vs; v>v0 && (v-1)->prob<v->prob; v--)
332
332
void sort_vers(cell *c)
333
333
 {
334
334
 version *v,*vs,*vm;
335
 
 BYTE l;
 
335
 uchar l;
336
336
 
337
337
 if (c->nvers <= 0)  {set_bad_cell(c); return; }
338
338
 for (vs=c->vers+1,vm=c->vers+c->nvers; vs<vm; vs++)
351
351
 
352
352
#define MAX_PROB 254
353
353
 
354
 
void cell_bonus(cell *C, version *pVer, INT BonVal)
 
354
void cell_bonus(cell *C, version *pVer, int16_t BonVal)
355
355
{
356
 
INT resp;
 
356
int16_t resp;
357
357
version *pv;
358
 
INT wp,wp1;
 
358
int16_t wp,wp1;
359
359
 
360
360
 if (pVer->prob != 0)
361
361
  {
371
371
       if ((wp1=(pv->prob - wp)) < 0)
372
372
        pv->prob = 2;
373
373
       else
374
 
        pv->prob = (BYTE)wp1;
 
374
        pv->prob = (uchar)wp1;
375
375
      }
376
376
     pVer->prob = MAX_PROB;
377
377
    }
378
 
   else pVer->prob = (BYTE)resp;
 
378
   else pVer->prob = (uchar)resp;
379
379
  }
380
380
}
381
381
 
382
 
void cell_bonus_let(cell *C, CHAR Let, INT BonVal)
 
382
void cell_bonus_let(cell *C, char Let, int16_t BonVal)
383
383
{
384
384
version *pv;
385
385
 for (pv=C->vers; pv->let != 0 ; pv++)
389
389
  }
390
390
}
391
391
/*=================== Start of string processing ======================*/
392
 
extern BYTE *CellsPage_rstr, *CellsPageEnd_rstr;
 
392
extern uchar *CellsPage_rstr, *CellsPageEnd_rstr;
393
393
void setup_string()
394
394
{
395
 
LONG    number_of_cells=((LONG)CellsPageEnd_rstr-(LONG)CellsPage_rstr)/sizeof (cell);
 
395
int32_t    number_of_cells=((int32_t)CellsPageEnd_rstr-(int32_t)CellsPage_rstr)/sizeof (cell);
396
396
 empty_cell=(cell *) (CellsPage_rstr);
397
397
 cell_boundary = empty_cell + number_of_cells;//NUMBER_OF_CELLS;
398
398
 free_cell_chain=NULL;
406
406
void kit_init() {
407
407
  kit_start = kit_curr = ED_file_bound; }
408
408
 
409
 
PBYTE give_kit_addr() { return kit_curr; }
 
409
puchar give_kit_addr() { return kit_curr; }
410
410
 
411
 
void take_kit_addr(PBYTE a)
 
411
void take_kit_addr(puchar a)
412
412
         { kit_curr = a;
413
413
         }
414
414
 
461
461
/////////////////////////////////////////////////////////////////////////////////////////
462
462
//======================= Kit function ===============================
463
463
 
464
 
static PBYTE save_kit(PBYTE c, INT l)
 
464
static puchar save_kit(puchar c, int16_t l)
465
465
{
466
 
 PBYTE w;
 
466
 puchar w;
467
467
 if (ED_file_end - kit_curr - 2 < l)
468
468
        ErrorExit (RSTR_ERR_NOPLACE);
469
 
 *(PINT) kit_curr=l; memcpy (kit_curr+2,c,l);
 
469
 *(pint16_t) kit_curr=l; memcpy (kit_curr+2,c,l);
470
470
 w=kit_curr; kit_curr+=l+2;
471
471
 return w;
472
472
}
473
473
 
474
 
static void rest_kit(PBYTE s, PBYTE k)
 
474
static void rest_kit(puchar s, puchar k)
475
475
{
476
 
 memcpy(s,k+2,*(PINT)k);
 
476
 memcpy(s,k+2,*(pint16_t)k);
477
477
}
478
478
 
479
 
static PBYTE comp_to_kit(MN * mn)
 
479
static puchar comp_to_kit(MN * mn)
480
480
{
481
 
 PBYTE sv;
482
 
 INT lth;
 
481
 puchar sv;
 
482
 int16_t lth;
483
483
 MN_to_line(mn);
484
484
 lth = sizeof(c_comp) + lpool_lth + 2;
485
485
 wcomp.size = (lth + 15)/16; // Vald 11-24-95 05:06pm
487
487
 if (ED_file_end - kit_curr < lth)
488
488
         ErrorExit (RSTR_ERR_NOPLACE);
489
489
 memcpy(kit_curr,&wcomp,sizeof(wcomp));
490
 
 *(INT *)(kit_curr+sizeof(wcomp)) = lpool_lth;
 
490
 *(int16_t *)(kit_curr+sizeof(wcomp)) = lpool_lth;
491
491
 memcpy(kit_curr+sizeof(c_comp)+2,lpool,lpool_lth);
492
492
 sv=kit_curr;
493
493
 kit_curr+=sizeof(c_comp)+2+lpool_lth;
498
498
 
499
499
c_comp * comp_vers_to_kit(MN * mn, c_comp *c)
500
500
{
501
 
 PBYTE sv=kit_curr;
502
 
 INT lth;
 
501
 puchar sv=kit_curr;
 
502
 int16_t lth;
503
503
 MN_to_line(mn);
504
504
 if (c->size == 1)
505
505
  {
509
509
   wcomp.type=ch_punct; wcomp.records=0; wcomp.lines=sizeof(c_comp);
510
510
   memcpy(kit_curr,&wcomp,sizeof(c_comp));
511
511
   ((c_comp*)kit_curr)->size=(lth+sizeof(lpool_lth)+15)/16; // Vald 02-15-96 07:12pm
512
 
   *(INT *)(kit_curr+sizeof(c_comp)) = lpool_lth;
513
 
   kit_curr+=sizeof(c_comp)+sizeof(INT);
 
512
   *(int16_t *)(kit_curr+sizeof(c_comp)) = lpool_lth;
 
513
   kit_curr+=sizeof(c_comp)+sizeof(int16_t);
514
514
   memcpy(kit_curr,lpool,lpool_lth);
515
515
   kit_curr+=lpool_lth;
516
516
   return (c_comp *)sv;
529
529
  cc->nl=wcomp.nl; cc->begs=wcomp.begs; cc->ends=wcomp.ends;
530
530
 }
531
531
 kit_curr+=sizeof(wcomp)+(c->nvers+1)*sizeof(version);
532
 
 *(INT *)kit_curr = lpool_lth;
 
532
 *(int16_t *)kit_curr = lpool_lth;
533
533
 memcpy(kit_curr+sizeof(lpool_lth),lpool,lpool_lth);
534
534
 kit_curr+=sizeof(lpool_lth)+lpool_lth;
535
535
 return (c_comp *)sv;
544
544
        if ( c->env )
545
545
        {
546
546
                memcpy (&wcomp,w,sizeof(c_comp));
547
 
                w = (c_comp *)((PBYTE)w + w->lines);
548
 
                lpool_lth=*(PINT)w;
549
 
                w=(c_comp *)((PINT)w+1);
 
547
                w = (c_comp *)((puchar)w + w->lines);
 
548
                lpool_lth=*(pint16_t)w;
 
549
                w=(c_comp *)((pint16_t)w+1);
550
550
                memcpy (lpool,w,lpool_lth);
551
551
                rec_ptr=start_rec;
552
552
        }
556
556
void online_comp(c_comp *w)
557
557
{
558
558
 memcpy (&wcomp,w,sizeof(c_comp));
559
 
 w = (c_comp *)((PBYTE)w + w->lines);
560
 
 lpool_lth=*(PINT)w; w=(c_comp *)((PINT)w+1);
 
559
 w = (c_comp *)((puchar)w + w->lines);
 
560
 lpool_lth=*(pint16_t)w; w=(c_comp *)((pint16_t)w+1);
561
561
 memcpy (lpool,w,lpool_lth);
562
562
 rec_ptr=start_rec;
563
563
}
564
564
 
565
565
#define NCOMPMAX 8
566
566
 
567
 
BOOL compose_cell(INT n,cell **clist,cell *c)
 
567
Bool compose_cell(int16_t n,cell **clist,cell *c)
568
568
 {
569
 
 INT i,top,bot,left,right,hmax,imax;
 
569
 int16_t i,top,bot,left,right,hmax,imax;
570
570
 c_comp *elist[NCOMPMAX];
571
 
 INT inc;
572
 
 BOOL   ret=TRUE;
 
571
 int16_t inc;
 
572
 Bool   ret=TRUE;
573
573
 
574
574
 for ( top=left=10000,imax=hmax=bot=right=-10000,i=0; i<n && i<NCOMPMAX; i++)
575
575
  {
606
606
     c->h=bot-top;
607
607
     c->r_col=left;
608
608
     c->w=right-left;
609
 
     c->row=c->r_row-(INT)((LONG)nIncline*c->r_col/2048);
610
 
     c->col=c->r_col+(INT)((LONG)nIncline*c->r_row/2048);
 
609
     c->row=c->r_row-(int16_t)((int32_t)nIncline*c->r_col/2048);
 
610
     c->col=c->r_col+(int16_t)((int32_t)nIncline*c->r_row/2048);
611
611
     c->env=compose_comp(i,elist);
612
612
     c->cg_flag|=c_cg_comp;
613
613
     }
614
614
 else if( imax!=-1 && c!=clist[imax] )
615
615
    {
616
616
    cell *n=c->next,*p=c->prev,*nl=c->nextl,*pl=c->prevl;
617
 
    WORD    flg=c->flg;
 
617
    uint16_t    flg=c->flg;
618
618
    *c=*clist[imax];
619
619
    c->next=n;
620
620
    c->prev=p;
629
629
 }
630
630
 
631
631
// analog of compose_cell whithout deleting
632
 
BOOL compose_cell_save(INT n,cell **clist,cell *c)
 
632
Bool compose_cell_save(int16_t n,cell **clist,cell *c)
633
633
 {
634
 
 INT i,top,bot,left,right,hmax,imax;
 
634
 int16_t i,top,bot,left,right,hmax,imax;
635
635
 c_comp *elist[NCOMPMAX];
636
 
 INT inc;
637
 
 BOOL   ret=TRUE;
 
636
 int16_t inc;
 
637
 Bool   ret=TRUE;
638
638
 
639
639
 for (top=left=10000,imax=hmax=bot=right=-10000,i=0; i<n && i<NCOMPMAX; i++)
640
640
  {
671
671
     c->h=bot-top;
672
672
     c->r_col=left;
673
673
     c->w=right-left;
674
 
     c->row=c->r_row-(INT)((LONG)nIncline*c->r_col/2048);
675
 
     c->col=c->r_col+(INT)((LONG)nIncline*c->r_row/2048);
 
674
     c->row=c->r_row-(int16_t)((int32_t)nIncline*c->r_col/2048);
 
675
     c->col=c->r_col+(int16_t)((int32_t)nIncline*c->r_row/2048);
676
676
     c->env=compose_comp(i,elist);
677
677
     c->cg_flag|=c_cg_comp;
678
678
     }
679
679
  else if( imax!=-1 && c!=clist[imax] )
680
680
    {
681
681
    cell *n=c->next,*p=c->prev,*nl=c->nextl,*pl=c->prevl;
682
 
    WORD    flg=c->flg;
 
682
    uint16_t    flg=c->flg;
683
683
    *c=*clist[imax];
684
684
    c->next=n;
685
685
    c->prev=p;
691
691
 }
692
692
 
693
693
 
694
 
c_comp *compose_comp(INT n,c_comp **c)
 
694
c_comp *compose_comp(int16_t n,c_comp **c)
695
695
 {
696
 
 INT lower,right,i,j,l,nl,du,dl,lth;
697
 
 PBYTE w,sv;
 
696
 int16_t lower,right,i,j,l,nl,du,dl,lth;
 
697
 puchar w,sv;
698
698
 lnhead *ln;
699
699
 interval *intv;
700
700
 
732
732
 {
733
733
  if (c[i]!=NULL)
734
734
   {
735
 
   w=(PBYTE)(c[i])+c[i]->lines;
736
 
   l+=*((INT *)w)-((i==n-1)?0:2);
 
735
   w=(puchar)(c[i])+c[i]->lines;
 
736
   l+=*((int16_t *)w)-((i==n-1)?0:2);
737
737
  }
738
738
 }
739
739
 if( l>LPOOL_SIZE)
741
741
 for (i=0; i<n; i++,lpool_lth+=l)
742
742
  if (c[i]!=NULL)
743
743
   {
744
 
   w=(PBYTE)(c[i])+c[i]->lines;
 
744
   w=(puchar)(c[i])+c[i]->lines;
745
745
   nl=c[i]->nl;
746
746
   du=c[i]->upper-wcomp.upper;
747
747
   dl=c[i]->left-wcomp.left;
748
 
   l=*((INT *)w)-((i==n-1)?0:2);
749
 
   memcpy((PBYTE)lpool+lpool_lth,w+2,l);
750
 
   for (ln=(lnhead*)((PBYTE)lpool+lpool_lth),j=0; j<nl;
751
 
                                         j++,ln=(lnhead *)((PBYTE)ln+lth))
 
748
   l=*((int16_t *)w)-((i==n-1)?0:2);
 
749
   memcpy((puchar)lpool+lpool_lth,w+2,l);
 
750
   for (ln=(lnhead*)((puchar)lpool+lpool_lth),j=0; j<nl;
 
751
                                         j++,ln=(lnhead *)((puchar)ln+lth))
752
752
    {
753
753
    ln->row+=du;
754
754
    lth=ln->lth;
756
756
     ln->flg|=l_cbeg;
757
757
    if (j==nl-1)
758
758
     ln->flg|=l_cend;
759
 
    for (intv=(interval *)((PBYTE)ln+sizeof(lnhead)); intv->l; intv++)
 
759
    for (intv=(interval *)((puchar)ln+sizeof(lnhead)); intv->l; intv++)
760
760
     intv->e+=dl;
761
761
    }
762
762
   }
763
763
 
764
 
 *((INT *)lpool)=lpool_lth-2;
765
 
 if( (PBYTE)(ED_file_end - kit_curr)<(PBYTE)(lpool_lth+sizeof(c_comp)) )
 
764
 *((int16_t *)lpool)=lpool_lth-2;
 
765
 if( (puchar)(ED_file_end - kit_curr)<(puchar)(lpool_lth+sizeof(c_comp)) )
766
766
  ErrorExit (RSTR_ERR_NOPLACE);
767
767
 sv=kit_curr;
768
768
 wcomp.size = (sizeof(c_comp) + lpool_lth + 15) / 16; // Vald
817
817
}
818
818
 
819
819
 
820
 
PBYTE del_save_cell(cell *c)
 
820
puchar del_save_cell(cell *c)
821
821
{
822
 
 PBYTE p;
823
 
 p =  save_kit((PBYTE)c,sizeof(cell));
 
822
 puchar p;
 
823
 p =  save_kit((puchar)c,sizeof(cell));
824
824
 del_cell(c);
825
825
 return p;
826
826
}
828
828
cell * rest_cell(void *k, cell *ci)
829
829
{
830
830
 cell * c = new_cell();
831
 
 rest_kit((PBYTE) c, k);
 
831
 rest_kit((puchar) c, k);
832
832
 insert_cell(c,ci);
833
833
 return c;
834
834
}
835
835
 
836
836
void insert_cell(cell *c,cell *ci)
837
837
{
838
 
        INT col=c->col;
 
838
        int16_t col=c->col;
839
839
        if(!(ci->flg & c_f_space)) // Valdemar 02-15-96 00:17am
840
840
// Paul 10-11-96
841
841
/*
884
884
// crash attention!
885
885
void insert_cell1(cell *c,cell *ci)
886
886
{
887
 
        INT col=c->col;
 
887
        int16_t col=c->col;
888
888
 
889
889
        if( !(ci->flg & c_f_space)) // Valdemar 02-15-96 00:17am
890
890
                if ( col <= ci->col)
933
933
 cn->prevl = c;
934
934
}
935
935
 
936
 
cell * create_cell(MN * mn, cell * ci, CHAR bdiff, CHAR dflag)
 
936
cell * create_cell(MN * mn, cell * ci, char bdiff, char dflag)
937
937
{
938
938
 cell * c = new_cell();
939
939
 accept_cell (c,(c_comp *)comp_to_kit(mn));
957
957
 return c;
958
958
}
959
959
 
960
 
cell * create_cell1(MN * mn, cell * ci, CHAR bdiff, CHAR dflag)
 
960
cell * create_cell1(MN * mn, cell * ci, char bdiff, char dflag)
961
961
{
962
962
 cell * c = new_cell();
963
963
 accept_cell (c,(c_comp *)comp_to_kit(mn));
981
981
 return c;
982
982
}
983
983
 
984
 
cell * create_cell_work(MN * mn, cell * ci, CHAR bdiff, CHAR dflag)
 
984
cell * create_cell_work(MN * mn, cell * ci, char bdiff, char dflag)
985
985
{
986
986
 cell * c = new_cell();
987
987
 accept_cell (c,(c_comp *)comp_to_kit(mn));
1013
1013
 
1014
1014
/*=============== Cell rocognition ===========================*/
1015
1015
 
1016
 
static INT vers_to_cell(cell *c)
 
1016
static int16_t vers_to_cell(cell *c)
1017
1017
{
1018
 
 INT i;
 
1018
 int16_t i;
1019
1019
 c->recsource = 0;
1020
1020
 if ((i=rec_ptr-start_rec) !=0)
1021
1021
  {
1030
1030
 set_bad_cell(c); return 0;
1031
1031
}
1032
1032
 
1033
 
static INT second_recog(cell *c)
 
1033
static int16_t second_recog(cell *c)
1034
1034
{
1035
1035
 levcut(c,1);
1036
1036
 if (db_status && (db_trace_flag & 2))
1046
1046
}
1047
1047
 
1048
1048
 
1049
 
INT short_recog_cell (cell *c)
 
1049
int16_t short_recog_cell (cell *c)
1050
1050
{
1051
 
 // was && �� ���� ��� c->evn - ��� ������������?
 
1051
 // was && но если нет c->evn - что распознавать?
1052
1052
 if( (c->cg_flag & c_cg_comp) ||
1053
1053
     (!c->env) )
1054
1054
   return 0;
1055
1055
 
1056
1056
 comp_from_kit(c);
1057
1057
 {
1058
 
INT n,i;
1059
 
BYTE res[20];
 
1058
int16_t n,i;
 
1059
uchar res[20];
1060
1060
CCOM_comp cc;
1061
 
//������ � ��������� CCOM_comp ������ ��� EVNRecog_lp
 
1061
//запись в структуру CCOM_comp данных для EVNRecog_lp
1062
1062
cc.h = c->env->h;
1063
1063
cc.w = c->env->w;
1064
1064
cc.rw = c->env->rw;
1067
1067
cc.ends = c->env->ends;
1068
1068
cc.scale = c->env->scale;
1069
1069
 
1070
 
// n = (INT)EVNRecog_lp(c->env,lpool,lpool_lth,&res[0]);
1071
 
 n = (INT)EVNRecog_lp(&cc,lpool,lpool_lth,&res[0]);
 
1070
// n = (int16_t)EVNRecog_lp(c->env,lpool,lpool_lth,&res[0]);
 
1071
 n = (int16_t)EVNRecog_lp(&cc,lpool,lpool_lth,&res[0]);
1072
1072
 
1073
 
//�������������� �� ��������� CCOM_comp ����������� EVNRecog_lp
 
1073
//восстановление из структуры CCOM_comp результатов EVNRecog_lp
1074
1074
 c->env->type = cc.type;
1075
1075
 c->env->cs = cc.cs;
1076
1076
 c->env->pidx = cc.pidx;
1105
1105
 return c->nvers;
1106
1106
}
1107
1107
 
1108
 
INT recog_cell(cell *c)
 
1108
int16_t recog_cell(cell *c)
1109
1109
{
1110
1110
if( !c->env ) return 0; // Oleg : can't recog null cells
1111
1111
 short_recog_cell(c);
1115
1115
 return second_recog(c);
1116
1116
}
1117
1117
 
1118
 
INT reco2_cell(cell *c)
 
1118
int16_t reco2_cell(cell *c)
1119
1119
{
1120
1120
 c->reasno=0;
1121
1121
 second_recog(c);
1132
1132
 return c->nvers;
1133
1133
}
1134
1134
 
1135
 
INT recop_cell(cell *c)
 
1135
int16_t recop_cell(cell *c)
1136
1136
{
1137
1137
 c->reasno=0; criteria(c);  if (db_pidx_crit) v2_pidx_crit(c);
1138
1138
 if ( c->nvers == 0 )  {
1143
1143
}
1144
1144
 
1145
1145
/*================ Make raster function =======================*/
1146
 
PBYTE save_raster(cell *c)
 
1146
puchar save_raster(cell *c)
1147
1147
{
1148
1148
 comp_from_kit(c); return make_raster();
1149
1149
}
1150
1150
 
1151
 
PBYTE save_raster_align8(cell *c)
 
1151
puchar save_raster_align8(cell *c)
1152
1152
{
1153
1153
 comp_from_kit(c);
1154
1154
 wcomp.rw = ((wcomp.w+63)/64)*8;
1157
1157
 
1158
1158
void add_vers(cell *bc, version *wv)
1159
1159
{
1160
 
 INT nv;
 
1160
 int16_t nv;
1161
1161
 nv=bc->nvers;
1162
1162
 if (nv == VERS_IN_CELL-1)
1163
1163
  {
1176
1176
  }
1177
1177
}
1178
1178
 
1179
 
BOOL    comp_versions(version *v, version *w, INT n,INT    snvers)
 
1179
Bool    comp_versions(version *v, version *w, int16_t n,int16_t    snvers)
1180
1180
{
1181
 
INT i;
 
1181
int16_t i;
1182
1182
 
1183
1183
if( n!=snvers )
1184
1184
    return TRUE;
1190
1190
return FALSE;
1191
1191
}
1192
1192
 
1193
 
void del_version(  cell *c,BYTE let)
 
1193
void del_version(  cell *c,uchar let)
1194
1194
{
1195
 
 INT i,nvers;
 
1195
 int16_t i,nvers;
1196
1196
 version *v ;
1197
1197
 
1198
1198
 if( c->nvers<1 )
1214
1214
}
1215
1215
 
1216
1216
#define s_ans(a) { rec_ptr->let = a; rec_ptr->prob = 254; rec_ptr++; }
1217
 
INT stick_w_4()
 
1217
int16_t stick_w_4()
1218
1218
{
1219
 
 INT answ;
 
1219
 int16_t answ;
1220
1220
 answ = typ_thin_stick((lnhead *)lpool,wcomp.h,wcomp.w);
1221
1221
 rec_ptr = start_rec;
1222
1222
 if (answ == 0) goto ret;