
int GodCtrl = 2009;  // год по который увол не принимать
var TablLS;



   int Rec1 = 11000;
   double PodN[Rec1];   //массив подразделений
   double DolN[Rec1];   //массив должностей
   int    KpsN[Rec1];
   int    LgtN[Rec1];   //массив льготных профессий
   string LgNa[Rec1];
   string LgKo[Rec1];

   int Rec2 = 1000;
   string SlovDlg[Rec2];   //массив должностей  TEXT  из SLOVAR
   int    CodeDlg[Rec2];   //массив должностей  KOD   из SLOVAR
   string SlovKPS[Rec2];   // массив КПС  TEXT  из SLOVAR
   int    CodeKPS[Rec2];   // массив КПС  KOD   из SLOVAR
  // string SlovLgt[Rec2];   // массив льгот  TEXT  из SLOVAR
  // int    CodeLgt[Rec2];   // массив льгот  KOD   из SLOVAR

   int ndx1=0, ndx2=0;
   int ndx11=0, ndx111=0;

   string Podr, Dlgn, Kps;
   string Dolgn, KodPS;
  // string Lgt, LgtS;


ReadDBF()     // адрес передаваемой таблицы
{
   
   // создаем объекты для таблиц

   // таблица для накапливания информации по отдельным ЛС, которые
   TablLS   = CreateObject("CurPrnTbl");

   // одна таблица - для dbf-файла, из которого осуществляем прием
   var TablDbf  = CreateObject("CurPrnTbl");
   TablDbf.InitialNameFile("D:\\bd01.dbf");   //(static_cast_to_string(NameDbf));
  // 19.01.2011
   var Tabl3Dbf  = CreateObject("CurPrnTbl");
   Tabl3Dbf.InitialNameFile("D:\\bd03.dbf");   

   var Tabl4Dbf  = CreateObject("CurPrnTbl");
   Tabl4Dbf.InitialNameFile("D:\\slovar.dbf");   


   // Если у нас получилась всего одна строка да и та пустая
   // (т.е. в файле нет информации), то выходим
   if ( TablDbf.Count_Rcr()<2 &&  TablDbf.Check_Empty_Rcr(0)==-1 )
      return ESC;
   // определим номера столбцов dbf-файла, по их именам
   if ( !InitNumFldDbfBrig(TablDbf) )
      return ESC;

   if ( !InitNumFldDbf3(Tabl3Dbf) )
      return ESC;

   if ( !InitNumFldDbf4(Tabl4Dbf) )
      return ESC;



   // создание временных массивов на основе информации из BD03
   for ( int RcrDbf3=0; RcrDbf3<Tabl3Dbf.Count_Rcr(); ++RcrDbf3 )
    {
     long TabN   = atol(Tabl3Dbf.Text(FldDbf3[idxDbf3TABN  ],RcrDbf3));

     PodN[TabN]  = atol(Tabl3Dbf.Text(FldDbf3[idxDbf3PODR  ],RcrDbf3));
     DolN[TabN]  = atol(Tabl3Dbf.Text(FldDbf3[idxDbf3DLGN  ],RcrDbf3));
     KpsN[TabN]  = atoi(Tabl3Dbf.Text(FldDbf3[idxDbf3KPOS  ],RcrDbf3));
     LgtN[TabN]  = atoi(Tabl3Dbf.Text(FldDbf3[idxDbf3LGOT  ],RcrDbf3));
     LgNa[TabN]  = Tabl3Dbf.Text(FldDbf3[idxDbf3LGNA  ],RcrDbf3);
     LgKo[TabN]  = Tabl3Dbf.Text(FldDbf3[idxDbf3LGKO  ],RcrDbf3);

    }


   // создание временного массива на основе информации из SLOVAR
   for ( int RcrDbf4=0; RcrDbf4<Tabl4Dbf.Count_Rcr(); ++RcrDbf4 )
    {
     //int RazN   = atoi(Tabl4Dbf.Text(FldDbf4[idxDbf4RAZD  ],RcrDbf4));
     //int RecN   = atoi(Tabl4Dbf.Text(FldDbf4[idxDbf4RECV  ],RcrDbf4));
     int RazN   = atoi(Tabl4Dbf.TextS("NRAZD",RcrDbf4));
     int RecN   = atoi(Tabl4Dbf.TextS("NRECV",RcrDbf4));
     int Cod    = atoi(Tabl4Dbf.TextS("KOD",RcrDbf4));

     if (( RazN == 3 ) && ( RecN == 5 ))   // для должн из  BD03
       {
        ++ndx1;
        //CodeDlg[ndx1] = atoi(Tabl4Dbf.Text(FldDbf4[idxDbf4COD   ],RcrDbf4));
        //SlovDlg[ndx1] = Tabl4Dbf.Text(FldDbf4[idxDbf4TXSL  ],RcrDbf4);
        CodeDlg[ndx1]  = Cod;
        SlovDlg[ndx1]  = Tabl4Dbf.TextS("TEXT",RcrDbf4);
       }

     if (( RazN == 3 ) && ( RecN == 11 ))   // для КПС из  BD03
       {
        ++ndx11;
        CodeKPS[ndx11] = Cod;
        SlovKPS[ndx11] = Tabl4Dbf.TextS("TEXT",RcrDbf4);
       }

    // if (( RazN == 3 ) && ( RecN == 16 ))   // для ___ из  BD03
    //   {
    //    ++ndx1;
    //    CodeLgt[ndx1] = Cod;
    //    SlovLgt[ndx1] = Tabl4Dbf.Text(FldDbf4[idxDbf4TXSL  ],RcrDbf4);
    //   }


    }
    


   // Начинаем обработку файла построчно
   for ( int RcrDbf=0; RcrDbf<TablDbf.Count_Rcr(); ++RcrDbf )
   {
      // Берем  данные из строки dbf-файла

      long TN   = atol(TablDbf.Text(FldDbf[idxDbfTABN  ],RcrDbf));
      string FAM   =    TablDbf.Text(FldDbf[idxDbfFAM   ],RcrDbf);
         string fam;  fam = Fam(FAM);
      string IM    =    TablDbf.Text(FldDbf[idxDbfIM    ],RcrDbf);
         string im;   im  = Fam(IM);
      string OT    =    TablDbf.Text(FldDbf[idxDbfOT    ],RcrDbf);
         string ot;   ot  = Fam(OT);
      string DR    =    TablDbf.Text(FldDbf[idxDbfDR    ],RcrDbf);
      string POL   =    TablDbf.Text(FldDbf[idxDbfPOL   ],RcrDbf);
      string DatSt =    TablDbf.Text(FldDbf[idxDbfDatSt ],RcrDbf);
      string KolSt =    TablDbf.Text(FldDbf[idxDbfKolSt ],RcrDbf);
      string Vys   =    TablDbf.Text(FldDbf[idxDbfVys   ],RcrDbf);
      string DtVyd =    TablDbf.Text(FldDbf[idxDbfDtVyd ],RcrDbf);
      string SerNm =    TablDbf.Text(FldDbf[idxDbfSerNm ],RcrDbf);
      string Kem   =    TablDbf.Text(FldDbf[idxDbfKem   ],RcrDbf);
      string NomSS =    TablDbf.Text(FldDbf[idxDbfNomSS ],RcrDbf);
      string InvGr =    TablDbf.Text(FldDbf[idxDbfInvGr ],RcrDbf);
      string InvNa =    TablDbf.Text(FldDbf[idxDbfInvNa ],RcrDbf);
      string InvKo =    TablDbf.Text(FldDbf[idxDbfInvKo ],RcrDbf);
      string DtRab1=    TablDbf.Text(FldDbf[idxDbfDtRab1],RcrDbf);
     // string DtRab2=    TablDbf.Text(FldDbf[idxDbfDtRab2],RcrDbf);
      string DtUv  =    TablDbf.Text(FldDbf[idxDbfDtUv  ],RcrDbf);  
      string INN   =    TablDbf.Text(FldDbf[idxDbfINN   ],RcrDbf);

      string GodV  =    TablDbf.Text(FldDbf[idxDbfGV    ],RcrDbf);

      string UvPr  =    TablDbf.Text(FldDbf[idxDbfUVPR  ],RcrDbf);
        if ( atoi(UvPr) == 24 ) UvPr =  1;  // 05.02.2011 _____!!!!!!!!!!__проверить____

     // string Prof  =    TablDbf.Text(FldDbf[idxDbfPROF  ],RcrDbf);
      string SemP  =    TablDbf.Text(FldDbf[idxDbfSEMP  ],RcrDbf);
      string Katg  =    TablDbf.Text(FldDbf[idxDbfKATG  ],RcrDbf);

      string Ind   =    TablDbf.Text(FldDbf[idxDbfIND   ],RcrDbf); FreeSpaceString(Ind,3,"");
      string Reg   =    TablDbf.Text(FldDbf[idxDbfREG   ],RcrDbf); FreeSpaceString(Reg,3,"");
      string Raj   =    TablDbf.Text(FldDbf[idxDbfRAJ   ],RcrDbf); FreeSpaceString(Raj,3,"");
      string Gor   =    TablDbf.Text(FldDbf[idxDbfGOR   ],RcrDbf); FreeSpaceString(Gor,3,"");
      string Pun   =    TablDbf.Text(FldDbf[idxDbfPUN   ],RcrDbf); FreeSpaceString(Pun,3,"");
      string Uli   =    TablDbf.Text(FldDbf[idxDbfULI   ],RcrDbf); FreeSpaceString(Uli,3,"");
      string Dom   =    TablDbf.Text(FldDbf[idxDbfDOM   ],RcrDbf); FreeSpaceString(Dom,3,"");
      string Kor   =    TablDbf.Text(FldDbf[idxDbfKOR   ],RcrDbf); FreeSpaceString(Kor,3,"");
      string Kva   =    TablDbf.Text(FldDbf[idxDbfKVA   ],RcrDbf); FreeSpaceString(Kva,3,"");
     
      string MRojd   =    TablDbf.Text(FldDbf[idxDbfMROJ   ],RcrDbf); FreeSpaceString(MRojd,3,"");

      int PrZap = 1;  //признак записи в таблицу
      string GodUv;   GodUv = God1(DtUv);

      if (( atoi(GodUv) <= GodCtrl ) && ( atoi(GodUv) != 0))  PrZap = 0;

      char SP[3];
      if ( atoi(SemP) == 1 ) sprintf(SP,"Ж"); 
      if ( atoi(SemP) == 2 ) sprintf(SP,"Х");
      if ( atoi(SemP) == 3 ) sprintf(SP,"Р");
      if ( atoi(SemP) == 4 ) sprintf(SP,"В");
     
     //выборка из BD03.DBF информации по ТабНом TN

     Podr   = PodN[TN];
     Dlgn   = DolN[TN];
     Kps    = KpsN[TN];
     
     //string lgpr;
     char lgpr[20];
     string lgna;
     string lgko;

     for ( ndx2=0; ndx2<ndx1; ++ndx2 )
        {
         if ( CodeDlg[ndx2] == Dlgn )  Dolgn = static_cast_to_string(SlovDlg[ndx2]);     
        }

     if ( atoi(Kps) != 0 )
       {
        for ( ndx2=0; ndx2<ndx11; ++ndx2 )  
         {
          if ( CodeKPS[ndx2] == Kps )  KodPS = static_cast_to_string(SlovKPS[ndx2]);
         }
        if ( LgtN[TN] == 1 )  sprintf(lgpr,"27-1");  
        if ( LgtN[TN] == 2 )  sprintf(lgpr,"27-2"); 
        if ( LgtN[TN] == 5 )  sprintf(lgpr,"27-3");
           
        lgna    = Dat1(LgNa[TN]);
        lgko    = Dat1(LgKo[TN]);

       }
     else  KodPS  = static_cast_to_string(Kps);  //для обнуления   KodPS
    

      if ((TN != 0) && (PrZap == 1))
        {
         int CurRcr = TablLS.Count_Rcr()-1;    //всегда добавляем в конец таблицы
         // Добавляем, если надо, строку      
         //if ( bNeedAddRcr && TablLS.Add_Rcr(CurRcr++,1)==-1 ) break;

         string dr    = Dat1(DR);
         string pol   = Sex(POL);
         string datst = Dat1(DatSt);
         string vys   = Dat1(Vys);
         string dtvyd = Dat1(DtVyd);  string psp = DatPSP(SerNm,Kem,dtvyd);
         int kdok = 21;
         string invna = Dat1(InvNa);
         string invko = Dat1(InvKo);
       if( atoi(InvGr) > 0 )  string inval = DatInv(InvGr,invko);
         string dtrab= Dat1(DtRab1);
        // string dtrab2= Dat1(DtRab2);
        // string dtrab = DatRab(dtrab1,dtrab2);
         string dtuv  = Dat1(DtUv);
         string kolst = Dat2(KolSt);

         string godv  = Dat1(GodV);

         char AdrReg[250];
         sprintf(AdrReg,"%s,%s,%s,%s,%s,%s,%s,%s,%s",
                   static_cast_to_string(Ind),
                   static_cast_to_string(Reg),
                   static_cast_to_string(Raj),
                   static_cast_to_string(Gor),
                   static_cast_to_string(Pun),
                   static_cast_to_string(Uli),
                   static_cast_to_string(Dom),
                   static_cast_to_string(Kor),
                   static_cast_to_string(Kva));

         TablLS.Add_Rcr(CurRcr,1);
         TablLS.STextS("C_FIO",CurRcr, static_cast_to_string(TN));
         TablLS.STextS("FCf",CurRcr, static_cast_to_string(fam));
         TablLS.STextS("FCi",CurRcr, static_cast_to_string(im));
         TablLS.STextS("FCo",CurRcr, static_cast_to_string(ot));
         TablLS.STextS("FCdata_r",CurRcr, static_cast_to_string(dr));
         TablLS.STextS("FCpol",CurRcr, static_cast_to_string(pol));
         TablLS.STextS("Dt_SS",CurRcr, static_cast_to_string(datst));
         TablLS.STextS("FCdata_st",CurRcr, static_cast_to_string(kolst));
         TablLS.STextS("FCdatavys",CurRcr, static_cast_to_string(vys));
         TablLS.STextS("Dt_Vyd",CurRcr, static_cast_to_string(dtvyd));
         TablLS.STextS("Ser_Nom",CurRcr, static_cast_to_string(SerNm));
         TablLS.STextS("Kem_Vyd",CurRcr, static_cast_to_string(Kem));
         TablLS.STextS("FCdoc_code",CurRcr, static_cast_to_string(kdok));
         TablLS.STextS("FCpasport",CurRcr, static_cast_to_string(psp));
         TablLS.STextS("FCstrah_n",CurRcr, static_cast_to_string(NomSS));
         TablLS.STextS("Inv_Gr",CurRcr, static_cast_to_string(InvGr));
         TablLS.STextS("Inv_Na",CurRcr, static_cast_to_string(invna));
         TablLS.STextS("Inv_Ko",CurRcr, static_cast_to_string(invko));
       if( atoi(InvGr) > 0 )  TablLS.STextS("FCd_inv",CurRcr, static_cast_to_string(inval));
         TablLS.STextS("Dt_Rab1",CurRcr, static_cast_to_string(dtrab));
       //  TablLS.STextS("Dt_Rab2",CurRcr, static_cast_to_string(dtrab2));
         TablLS.STextS("Dt_Rab",CurRcr, static_cast_to_string(dtrab));
         TablLS.STextS("FCdata_uv",CurRcr, static_cast_to_string(dtuv));
         TablLS.STextS("FCinn_fl",CurRcr, static_cast_to_string(INN));

         TablLS.STextS("FCdata_13",CurRcr, static_cast_to_string(godv));

         TablLS.STextS("FCpodr",CurRcr, static_cast_to_string(Podr));
         TablLS.STextS("FCdolgnost",CurRcr, static_cast_to_string(Dlgn));
         TablLS.STextS("NaimDolgn",CurRcr, static_cast_to_string(Dolgn));
         TablLS.STextS("DolVs",CurRcr, static_cast_to_string(ndx1));
         TablLS.STextS("CodPS",CurRcr, static_cast_to_string(KodPS));
         TablLS.STextS("CodLgPr",CurRcr, static_cast_to_string(lgpr));
         TablLS.STextS("DatLgNa",CurRcr, static_cast_to_string(lgna));
         TablLS.STextS("DatLgKo",CurRcr, static_cast_to_string(lgko));
         TablLS.STextS("KpsVs",CurRcr, static_cast_to_string(ndx11));

         TablLS.STextS("FCuvol",CurRcr, static_cast_to_string(UvPr));
        // TablLS.STextS("FCpr_souz",CurRcr, static_cast_to_string(Prof));
         TablLS.STextS("FCsem",CurRcr, static_cast_to_string(SP));
         TablLS.STextS("FCkat",CurRcr, static_cast_to_string(Katg));

         TablLS.STextS("FCadres",CurRcr, static_cast_to_string(AdrReg));

         TablLS.STextS("AdrRojd",CurRcr, static_cast_to_string(MRojd));

         CurRcr++;
        }
         // переходим к обработке следующей строки файла
      continue;
      
   }
}



int idxDbfTABN  =0,
    idxDbfFAM   =1,
    idxDbfIM    =2,
    idxDbfOT    =3,
    idxDbfDR    =4,
    idxDbfPOL   =5,
    idxDbfDatSt =6,
    idxDbfKolSt =7,
    idxDbfVys   =8,
    idxDbfDtVyd =9,
    idxDbfSerNm =10,
    idxDbfKem   =11,
    idxDbfNomSS =12,
    idxDbfInvGr =13,
    idxDbfInvNa =14,
    idxDbfInvKo =15,
    idxDbfDtRab1=16,
    idxDbfDtRab2=17,
    idxDbfDtUv  =18,
    idxDbfINN   =19,
    idxDbfGV    =20,

    idxDbfPODR  =21,
    idxDbfDLGN  =22,
    idxDbfUVPR  =23,
    idxDbfPROF  =24,
    idxDbfSEMP  =25,
    idxDbfKATG  =26,

    idxDbfIND   =27,
    idxDbfREG   =28,
    idxDbfRAJ   =29,
    idxDbfGOR   =30,
    idxDbfPUN   =31,
    idxDbfULI   =32,
    idxDbfDOM   =33,
    idxDbfKOR   =34,
    idxDbfKVA   =35,

    idxDbfMROJ   =36,

    CountIdxDbf =37;

int FldDbf[CountIdxDbf];


int idxDbf3TABN  =0,           // для BD03
    idxDbf3PODR   =1,
    idxDbf3DLGN   =2,

    idxDbf3KPOS   =3,
    idxDbf3LGOT   =4,
    idxDbf3LGNA   =5,
    idxDbf3LGKO   =6,

    CountIdxDbf3 = 7;

int FldDbf3[CountIdxDbf3];


int idxDbf4RAZD =0,           // для SLOVAR
    idxDbf4RECV   =1,
    idxDbf4COD    =2,
    idxDbf4TXSL   =3,

    CountIdxDbf4 = 4;

int FldDbf4[CountIdxDbf4];



InitNumFldDbf4(&Tabl4Dbf)
{
   FldDbf4[idxDbf4RAZD  ]=Tabl4Dbf.Find_Name_Fld("NRAZD");
   FldDbf4[idxDbf4RECV  ]=Tabl4Dbf.Find_Name_Fld("NRECV");
   FldDbf4[idxDbf4COD   ]=Tabl4Dbf.Find_Name_Fld("KOD");
   FldDbf4[idxDbf4TXSL  ]=Tabl4Dbf.Find_Name_Fld("TEXT");

   for ( int idx=0; idx<CountIdxDbf4; ++idx )
      if ( FldDbf4[idx]==-1 )
      {
         AmbaMessageBox("Нет необходимых полей в dbf-файле!","Ошибка!!!",MB_OK|MB_ICONERROR,0);
         return false;
      }
   return true;
}



InitNumFldDbf3(&Tabl3Dbf)
{
   FldDbf3[idxDbf3TABN  ]=Tabl3Dbf.Find_Name_Fld("TABN");
   FldDbf3[idxDbf3PODR  ]=Tabl3Dbf.Find_Name_Fld("P03_04");
   FldDbf3[idxDbf3DLGN  ]=Tabl3Dbf.Find_Name_Fld("P03_05");

   FldDbf3[idxDbf3KPOS  ]=Tabl3Dbf.Find_Name_Fld("P03_11"); //код позиц списка
   FldDbf3[idxDbf3LGOT  ]=Tabl3Dbf.Find_Name_Fld("P03_16"); //код услов труда
   FldDbf3[idxDbf3LGNA  ]=Tabl3Dbf.Find_Name_Fld("P03_14"); // начало льг стажа
   FldDbf3[idxDbf3LGKO  ]=Tabl3Dbf.Find_Name_Fld("P03_15"); // оконч льг стажа

   for ( int idx=0; idx<CountIdxDbf3; ++idx )
      if ( FldDbf3[idx]==-1 )
      {
         AmbaMessageBox("Нет необходимых полей в dbf-файле!","Ошибка!!!",MB_OK|MB_ICONERROR,0);
         return false;
      }
   return true;
}



InitNumFldDbfBrig(&TablDbf)
{
   FldDbf[idxDbfTABN  ]=TablDbf.Find_Name_Fld("TABN");
   FldDbf[idxDbfFAM   ]=TablDbf.Find_Name_Fld("P01_03");
   FldDbf[idxDbfIM    ]=TablDbf.Find_Name_Fld("P01_04");
   FldDbf[idxDbfOT    ]=TablDbf.Find_Name_Fld("P01_05");
   FldDbf[idxDbfDR    ]=TablDbf.Find_Name_Fld("P01_06");
   FldDbf[idxDbfPOL   ]=TablDbf.Find_Name_Fld("P01_07");
   FldDbf[idxDbfDatSt ]=TablDbf.Find_Name_Fld("P01_17");
   FldDbf[idxDbfKolSt ]=TablDbf.Find_Name_Fld("P01_16");
   FldDbf[idxDbfVys   ]=TablDbf.Find_Name_Fld("P01_18");
   FldDbf[idxDbfDtVyd ]=TablDbf.Find_Name_Fld("P01_26");
   FldDbf[idxDbfSerNm ]=TablDbf.Find_Name_Fld("P01_24");
   FldDbf[idxDbfKem   ]=TablDbf.Find_Name_Fld("P01_25");
   FldDbf[idxDbfNomSS ]=TablDbf.Find_Name_Fld("P01_31");
   FldDbf[idxDbfInvGr ]=TablDbf.Find_Name_Fld("P01_32");
   FldDbf[idxDbfInvNa ]=TablDbf.Find_Name_Fld("P01_33");
   FldDbf[idxDbfInvKo ]=TablDbf.Find_Name_Fld("P01_34");
   FldDbf[idxDbfDtRab1]=TablDbf.Find_Name_Fld("P01_23");
  // FldDbf[idxDbfDtRab2]=TablDbf.Find_Name_Fld("P01_35");
   FldDbf[idxDbfGV    ]=TablDbf.Find_Name_Fld("P01_59");
   FldDbf[idxDbfDtUv  ]=TablDbf.Find_Name_Fld("P01_60");
   FldDbf[idxDbfINN   ]=TablDbf.Find_Name_Fld("P01_61");

   FldDbf[idxDbfUVPR  ]=TablDbf.Find_Name_Fld("P01_48");    // прич_увол (собст_жел) 
  // FldDbf[idxDbfPROF  ]=TablDbf.Find_Name_Fld             // член профсоюза
   FldDbf[idxDbfSEMP  ]=TablDbf.Find_Name_Fld("P01_19");    // семейное полож
   FldDbf[idxDbfKATG  ]=TablDbf.Find_Name_Fld("P01_37");    // код катег

   FldDbf[idxDbfIND   ]=TablDbf.Find_Name_Fld("P01_64");
   FldDbf[idxDbfREG   ]=TablDbf.Find_Name_Fld("P01_65");
   FldDbf[idxDbfRAJ   ]=TablDbf.Find_Name_Fld("P01_66");
   FldDbf[idxDbfGOR   ]=TablDbf.Find_Name_Fld("P01_67");
   FldDbf[idxDbfPUN   ]=TablDbf.Find_Name_Fld("P01_68");
   FldDbf[idxDbfULI   ]=TablDbf.Find_Name_Fld("P01_69");
   FldDbf[idxDbfDOM   ]=TablDbf.Find_Name_Fld("P01_70");
   FldDbf[idxDbfKOR   ]=TablDbf.Find_Name_Fld("P01_71");
   FldDbf[idxDbfKVA   ]=TablDbf.Find_Name_Fld("P01_72");

   FldDbf[idxDbfMROJ   ]=TablDbf.Find_Name_Fld("P01_08");


   for ( int idx=0; idx<CountIdxDbf; ++idx )
      if ( FldDbf[idx]==-1 )
      {
         AmbaMessageBox("Нет необходимых полей в dbf-файле!","Ошибка!!!",MB_OK|MB_ICONERROR,0);
         return false;
      }
   return true;
}

Fam(fam)   //исправление символов-хамелеонов с пом ф-ции  To_Rus
{
      char fa[91];
      sprintf(fa,"%.90s",static_cast_to_string(fam));
      FreeSpaceString(fa,3,"");
      unsigned len = strlen(fa);

      for (unsigned idx=0; idx<len; ++idx)  fa[idx]=To_Rus(fa[idx]);

      return fa;

}

Dat1(d1)   //преобразов даты из ГГГГ.ММ.ДД в ДД.ММ.ГГГГ
{
      char d2[91];
      sprintf(d2,"%.90s",static_cast_to_string(d1));

      var DatParam = CreateObject("ParamFuncRW");
      DatParam.IInitial(static_cast_to_string(d2)," .",4);

      char d3[10], d4[10], d5[10];
      sprintf(d3,"%.9s", static_cast_to_string(DatParam.Get(0)));
      sprintf(d4,"%.9s", static_cast_to_string(DatParam.Get(1)));
      sprintf(d5,"%.9s", static_cast_to_string(DatParam.Get(2)));

      FreeSpaceString(d3,3,"");
      FreeSpaceString(d4,3,"");
      FreeSpaceString(d5,3,"");

      char d6[20];
      sprintf(d6,"%s.%s.%s",d5,d4,d3);
      FreeSpaceString(d6,3,"");

  return d6;
}

God1(d1)   
{
      char d2[91];
      sprintf(d2,"%.90s",static_cast_to_string(d1));

      var DatParam = CreateObject("ParamFuncRW");
      DatParam.IInitial(static_cast_to_string(d2)," .",4);

      char d3[10];
      sprintf(d3,"%.9s", static_cast_to_string(DatParam.Get(0)));

      FreeSpaceString(d3,3,"");

  return d3;
}


Sex(sx)
{
 char pol[2];   
 pol[0]='М'; 
 int prz=atoi(sx);
 if(prz==2) pol[0]='Ж';
 return pol;  
}

Dat2(d1)   // замена  "_" на  " "
{
      char d2[20];
      sprintf(d2,"%s",static_cast_to_string(d1));
      FreeSpaceString(d2,3,"");
      unsigned len = strlen(d2);

      int izm=0;
      for (unsigned idx=0; idx<len; ++idx)
       {
         if ( d2[idx]=='-' )   
          {
            d2[idx]=' ';
            izm=1;
          }
       }                     

      if (izm==0) 
       {
        for (unsigned idx=0; idx<len; ++idx) d2[idx]=' ';
       }

  return d2;

}

DatPSP(ser,kem,kog)
{
      char p2[90];
      sprintf(p2,"%s",static_cast_to_string(ser));
      FreeSpaceString(p2,3,"");
      unsigned len = strlen(p2);

      int izm=0;
      for (unsigned idx=0; idx<len; ++idx)
       {
         if ( p2[idx]==' ' )   
          {
            //d2[idx]=' ';
            izm++;
            if (izm==2) p2[idx]=',';  // заменяем пробел на запятую
          }
       }                     

      char p3[90];
      sprintf(p3,"%s",static_cast_to_string(kem));
      FreeSpaceString(p3,3,"");

      char p4[90];
      sprintf(p4,"%s",static_cast_to_string(kog));
      FreeSpaceString(p4,3,"");

      char p5[90];
      sprintf(p5,"%s,%s,%s",p2,p3,p4);  //sprintf(p5,"%s,%s,%s",p2,kem,kog);
      FreeSpaceString(p5,3,"");

      return p5;
}

DatInv(in1,in2)
{
      char i1[20];
      sprintf(i1,"%s",static_cast_to_string(in1));
      FreeSpaceString(i1,3,"");
      char i2[20];
      sprintf(i2,"%s",static_cast_to_string(in2));
      FreeSpaceString(i2,3,"");

      char i3[90];
      sprintf(i3,"%s,%s",i2,i1);
      FreeSpaceString(i3,3,"");

  return i3;
}

DatRab(dat1,dat2)
{
      char d1[20];
      sprintf(d1,"%s",static_cast_to_string(dat1));
      FreeSpaceString(d1,3,"");

      char d2[20];
      sprintf(d2,"%s",static_cast_to_string(dat2));
      FreeSpaceString(d2,3,"");
      unsigned len = strlen(d2);

      if (len>2)  return d2;
      else        return d1;
}
