//       п/п ввода базы данных
#include  "complex.h"
#include  "graf.h"
#include  "shst_prt.h"
#include  "mnemos.h"
#include  "screen.h"

#define DI1   (DINA +N_D)->

extern void end_scan(void);
extern void error_bd(char *str1);

char *StrMesIndb[]=
{
 "Отсутствует файл %s",                                                            //0
 "Элем. %.9s мнемосхемы %.8s, отсутствует в контроллерах",                         //1
 "Элем. %.9s мнемосхемы %.8s, встречается более раза в контроллерах",              //2
 "Пустой элемент динамики мнемосхем",                                              //3
 "Дискр. элем. %.9s объекта сигн. %.8s отсутствует в контроллерах",                //4
 "Дискр. элем. %.9s объекта сигн. %.8s встречается более раза в контроллерах",     //5
 "Элем. %.9s объекта сигн. %.8s не является дискркетным ",                         //6
 "Элем. %.9s группы контуров %.8s отсутствует в контроллерах",                     //7
 "Элем. %.9s группы контуров %.8s встречается более раза в контроллерах",          //8
 "ENERGY",                                                                         //9
 "Элем. %.9s группы графиков %.8s отсутствует в контроллерах",                     //10
 "Элем. %.9s группы графиков %.8s встречается более раза в контроллерах",          //11
 "Элем. %.9s группы графиков %.8s является дискретным параметром",                 //12
 "Элем. %.9s обзорного кадра %.8s отсутствует в контроллерах",                     //13
 "Элем. %.9s обзорного кадра %.8s встречается более раза в контроллерах",          //14
 "Элем. %.9s сводной таблицы %.9s отсутствует в контроллерах",                     //15
 "Элем. %.9s сводной таблицы %.9s встречается более раза в контроллерах",          //16
 "Элем. %.9s сводной таблицы %.9s является дискретным параметром",                 //17
 "Контур %.8s объекта сигн. %.8s встречается более раза в контурах",               //18
 "Контур %.8s объекта сигн. %.8s отсутствует в контурах",                          //19
 "График %.8s объекта сигн. %.8s встречается более раза в графиках",               //20
 "График %.8s объекта сигн. %.8s отсутствует в графиках",                          //21
 "Мнемосхема %.8s объекта сигн. %.8s встречается более раза в мнемосхемах",        //22
 "Мнемосхема %.8s объекта сигн. %.8s отсутствует в мнемосхемах",                   //23
 "Шифр %.9s голосовых сообщений отсутствует в контроллерах",                       //24
 "Шифр %.9s голосовых сообщений встречается более раза в контроллерах"            //25
};

extern word_s ChekNamePasport(char *str,word_s *nc,word_s *nz);
word_s open_fh(char *namf,word_s init);
char * infil(char *fl,word_s *pnum,word_s lrec);
dinami * LoadMS(char *fl,word_s *pnum);

void in_view(void);
void in_sv_tabl(void);
void in_alg(void);

void inreg(void);
void incontr(void);
void insert(void);
void inobject(void);
void in_gr_cont(void);
void in_gr_nr(void);
void in_gr_graficov(void);
void in_gr_tex_g(char *tg, char *fg);
void in_speak(void);
void in_edit_q(void);

extern void insert_contr(controller *ptr_c,int n_contr,char *Basa,int mode);

void koeff_sc(analog *a_ptr);
word_s setting(analog *a_ptr,float work_f);
void def_param_man(void);
void def_no_uch(void);
char * z_db(char *x_db,int len);

char *inputdb = __FILE__;

//word_s strfl = 6;
//word_s posfl = 1;
//word_s errbd = 0;

edit_doc *ed_doc;

extern mpred *ptr_mpred;
//extern s_alg  *p_alg;
//extern word_s k_alg;

extern word_s N_MAN;        // переменная для подсчета параметров ручного ввода
word_s fh, lenrec, numrec, ofsetdat;
char descr[32], *recfil;
//-------------------------------------------------------------------

void input_DB()
{
  word_s N_D;

  incontr();                   // ввод описателей контроллеров
  insert();                    // ввод паспоpтов паpаметpов
#if (EDITQ * !ALG)
  in_edit_q();                // ввод описания корректируемых параметров
#endif

#if (VIEW)
  in_view();                 // ввод обзорного кадра
#endif
#if (KONTUR)
  in_gr_cont();             // ввод описания гpупп контуpов
#endif
#if (PROTOC)
#if (!AL_AN)
  in_gr_nr();               // ввод описания гpупп нарушений
#endif
    in_gr_tex_g(NameFile[26],NameFile[27]);     // ввод  участков тех.журнала 1
    if((fh=sopen(NameFile[28],O_BINARY|O_RDWR,SH_DENYNO)) == -1)
      remove(NameFile[29]);
    else in_gr_tex_g(NameFile[28],NameFile[29]);  // ввод  участков тех.журнала 2
#endif
#if (GRAFIK)
  in_gr_graficov();           // ввод описания гpупп графиков
#endif
#if (SPEAK)
  in_speak();
#endif
#if (MNEMOC)
  DOMI=(domim *)infil(NameFile[6],&KOLDO,sizeof(domim));      // файл управляющий
  STATI=(statim *)infil(NameFile[7],&KOLST,sizeof(statim));  // файл статики
  DINA=LoadMS(NameFile[8],&KOLDI);
//  DINA=(dinami *)infil(NameFile[8],&KOLDI,sizeof(dinami));  // файл динамики

  if(DOMI && KOLDI)
  {
   if((ptr_mpred = (mpred *)calloc(KOLDI,sizeof(mpred)))==NULL) kz_mem(inputdb,__LINE__);
   for(N_D=0;N_D<KOLDI;N_D++) (ptr_mpred+N_D)->X_PRED[0]=(ptr_mpred+N_D)->X_PRED[1]=DI1 X_PRED;
//   for(N_D=0;N_D<KOLDI;N_D++) for(i=0;i<10;i++) if(DI1 IMJ[i]==' ') DI1 IMJ[i]='\0';
//   for(N_D=0;N_D<KOLDO;N_D++) for(i=0;i<7;i++) if((DOMI+N_D)->IMJ[i]=='\0') (DOMI+N_D)->IMJ[i]=' ';
  }
#endif

#if (SVTAB)
  in_sv_tabl();
#endif
  inobject();                  // ввод объектов сигнализации

//  if(errbd) {
//    _settextcolor(14);
//    gprintf(23,30,"НЕТ НЕКОТОРЫХ ФАЙЛОВ - пpодолжить pаботу (ВВОД/Ф6)?");
//    _settextposition(3,2);
//    if((_bios_keybrd(_KEYBRD_READ) >> 8) != ENTER) { end_scan(); exit(3); }
//    bar_(0, 0, Y_T_SCR, X_SCR, Y_B_SCR-1);
//  }
}
//--------------------------------------------------------------------

word_s open_fh(char *namf,word_s init)
{
  word_s h;

  if((h=sopen(namf,O_BINARY|O_RDWR,SH_DENYNO)) == -1)
  {
   eprintf(GRAY_,StrMesIndb[0],namf);
//    gprintf(strfl++,posfl," НЕТ ФАЙЛА  %s", namf);
//    errbd = 1;
//    if(strfl > 22) { strfl = 6; posfl += 26; }
    return -1;
  }
  if(!init) return h;

  read(h, descr, 32);                   // читать заголовок  dbf-файла
  lenrec = *(word_s*)(descr + 10);         // длинa записи
  ofsetdat = *(word_s *)(descr + 8);       // смещение данных в файле
  if((recfil = (char *)calloc(1,lenrec)) == NULL) kz_mem(inputdb,__LINE__);
  lseek(h, (long)ofsetdat, SEEK_SET);
  return h;
}
//-------------------------------------------------------------------

#if (MNEMOC)
char * infil(char *fl,word_s *pnum,word_s lrec)   // пп ввода файла
{
  word_s h;
  char *pc;

  pc=NULL;
  if((h=open_fh(fl,0)) != -1)
  {
    *pnum=(unsigned)filelength(h)/lrec;
    if(*pnum!=0)
    {
      pc=(char *)calloc(*pnum,lrec);
      if(pc==NULL) kz_mem(inputdb,__LINE__);
      read(h,pc,*pnum*lrec);
      close(h);
    }
    return(pc);
  }
 return(0);
}
//               -----------
dinami * LoadMS(char *fl,word_s *pnum)
{
 word_s h,i,ii,ki,kor,ld_zap,ld_contr,ld_tip;
 dinami *pc,*pc1;
 char sss[9];                                                 //hi

 pc=NULL;
 if((h=open_fh(fl,0)) != -1)
 {
  *pnum=(unsigned)(filelength(h)/sizeof(dinami));
  if(*pnum!=0)
  {
   pc=pc1=(dinami *)calloc(*pnum,sizeof(dinami));
   if(pc==NULL) kz_mem(inputdb,__LINE__);
   for(i=0,ki=0;i< *pnum;i++)
   {
    read(h,pc1,sizeof(dinami));
    ld_tip=ChekNamePasport(pc1->IMJ,&ld_contr,&ld_zap);
    if(ld_tip==ANALOG || ld_tip==DIGIT)
    {
     pc1->N_KO=ld_contr;
     pc1->P_E=ld_tip;
     pc1->NOM_PAR=ld_zap;
     pc1++;ki++;
    }
    else
    {
     for(ii=0,kor=0;ii<KOLDO;ii++)
     {
      if(kor){(DOMI+ii)->N_D--;(DOMI+ii)->K_D--;}
      if(ki >= (DOMI+ii)->N_D && ki <= (DOMI+ii)->K_D && !kor)
       {(DOMI+ii)->K_D--;strncpy(sss,(DOMI+ii)->IMJ,8);kor=1;}
     }
     if(ld_tip== -1)
      eprintf(GRAY_,StrMesIndb[1],pc1->IMJ,sss);
     if(ld_tip== -2)
      eprintf(GRAY_,StrMesIndb[2],pc1->IMJ,sss);
     if(ld_tip==EMPTY)
      eprintf(GRAY_,StrMesIndb[3]);
    }
   }
   if(ki!= *pnum)pc=(dinami *)realloc(pc,ki*sizeof(dinami));
  }
  close(h);
  return(pc);
 }
 return(0);
}
#endif
//-------------------------------------------------------------------

void incontr(void)
{
 word_s i;
 float  per;
 controller * ptr_c;
 char *Basa,str[256];

 if((Basa=(char *)CreateLoadDbf(NameFile[3]))== NULL) error_bd(NameFile[3]);
 c_num=GetCountItDbf(Basa);
 if(c_num==0) error_bd(NameFile[3]);
 c_ptr = (controller *)calloc(c_num, sizeof(controller));
 if(c_ptr == NULL) kz_mem(inputdb,__LINE__);
 for(i=0,ptr_c=c_ptr; i < c_num; i++,ptr_c++)
 {
  ptr_c->nom_ord = i;
  GetFieldItDbf(Basa,i,"SHIFR",str);  ptr_c->nomcontr=atoi(str);
  GetFieldItDbf(Basa,i,"TC",str);     ptr_c->typcontr=atoi(str);
  GetFieldItDbf(Basa,i,"NFA",ptr_c->namfil_A);
  GetFieldItDbf(Basa,i,"NFD",ptr_c->namfil_D);
  GetFieldItDbf(Basa,i,"PER",str);    ptr_c->period=atoi(str)*HZ/1000;
//  sprintf(str,"%d",(ptr_c->period*1000/HZ));
//  SetFieldItDbf(Basa,i,"PER",str);
//  eprintf(GRAY_,"%d: Period %d",i,ptr_c->period);

  insert_contr(c_ptr,i,Basa,InsContr);
//  GetFieldItDbf(Basa,i,"SPEED",str);  ptr_c->baud=atoi(str);
//  if(ptr_c->baud==1920 || ptr_c->baud==3840) ptr_c->baud *= 10;
//  GetFieldItDbf(Basa,i,"PORT",str);   ptr_c->nomport=atoi(str);
//  ptr_c->nomport=ptr_c->nomport/10*16+ptr_c->nomport%10;
//  GetFieldItDbf(Basa,i,"ADRES",str);  ptr_c->basaddr=strtol(str,NULL,16);
//  GetFieldItDbf(Basa,i,"LINE",str);   ptr_c->IRQ_line=strtol(str,NULL,16);
//  GetFieldItDbf(Basa,i,"VECT",str);   ptr_c->vector=strtol(str,NULL,16);

//  GetFieldItDbf(Basa,i,"LA",str);     ptr_c->num_ap=atoi(str);
//  GetFieldItDbf(Basa,i,"LD",str);     ptr_c->num_dp=atoi(str);
 }
// SaveDbf(Basa);
 DeleteDbf(Basa);
}

//-------------------------------------------------------------------

void insert(void)
{
 word_s i,ii;
 controller * ptr_c;
 char *Basa,str[256];

 for(i = 0, ptr_c = c_ptr; i < c_num; i++, ptr_c++)
 {
  ptr_c->num_ap=0;
  if((Basa=(char *)CreateLoadDbf(ptr_c->namfil_A))!= NULL)
  {
   if(ptr_c->num_ap=GetCountItDbf(Basa))
   {
    ptr_c->a_ptr = (analog *)calloc(ptr_c->num_ap, sizeof(analog));
    if(ptr_c->a_ptr == NULL) kz_mem(inputdb,__LINE__);
    for(ii=0;ii<ptr_c->num_ap;ii++)
    {
     ptr_c->a_ptr[ii].novalid=0; ptr_c->a_ptr[ii].nomin_var = -1;
     GetFieldItDbf(Basa,ii,"SHIFR",ptr_c->a_ptr[ii].cipher);
     GetFieldItDbf(Basa,ii,"NAME",ptr_c->a_ptr[ii].name);
     GetFieldItDbf(Basa,ii,"ED",ptr_c->a_ptr[ii].unit);
     GetFieldItDbf(Basa,ii,"SCALE",str); ptr_c->a_ptr[ii].type_sc=atoi(str);
     GetFieldItDbf(Basa,ii,"NG",str); ptr_c->a_ptr[ii].min_sc=atof(str);
     GetFieldItDbf(Basa,ii,"VG",str); ptr_c->a_ptr[ii].max_sc=atof(str);
     koeff_sc(&(ptr_c->a_ptr[ii]));
     GetFieldItDbf(Basa,ii,"NTG",str); ptr_c->a_ptr[ii].min_reg = setting(&(ptr_c->a_ptr[ii]),atof(str));
     GetFieldItDbf(Basa,ii,"VTG",str); ptr_c->a_ptr[ii].max_reg = setting(&(ptr_c->a_ptr[ii]),atof(str));
     GetFieldItDbf(Basa,ii,"NAG",str); ptr_c->a_ptr[ii].min_al = setting(&(ptr_c->a_ptr[ii]),atof(str));
     GetFieldItDbf(Basa,ii,"VAG",str); ptr_c->a_ptr[ii].max_al = setting(&(ptr_c->a_ptr[ii]),atof(str));
     GetFieldItDbf(Basa,ii,"TIPO",str); ptr_c->a_ptr[ii].sum_ysr=atoi(str);
     GetFieldItDbf(Basa,ii,"TIP",str); ptr_c->a_ptr[ii].type_mech=atoi(str);
     GetFieldItDbf(Basa,ii,"Z_GR",str); ptr_c->a_ptr[ii].d_gr=atof(str);
     GetFieldItDbf(Basa,ii,"STAT",str); ptr_c->a_ptr[ii].pasive=atoi(str);
     if(ptr_c->a_ptr[ii].type_mech==M_INP)
     {
      if(ptr_c->a_ptr[ii].k_scale > 0) ptr_c->a_ptr[ii].novalid = 0;
//     ptr_c->a_ptr[ii].type_mech=0; ptr_c->a_ptr[ii].mod_cod=M_INP;    //!!
      N_MAN += 1;
     }
    }
    insert_contr(c_ptr,i,Basa,InsAnlog);
//   insert_A_contr(ptr_c,Basa);
   }
   DeleteDbf(Basa);
  }
  ptr_c->num_dp=0;
  if((Basa=(char *)CreateLoadDbf(ptr_c->namfil_D))!= NULL)
  {
   if(ptr_c->num_dp=GetCountItDbf(Basa))
   {
    ptr_c->d_ptr = (digit *)calloc(ptr_c->num_dp, sizeof(digit));
    if(ptr_c->d_ptr == NULL) kz_mem(inputdb,__LINE__);
    for(ii=0;ii<ptr_c->num_dp;ii++)
    {
     ptr_c->d_ptr[ii].novalid=0; ptr_c->d_ptr[ii].nom_var =0;
     GetFieldItDbf(Basa,ii,"SHIFR",ptr_c->d_ptr[ii].cipher);
     GetFieldItDbf(Basa,ii,"NAME",ptr_c->d_ptr[ii].name);
     GetFieldItDbf(Basa,ii,"TIP",str); ptr_c->d_ptr[ii].type_par=atoi(str);
     GetFieldItDbf(Basa,ii,"PA",str); ptr_c->d_ptr[ii].archive=atoi(str);
     GetFieldItDbf(Basa,ii,"T_W",str); ptr_c->d_ptr[ii].reg_tim=atoi(str);
     GetFieldItDbf(Basa,ii,"TIPC",str); ptr_c->d_ptr[ii].type_com=atoi(str);      //?
     GetFieldItDbf(Basa,ii,"STAT",str); ptr_c->d_ptr[ii].pasive=atoi(str);
     GetFieldItDbf(Basa,ii,"SIG",str); ptr_c->d_ptr[ii].signal=atoi(str);
     if(!ptr_c->d_ptr[ii].type_com) ptr_c->d_ptr[ii].nom_dout=ptr_c->d_ptr[ii].nom_dot2=ptr_c->d_ptr[ii].nom_dot3= -1;
    }
    insert_contr(c_ptr,i,Basa,InsDigit);
//   insert_D_contr(ptr_c,Basa);
   }
   DeleteDbf(Basa);
  }
 }
 def_param_man();
 def_no_uch();
}
//-------------------------------------------------------------------

void def_param_man(void)
{
  word_s h, nf, i, j, k, kz, n_in_f;
  par_man *pf, *pm, *p_mem, *pk;
  controller *ptr_c;
  analog *a_ptr;

  if(N_MAN==0) { remove(NameFile[24]); return; }
  n_in_f=0;

  h = sopen(NameFile[24],O_BINARY|O_RDWR,SH_DENYNO);
  if(h != -1)
  {
   pf = (par_man *)malloc((unsigned)filelength(h));
   if(pf==NULL) kz_mem(inputdb,__LINE__);
   read(h, pf, (unsigned)filelength(h));
   nf = filelength(h) / sizeof(par_man);
  }

  p_mem=pm = (par_man *)calloc(N_MAN, sizeof(par_man));
  if(pm==NULL) kz_mem(inputdb,__LINE__);

  for(i=0, ptr_c=c_ptr; i < c_num; i++, ptr_c++)
   for(j=0, a_ptr=ptr_c->a_ptr; j < ptr_c->num_ap; j++, a_ptr++)
    if(a_ptr->type_mech==M_INP)           //!!
    {
     strncpy(pm->cipher, a_ptr->cipher, 9);
     if(h != -1)
     {
      for(k=0, pk=pf;  k < nf; k++, pk++)
       if((kz=strncmp(pm->cipher,pk->cipher,9)) == 0) { n_in_f++; break; }
      if(!kz)
      {
       pm->var_cod=a_ptr->var_cod = pk->var_cod;
       a_ptr->var_tech=valtec(a_ptr,a_ptr->var_cod);

       if(a_ptr->min_reg && a_ptr->var_cod < a_ptr->min_reg) a_ptr->bound_reg=1;
       else if(a_ptr->max_reg && a_ptr->var_cod > a_ptr->max_reg) a_ptr->bound_reg=2;
       else a_ptr->bound_reg=0;
       if(a_ptr->min_al && a_ptr->var_cod < a_ptr->min_al) a_ptr->bound_al=1;
       else if(a_ptr->max_al && a_ptr->var_cod > a_ptr->max_al) a_ptr->bound_al=2;
       else a_ptr->bound_al=0;
      }
     }
     pm++;
    }
  if( h != -1 && n_in_f==N_MAN && nf==N_MAN) return;
  if(h != -1) { close(h); remove(NameFile[24]); }
  h=sopen(NameFile[24],O_BINARY|O_RDWR|O_CREAT, SH_DENYNO, S_IWRITE);
  write(h,p_mem,N_MAN*sizeof(par_man));
  close(h);
  free(p_mem);
  free(pf);
}
//-------------------------------------------------------------------

void def_no_uch(void)
{
  word_s h, nf, i, j, k, kz;
  no_uch_f *pf, *pk;
  controller *ptr_c;
  analog *a_ptr;

  h = sopen(NameFile[30],O_BINARY|O_RDWR,SH_DENYNO);
  if(h != -1) {
    pf = (no_uch_f *)malloc((unsigned)filelength(h));
    if(pf==NULL) kz_mem(inputdb,__LINE__);
    read(h, pf, (unsigned)filelength(h));
    nf = filelength(h) / sizeof(no_uch_f);

    for(i=0, ptr_c=c_ptr; i < c_num; i++, ptr_c++) {
      for(j=0, a_ptr=ptr_c->a_ptr; j < ptr_c->num_ap; j++, a_ptr++) {
        for(k=0, pk=pf;  k < nf; k++, pk++) {
          if((kz=strncmp(a_ptr->cipher,pk->cipher,9)) == 0) break;
        }
        if(!kz) a_ptr->no_uchet=1;
      }
    }
    close(h);
    free(pf);
  }
}
//-------------------------------------------------------------------

void inobject(void)
{
 int hd;
 word_s i,j,ld_zap,ld_contr,ld_tip,mi,n_mi,n_mi1,len;
 object * ptr_obj;
 char str[10];
 char x_db;

 hd=sopen(NameFile[11],O_BINARY|O_RDWR,SH_DENYNO);
 if(hd <= 0) error_bd(NameFile[11]);

 for(o_num=0;;)
 {
  if(read(hd,&x_db,1)== -1) goto exit_fr;
  if(x_db==0x55)break;
  if(x_db!=0x0D)goto exit_fr;

  read(hd,&len,2);
  o_num++;
  if((lseek(hd,len,SEEK_CUR)==-1) && (errno==EINVAL)) goto exit_fr;
 }
 o_ptr = (object *)calloc(o_num, sizeof(object));
 if(o_ptr == NULL) kz_mem(inputdb,__LINE__);
 lseek(hd,0,SEEK_SET);

 for(ptr_obj=o_ptr,i=0;i<o_num;i++,ptr_obj++)
 {
  lseek(hd,1,SEEK_CUR);
  read(hd,&len,2);
  read(hd,ptr_obj->cipher,9);
  read(hd,str,9);

  ld_tip=ChekNamePasport(str,&ld_contr,&ld_zap);
  if(ld_tip==-1)
  {eprintf(GRAY_,StrMesIndb[4],str,ptr_obj->cipher); ptr_obj->type_par=EMPTY; goto os1;}
  if(ld_tip==-2)
  {eprintf(GRAY_,StrMesIndb[5],str,ptr_obj->cipher); ptr_obj->type_par=EMPTY; goto os1;}
  if(ld_tip==ANALOG){ eprintf(GRAY_,StrMesIndb[6],str,ptr_obj->cipher); ptr_obj->type_par=EMPTY; goto os1;}
  ptr_obj->type_par=ld_tip;
  ptr_obj->nomcontr=ld_contr;
  ptr_obj->nomsert=ld_zap;
  ptr_obj->type_ds=((c_ptr+ld_contr)->d_ptr+ld_zap)->type_var;
os1:
  read(hd,&(ptr_obj->n_ms),1);
  read(hd,&(ptr_obj->n_gr_c),1);
  read(hd,&(ptr_obj->n_gr_g),1);
  if(ptr_obj->n_ms) ptr_obj->nom_gr_m=(byte *)calloc(ptr_obj->n_ms,8); else ptr_obj->nom_gr_m=NULL;
  if(ptr_obj->n_gr_c) ptr_obj->nom_gr_c=(byte *)calloc(ptr_obj->n_gr_c,9); else ptr_obj->nom_gr_c=NULL;
  if(ptr_obj->n_gr_g) ptr_obj->nom_gr_g=(byte *)calloc(ptr_obj->n_gr_g,9); else ptr_obj->nom_gr_g=NULL;

  for(n_mi1=0,j=0; j < ptr_obj->n_ms; j++)
  {
   read(hd,str,8); DelSpace(str,7);
   for(n_mi= -1,mi=0;mi<KOLDO;mi++)
   {
    DelSpace((DOMI+mi)->IMJ,7);
    if(!strncmp((DOMI+mi)->IMJ,str,7))
    {if(n_mi!= -1)n_mi= -2;else n_mi=mi;}
   }
   if(n_mi== -1){if(str[0]!=' ') eprintf(GRAY_,StrMesIndb[23],str,ptr_obj->cipher); continue;}
   if(n_mi== -2){ eprintf(GRAY_,StrMesIndb[22],str,ptr_obj->cipher); continue;}
   *(ptr_obj->nom_gr_m+n_mi1)=n_mi;
   n_mi1++;
  }
  ptr_obj->n_ms = n_mi1;

  for(n_mi1=0,j=0;j < ptr_obj->n_gr_c; j++)
  {
   read(hd,str,9);
   for(n_mi= -1,mi=0;mi<gr_c_n;mi++)if(!strncmp((gr_c_p+mi)->cipher,str,8)){if(n_mi!= -1)n_mi= -2;else n_mi=mi;}
   if(n_mi== -1) {if(str[0]!=' ') eprintf(GRAY_,StrMesIndb[19],str,ptr_obj->cipher); continue;}
   if(n_mi== -2){ eprintf(GRAY_,StrMesIndb[18],str,ptr_obj->cipher); continue;}
   *(ptr_obj->nom_gr_c+n_mi1)=n_mi;
   n_mi1++;
  }
  ptr_obj->n_gr_c = n_mi1;

  for(n_mi1=0,j=0; j < ptr_obj->n_gr_g; j++)
  {
   read(hd,str,9);
   for(n_mi= -1,mi=0;mi<gr_g_n;mi++)if(!strncmp((M_gr+mi)->shifr,str,8)){if(n_mi!= -1)n_mi= -2;else n_mi=mi;}
   if(n_mi== -1) {if(str[0]!=' ') eprintf(GRAY_,StrMesIndb[21],str,ptr_obj->cipher); continue;}
   if(n_mi== -2){ eprintf(GRAY_,StrMesIndb[20],str,ptr_obj->cipher); continue;}
   *(ptr_obj->nom_gr_g+n_mi1)=n_mi;
   n_mi1++;
  }
  ptr_obj->n_gr_g = n_mi1;
 }
exit_fr:
 close(hd);
}
//-------------------------------------------------------------------
#if (KONTUR)
void in_gr_cont(void)
{
 word_s i,j,ld_zap,ld_contr,ld_tip;
 gr_cont * p_gr_c;
 char *Basa,str[256];//,str1[9];

 if(Basa=(char *)CreateLoadDbf(NameFile[9]))
 {
  gr_c_n=GetCountItDbf(Basa);
  gr_c_p = (gr_cont *)calloc(gr_c_n, sizeof(gr_cont));
  if(gr_c_p == NULL) kz_mem(inputdb,__LINE__);

  for(i=0,p_gr_c=gr_c_p; i < gr_c_n; i++,p_gr_c++)
  {
   GetFieldItDbf(Basa,i,"SHIFR",p_gr_c->cipher);
   GetFieldItDbf(Basa,i,"NAME",p_gr_c->name);
   for(j=0;j < 8;j++)
   {
    sprintf(str,"SHIFR_P%d",j+1);
    GetFieldItDbf(Basa,i,str,p_gr_c->ciph_par[j]);
    ld_tip=ChekNamePasport(p_gr_c->ciph_par[j],&ld_contr,&ld_zap);
    if(ld_tip==-1)
     {eprintf(GRAY_,StrMesIndb[7],p_gr_c->ciph_par[j],p_gr_c->cipher);
      p_gr_c->nomcontr[j]=0;p_gr_c->type_sert[j]=EMPTY;p_gr_c->nomsert[j]=0; continue;
     }
    if(ld_tip==-2)
     {eprintf(GRAY_,StrMesIndb[8],p_gr_c->ciph_par[j],p_gr_c->cipher);
      p_gr_c->nomcontr[j]=0;p_gr_c->type_sert[j]=EMPTY;p_gr_c->nomsert[j]=0; continue;
     }
    p_gr_c->nomcontr[j]=ld_contr;p_gr_c->type_sert[j]=ld_tip;p_gr_c->nomsert[j]=ld_zap;
   }
  }
  DeleteDbf(Basa);

//  if((h_ed = sopen(NameFile[31],O_BINARY|O_RDWR,SH_DENYNO)) == -1)
//  {
//   h_ed = sopen(NameFile[31],O_BINARY|O_RDWR|O_CREAT,SH_DENYNO,S_IWRITE);
//   if((ed_doc=(edit_doc *)malloc(sizeof(edit_doc))) == NULL) kz_mem(inputdb,__LINE__);
//   memset(ed_doc,0,sizeof(edit_doc));
//   for (i=0,p_gr_c=gr_c_p,j=0; i < gr_c_n; i++ ,p_gr_c++)
//   {
//    if(!memcmp(p_gr_c->cipher,StrMesIndb[9],5))
//    {
//     lseek(h_ed, (long)sizeof(edit_doc) * j, SEEK_SET);
//     memcpy(ed_doc->cipher,p_gr_c->cipher,9);

//     pa_e=(c_ptr+p_gr_c->nomcontr[0])->a_ptr+p_gr_c->nomsert[0];
//     if(pa_e->type_mech!=M_INP && (p_alg+pa_e->nomin_var)->proc==4) ed_doc->flag=1;   //!!
//     else ed_doc->flag=0;
//     write(h_ed,(byte *)ed_doc,sizeof(edit_doc));
//     j++;
//    }
//   }
//   free(ed_doc);
//  }
//  close (h_ed);
 }
}
#endif
//-------------------------------------------------------------------
#if (PROTOC)
#if (!AL_AN)
void in_gr_nr(void)
{
 word_s i,j,work_i;
 gr_nr * p_gr_nr;
 analog *a_ptr;

 if((fh=open_fh(NameFile[1],1)) != -1)
 {
  N_gr_nr = *(word_s*)(descr + 4);      // количество записей
  gr_nr_p = (gr_nr *)calloc(N_gr_nr, sizeof(gr_nr));
  if(gr_nr_p == NULL) kz_mem(inputdb,__LINE__);

  for(i=0,p_gr_nr=gr_nr_p; i < N_gr_nr; i++,p_gr_nr++)
  {
   read(fh, recfil, lenrec);
   x_db = recfil;

   strncpy(p_gr_nr->cipher, (x_db = recfil + 1), 9);
   strncpy(p_gr_nr->ciph_gl, (x_db += 9), 9);
   sscanf(x_db+= 9, "%1hd", &work_i);        p_gr_nr->n_con = work_i;
   sscanf(z_db(x_db+= 1,4), "%4hd", &work_i);   p_gr_nr->n_gl = work_i;
   sscanf(x_db+= 4, "%1hd", &work_i);        p_gr_nr->kol_d = work_i;

   for(j=0, x_db -= 3; j < 8; j++)
   {
    strncpy(p_gr_nr->ciph_d[j], (x_db += 4), 9);
    sscanf(x_db+= 9,"%1hd", &work_i);  p_gr_nr->n_con_d[j]=(byte)work_i;
    sscanf(z_db(x_db+= 1,4),"%4hd", &p_gr_nr->n_d[j]);
   }
   sscanf(x_db+= 4,"%1hd", &work_i);        p_gr_nr->kol_a = work_i;

   for(j=0, x_db -= 3; j < 8; j++)
   {
    strncpy(p_gr_nr->ciph_a[j], (x_db += 4), 9);
    sscanf(x_db+= 9,"%1hd", &work_i);  p_gr_nr->n_con_a[j]=(byte)work_i;
    sscanf(z_db(x_db+= 1,4),"%4hd", &p_gr_nr->n_a[j]);
   }
    }
    free(recfil);
    close(fh);
  }
}
#endif
//-------------------------------------------------------------------

void in_gr_tex_g(char *tg, char *fg)
{
  word_s i,j,gr_num,work_i,hn_g;
  char  *x, *x1, *x2,work_c[5] = "    ";
  struct fgtg_prt  fgtg;    // запись файла участков

  if((fh=open_fh(tg,1)) != -1)
  {
    gr_num = *(word_s *)(descr + 4);     // количество записеи(участков)

    if(!gr_num) remove(fg);
    else
    {
      hn_g=sopen(fg,O_BINARY|O_WRONLY|O_CREAT|O_TRUNC,SH_DENYWR,S_IWRITE);

      for(i = 0; i < gr_num; i++ )

      {    // НАЧАЛО ЦИКЛА ПО УЧАСТКАМ
        read(fh, recfil, lenrec);
        x = recfil;
        x++;
        strncpy(fgtg.gr_cipher, x , 9);         // шифр участка
        strncpy(fgtg.gr_name, (x += 9) , 29);  // наименование участка
        sscanf(z_db(x+= 29,2),"%2hd", &work_i);

        fgtg.k_par = (byte)work_i;      // количество паpаметpов участка

        x += 2; x += 9;
        x1 = x;       // адрес номера контроллера
        x2 = x + 1;   // адрес номера записи в контроллере

        for(j = 0; j < fgtg.k_par; j++)
        { // НАЧАЛО ЦИКЛА ПО ПАPАМЕТPАМ УЧАСТКА
          sscanf(x1, "%1hd", &work_i);   // номеp контpоллеpа
          fgtg.adres[j].nomer_c = work_i;
          strncpy(work_c, x2 , 4);  // номеp паpаметpа в контpоллеpе
          fgtg.adres[j].nomer_a = atoi(work_c);
          x1 += 14; x2 += 14;
        }     // КОНЕЦ  ЦИКЛА ПО ПАPАМЕТPАМ УЧАСТКА

        write(hn_g,(byte*)&fgtg,sizeof(fgtg));  // запись файла участков
      }     // КОНЕЦ  ЦИКЛА ПО УЧАСТКАМ
      close(hn_g);
    }
    free(recfil);
    close(fh);
  }
  else remove(fg);
}
#endif
//-------------------------------------------------------------------
#if (GRAFIK)
void in_gr_graficov()
{
 controller * ptr_c;
 word_s i,j,n;
 word_s ld_zap,ld_contr,ld_tip;
 char sss[10];
 char *Basa,str[256];//,str1[9];

 if(Basa=(char *)CreateLoadDbf(NameFile[10]))
 {
  gr_g_n=GetCountItDbf(Basa);
  M_gr = (g_graf *)calloc(gr_g_n, sizeof(g_graf));
  if(M_gr == NULL) kz_mem(inputdb,__LINE__);
  for(i = 0; i < gr_g_n; i++)                // НАЧАЛО ЦИКЛА ПО ГPУППАМ
  {
   GetFieldItDbf(Basa,i,"SHIFR",(M_gr+i)->shifr);
   GetFieldItDbf(Basa,i,"NAME",(M_gr+i)->name);
   for(j=0;j < Max_K_par;j++)
   {
    sprintf(str,"SHIFR_P%d",j+1);
    GetFieldItDbf(Basa,i,str,sss);
    ld_tip=ChekNamePasport(sss,&ld_contr,&ld_zap);
    if(ld_tip== -1)
    {eprintf(GRAY_,StrMesIndb[10],sss,(M_gr+i)->shifr); (M_gr+i)->tip[j]=EMPTY; continue; }
    if(ld_tip== -2)
    {eprintf(GRAY_,StrMesIndb[11],sss,(M_gr+i)->shifr); (M_gr+i)->tip[j]=EMPTY; continue; }
    if(ld_tip==DIGIT)
    {eprintf(GRAY_,StrMesIndb[12],sss,(M_gr+i)->shifr); (M_gr+i)->tip[j]=EMPTY; continue; }

    ptr_c = c_ptr + ld_contr; (M_gr+i)->tip[j]=ld_tip;
    (M_gr+i)->ptr_a[j] = ptr_c->a_ptr + ld_zap;
    (M_gr+i)->n_buf[j]=0;
    for(n=0,ptr_c=c_ptr;n<ld_contr;n++,ptr_c++)(M_gr+i)->n_buf[j] += ptr_c->num_ap;
    (M_gr+i)->n_buf[j] += ld_zap;

    sprintf(str,"NO_%d",j+1);
    GetFieldItDbf(Basa,i,str,sss); (M_gr+i)->tn_o[j]=atof(sss);
    sprintf(str,"NV_%d",j+1);
    GetFieldItDbf(Basa,i,str,sss); (M_gr+i)->tv_o[j]=atof(sss);
   }
  }
  DeleteDbf(Basa);
 }
}
#endif
//-------------------------------------------------------------------

void koeff_sc(analog *a_ptr)
{
   if(a_ptr->type_sc == SC_SQRT)
     a_ptr->k_scale=(a_ptr->max_sc-a_ptr->min_sc)/(float)sqrt((double)ADC_SC);
   else
     a_ptr->k_scale = (a_ptr->max_sc - a_ptr->min_sc) / ADC_SC;
   if(a_ptr->k_scale <= 0) a_ptr->nolog = 1;      // логич. запpет обpаб.
}
//-------------------------------------------------------------------

word_s setting(analog *a_ptr,float work_f)
{
   if(a_ptr->k_scale==0 || work_f==0 || (work_f-a_ptr->min_sc) < 0)  return 0;

   if(a_ptr->type_sc == SC_SQRT)
        return
         (word_s)(((work_f-a_ptr->min_sc)*(work_f-a_ptr->min_sc)*ADC_SC) /
             ((a_ptr->max_sc-a_ptr->min_sc)*(a_ptr->max_sc-a_ptr->min_sc)));
   else
        return
         (word_s)((work_f-a_ptr->min_sc)*ADC_SC/(a_ptr->max_sc-a_ptr->min_sc));
}
//-------------------------------------------------------------------

char *z_db(char *x_db,int len)
{
   char *y_db;

   y_db=x_db;
   while(len && *y_db == ' '){ *y_db++ = '0';len--;}
   if(len && *x_db=='0' && *y_db < '0') { *x_db = *y_db; *y_db = '0'; }
   return x_db;
}
//-------------------------------------------------------------------
#if (VIEW)
void in_view(void)
{
 word_s i,j,jj,s,h,dx,dy,dx1,dy1,k=0,ld_zap,ld_contr,ld_tip;

 str_ov *str_ov_p, *p_str_ovt;
 par_ov *par_ov_p,*p_par_ovt;
 controller *ptr_c;
 char sss[10],sss1[10];
 char *Basa,str[256];

 if((Basa=(char *)CreateLoadDbf(NameFile[13]))== NULL) return;
 k_str_ov=GetCountItDbf(Basa);
 p_str_ov=(str_ov *)calloc(k_str_ov,sizeof(str_ov));
 if(p_str_ov == NULL) kz_mem(inputdb,__LINE__);

 for(i=0,str_ov_p=p_str_ov; i<k_str_ov; i++,str_ov_p++)
 {
  str_ov_p->kol=0;
  str_ov_p->perv=k;
  GetFieldItDbf(Basa,i,"N_ROW",str); str_ov_p->ver=str_ov_p->dy_g=atoi(str);
  GetFieldItDbf(Basa,i,"N_CLN",str); str_ov_p->gor=str_ov_p->dx_g=atoi(str);
  for(j=0;j<str_ov_p->dy_g;j++)
   for(jj=0;jj<str_ov_p->dx_g;jj++)
   {
    sprintf(str,"SH_%d",jj+1+6*j); GetFieldItDbf(Basa,i,str,sss1);
    ld_tip=ChekNamePasport(sss1,&ld_contr,&ld_zap);
    if(ld_tip==ANALOG || ld_tip == DIGIT) { k++; str_ov_p->kol++;}
   }
  j=565-4*(str_ov_p->dx_g+1);j=j/str_ov_p->dx_g;str_ov_p->dx_g=j-8;
  j=304-4*(str_ov_p->dy_g+1);j=j/str_ov_p->dy_g;str_ov_p->dy_g=j-27;
  str_ov_p->koef=(float)(str_ov_p->dy_g-1)/ADC_SC;
  str_ov_p->koef1=(float)(str_ov_p->dy_g-2)/(ADC_SC*0.4);
 }

 k_par_ov=0;p_str_ovt=p_str_ov;
 for(i=0;i<k_str_ov;i++,p_str_ovt++)k_par_ov+= p_str_ovt->kol;
 p_par_ov=(par_ov *)calloc(k_par_ov,sizeof(par_ov));
 if(p_par_ov == NULL) kz_mem(inputdb,__LINE__);

 for(i=0,par_ov_p=p_par_ov; i<k_str_ov; i++)
 {
  GetFieldItDbf(Basa,i,"SHIFR",sss);
  GetFieldItDbf(Basa,i,"N_ROW",str); h=atoi(str);
  GetFieldItDbf(Basa,i,"N_CLN",str); s=atoi(str);
  j=565-4*(s+1);dx=j/s+4;dx1=4+(j%s)/2;
  j=304-4*(h+1);dy=j/h+4;dy1=34+(j%h)/2;

  for(jj=0;jj<s;jj++)
   for(j=0;j<h;j++)
   {
    sprintf(str,"SH_%d",jj+1+6*j); GetFieldItDbf(Basa,i,str,sss1);
    ld_tip=ChekNamePasport(sss1,&ld_contr,&ld_zap);
    if(ld_tip== -1) { eprintf(GRAY_,StrMesIndb[13],sss1,sss); continue; }
    if(ld_tip== -2) { eprintf(GRAY_,StrMesIndb[14],sss1,sss); continue; }
    if(ld_tip== EMPTY) continue;
    par_ov_p->nomcontr=ld_contr;
    par_ov_p->type=ld_tip;
    par_ov_p->nom=ld_zap;
    par_ov_p->nx=dx1+jj*dx;
    par_ov_p->ny=dy1+j*dy;
    par_ov_p++;
   }
 }
 for(i=0,p_par_ovt=p_par_ov;i<k_par_ov;i++,p_par_ovt++)
 {
  p_par_ovt->nomer=0;
  for(j=0,ptr_c=c_ptr;j<p_par_ovt->nomcontr;j++,ptr_c++) p_par_ovt->nomer+=ptr_c->num_ap;
  p_par_ovt->nomer+=p_par_ovt->nom;
 }
 DeleteDbf(Basa);
}
#endif
//-------------------------------------------------------------------
#if (SPEAK)
void in_speak(void)
{
 extern struct sp_sk *speak_s;
 extern struct sp_sk sp_s;
 extern speak_ds *sp_sert;              // ук-ль на начало м-ва описателей pеч.сигн*/
 word_s i,ld_zap,ld_contr,ld_tip,ki;
 char sss[10];
 char *Basa;

 speak_ds *p_sp;
 speak_s=&sp_s;

 if((Basa=(char *)CreateLoadDbf(NameFile[15]))== NULL) return;
 speak_s->num_s=GetCountItDbf(Basa);
 for(i=0,ki=0; i < speak_s->num_s; i++)
 {
  GetFieldItDbf(Basa,i,"SHIFR",sss);
  ld_tip=ChekNamePasport(sss,&ld_contr,&ld_zap);
  if(ld_tip== -1) { eprintf(GRAY_,StrMesIndb[24],sss); continue; }
  if(ld_tip== -2) { eprintf(GRAY_,StrMesIndb[25],sss); continue; }
  if(ld_tip== EMPTY) continue;
  ki++;
 }
 speak_s->num_s=ki;
 sp_sert=(speak_ds *)calloc(speak_s->num_s, sizeof(speak_ds));
 if(sp_sert == NULL) kz_mem(inputdb,__LINE__);

 for(i=0,ki=0,p_sp=sp_sert; i < speak_s->num_s; i++,p_sp++)
 {
  GetFieldItDbf(Basa,i,"SHIFR",sss);
  ld_tip=ChekNamePasport(sss,&ld_contr,&ld_zap);
  if(ld_tip== -1) continue;
  if(ld_tip== -2) continue;
  if(ld_tip== EMPTY) continue;
  p_sp->nomcontr=ld_contr; p_sp->type_sert=ld_tip; p_sp->nomsert=ld_zap;
  GetFieldItDbf(Basa,i,"COD_O",sss); p_sp->cod_o=atoi(sss);
  GetFieldItDbf(Basa,i,"PRIORITET",sss);p_sp->priority=atoi(sss);
  GetFieldItDbf(Basa,i,"TEXT_S",p_sp->text_s);
  GetFieldItDbf(Basa,i,"LNG",sss); p_sp->lng=0;
  if(!strcmp(sss,"ru")) p_sp->lng=0;
  if(!strcmp(sss,"ua")) p_sp->lng=1;
//      for(j=78;j>-1 ;j--) {
//        if(p_sp->text_s[j]!=' ') {
//          p_sp->text_s[j+1]=0x0D;
//          p_sp->text_s[j+2]=0x00;
//          break;
//        }
 }
 speak_s->number_s=0; speak_s->quit=0;
 DeleteDbf(Basa);
}
#endif
//-------------------------------------------------------------------
#if (EDITQ * !ALG)
void in_edit_q(void)            // ввод описания корректируемых параметров
{
  word_s i,work_i;
  edit_q * ed;
  byte work_c[5]="    ";
  byte work_c2[8]= "       ";

  byte work_c1[9]= "        ";

  if((fh=open_fh(NameFile[25],1)) != -1) {
    e_num = *(word_s*)(descr + 4);       // количество записей
    e_ptr = (edit_q *)calloc(e_num, sizeof(edit_q));
    if(e_ptr == NULL) kz_mem(inputdb,__LINE__);

    for(i=0,ed=e_ptr; i < e_num; i++,ed++) {
      read(fh, recfil, lenrec);
      x_db = recfil+1;

      strncpy(ed->cipher_q, x_db, 9);
      sscanf((x_db += 9), "%1hd", &work_i);  ed->nc_q = (byte)work_i;
      strncpy(work_c, (x_db += 1), 4);      ed->nz_q = atoi(work_c);
      strncpy(ed->cipher_t, x_db +=4, 9);
      sscanf((x_db += 9), "%1hd", &work_i);  ed->nc_t = (byte)work_i;
      strncpy(work_c, (x_db += 1), 4);      ed->nz_t = atoi(work_c);
      strncpy(ed->cipher_p, x_db +=4, 9);
      sscanf((x_db += 9), "%1hd", &work_i);  ed->nc_p = (byte)work_i;
      strncpy(work_c, (x_db += 1), 4);      ed->nz_p = atoi(work_c);
      strncpy(work_c1, (x_db += 4), 9);     ed->r_f = atof(work_c1);
      strncpy(work_c2, (x_db += 9), 8);     ed->t_0 = atof(work_c2);
      strncpy(work_c2, (x_db += 8), 8);     ed->p_0 = atof(work_c2);
      strncpy(work_c1, (x_db += 8), 9);     ed->r_0 = atof(work_c1);
      sscanf((x_db += 9), "%1hd", &work_i);  ed->env = (byte)work_i;
    }
    free(recfil);
    close(fh);
  }
}
#endif
//-------------------------------------------------------------------
#if (SVTAB)
void in_sv_tabl()
{
 word_s i,j,jj,jjj,kk,j1,ver,gor,gor1,ver1,k=0,ld_zap,ld_contr,ld_tip;
 str_tab *str_tab_p;
 win_tab *win_tab_p;
 par_tab *par_tab_p;
 controller *ptr_c;
 char sss[10],sss1[10];
 char *Basa,str[256];

 if((Basa=(char *)CreateLoadDbf(NameFile[14]))== NULL) return;
 k_str_tab=GetCountItDbf(Basa);
 p_str_tab=(str_tab *)calloc(k_str_tab,sizeof(str_tab));
 if(p_str_tab == NULL) kz_mem(inputdb,__LINE__);
 for(i=0,str_tab_p=p_str_tab; i<k_str_tab; i++,str_tab_p++)
 {
  str_tab_p->kolwin=0;
  str_tab_p->nomwin=k;
  GetFieldItDbf(Basa,i,"N_ROW",str); str_tab_p->verwin=atoi(str);
  GetFieldItDbf(Basa,i,"N_CLN",str); str_tab_p->gorwin=atoi(str);
  if(str_tab_p->verwin*str_tab_p->gorwin)
  {
   for(j=0;j<str_tab_p->verwin;j++)
    for(jj=0;jj<str_tab_p->gorwin;jj++)
    {
     for(jjj=0,kk=0;jjj<5;jjj++)
     {
      sprintf(str,"SH_%d_%d",jj+1+4*j,jjj+1); GetFieldItDbf(Basa,i,str,sss1);
      if(ChekNamePasport(sss1,&ld_contr,&ld_zap)==ANALOG)kk++;
     }
     if(kk){ k++;str_tab_p->kolwin++; }
    }
   str_tab_p->verwin=305/str_tab_p->verwin;
   str_tab_p->gorwin=639/str_tab_p->gorwin;
   str_tab_p->dset=(float)(str_tab_p->verwin-12)/5;
   str_tab_p->koef=(float)(str_tab_p->verwin-12)/ADC_SC;
  }
 }

 k_win_tab=(p_str_tab+k_str_tab-1)->kolwin+(p_str_tab+k_str_tab-1)->nomwin+1;
 p_win_tab=(win_tab *)calloc(k_win_tab,sizeof(win_tab));
 if(p_win_tab == NULL) kz_mem(inputdb,__LINE__);

 for(k=0,i=0,win_tab_p=p_win_tab; i<k_str_tab; i++)
 {
  GetFieldItDbf(Basa,i,"N_ROW",str); ver=atoi(str);
  GetFieldItDbf(Basa,i,"N_CLN",str); gor=atoi(str);
  if(ver*gor)
  {
   ver1=305/ver; gor1=639/gor;
   for(j=0;j<ver;j++)
    for(jj=0;jj<gor;jj++)
    {
     kk=0;j1=k;
     for(jjj=0;jjj<5;jjj++)
     {
      sprintf(str,"SH_%d_%d",jj+1+4*j,jjj+1); GetFieldItDbf(Basa,i,str,sss1);
      if(ChekNamePasport(sss1,&ld_contr,&ld_zap)==ANALOG){ k++; kk++; }
     }
     if(kk)
     {
      sprintf(str,"NAMEW_%d",jj+1+4*j); GetFieldItDbf(Basa,i,str,win_tab_p->naimwin);
      win_tab_p->nompar=j1; win_tab_p->kolpar=kk;
      win_tab_p->nx=gor1*jj; win_tab_p->ny=ver1*j+30;
      win_tab_p++;
     }
    }
  }
 }
 k_win_tab--;

 k_par_tab=(p_win_tab+k_win_tab-1)->kolpar+(p_win_tab+k_win_tab-1)->nompar+1;
 p_par_tab=(par_tab *)calloc(k_par_tab,sizeof(par_tab));
 if(p_par_tab == NULL) kz_mem(inputdb,__LINE__);

 for(i=0,par_tab_p=p_par_tab; i<k_str_tab; i++)
 {
  GetFieldItDbf(Basa,i,"SHIFR",sss);
  GetFieldItDbf(Basa,i,"N_ROW",str); ver=atoi(str);
  GetFieldItDbf(Basa,i,"N_CLN",str); gor=atoi(str);
  if(ver*gor)
  {
   for(j=0;j<ver;j++)
    for(jj=0;jj<gor;jj++)
     for(jjj=0;jjj<5;jjj++)
     {
      sprintf(str,"SH_%d_%d",jj+1+4*j,jjj+1); GetFieldItDbf(Basa,i,str,sss1);
      ld_tip=ChekNamePasport(sss1,&ld_contr,&ld_zap);
      if(ld_tip== -1){eprintf(GRAY_,StrMesIndb[15],sss1,sss); continue;}
      if(ld_tip== -2){eprintf(GRAY_,StrMesIndb[16],sss1,sss); continue;}
      if(ld_tip==DIGIT){eprintf(GRAY_,StrMesIndb[17],sss1,sss); continue; }
      if(ld_tip==EMPTY) continue;
      sprintf(str,"OBJ_%d_%d",jj+1+4*j,jjj+1); GetFieldItDbf(Basa,i,str,par_tab_p->naim);
      par_tab_p->nomcontr=ld_contr; par_tab_p->nompar=ld_zap;
      par_tab_p->nomer=jjj; par_tab_p++;
     }
  }
 }
 k_par_tab--;

 for(i=0;i<k_par_tab;i++)
 {
  (p_par_tab+i)->nomar=0;
  for(j=0,ptr_c=c_ptr;j<(p_par_tab+i)->nomcontr;j++,ptr_c++) (p_par_tab+i)->nomar+=ptr_c->num_ap;
  (p_par_tab+i)->nomar+=(p_par_tab+i)->nompar;
 }
 DeleteDbf(Basa);
}
#endif
//-------------------------------------------------------------------