gstringext.cpp

Go to the documentation of this file.
00001 // gstringext.cpp -- Version 0.2
00002 
00003 #include <string.h>
00004 #include "gstringext.h"
00005 #include "garg.h"
00006 #include "gdir.h"
00007 ////////////////////////////////////////////////////////////
00008 // Static members
00009 // ---------------------------------------------------------
00010 char sHtmlSymbol::sBuf[50];
00011 short sUnCodeSymbol::strSymNameLen=60;
00012 char sUnCodeSymbol::symBufExt[257];
00013 sIanaCountry2 gStrControl::tblIanaCountry[]={
00014         {"ac", "Ascension Isl." },
00015         {"ad", "Andorra" },
00016         {"ae", "United Arab Emirates" },
00017         {"af", "Afghanistan" },
00018         {"ag", "Antigua and Barbuda" },
00019         {"ai", "Anguilla" },
00020         {"al", "Albania" },
00021         {"am", "Armenia" },
00022         {"an", "Netherlands Antilles" },
00023         {"ao", "Angola" },
00024         {"aq", "Antarctica" },
00025         {"ar", "Argentina" },
00026         {"as", "American Samoa" },
00027         {"at", "Austria" },
00028         {"au", "Australia" },
00029         {"aw", "Aruba" },
00030         {"ax", "Aland Isl." },
00031         {"az", "Azerbaijan" },
00032         {"ba", "Bosnia and Herzegovina" },
00033         {"bb", "Barbados" },
00034         {"bd", "Bangladesh" },
00035         {"be", "Belgium" },
00036         {"bf", "Burkina Faso" },
00037         {"bg", "Bulgaria" },
00038         {"bh", "Bahrain" },
00039         {"bi", "Burundi" },
00040         {"bj", "Benin" },
00041         {"bm", "Bermuda" },
00042         {"bn", "Brunei" },
00043         {"bo", "Bolivia" },
00044         {"br", "Brazil" },
00045         {"bs", "Bahamas" },
00046         {"bt", "Bhutan" },
00047         {"bv", "Bouvet Isl." },
00048         {"bw", "Botswana" },
00049         {"by", "Belarus" },
00050         {"bz", "Belize" },
00051         {"ca", "Canada" },
00052         {"cc", "Cocos Keeling Isl." },
00053         {"cd", "Congo, Dem. Rep." },
00054         {"cf", "Central African Republic" },
00055         {"cg", "Congo," },
00056         {"ch", "Switzerland" },
00057         {"ci", "Cote D'Ivoire" },
00058         {"ck", "Cook Isl." },
00059         {"cl", "Chile" },
00060         {"cm", "Cameroon" },
00061         {"cn", "China" },
00062         {"co", "Colombia" },
00063         {"cr", "Costa Rica" },
00064         {"cs", "Serbia and Montenegro" },
00065         {"cu", "Cuba" },
00066         {"cv", "Cape Verde" },
00067         {"cx", "Christmas Isl." },
00068         {"cy", "Cyprus" },
00069         {"cz", "Czech Republic" },
00070         {"de", "Germany" },
00071         {"dj", "Djibouti" },
00072         {"dk", "Denmark" },
00073         {"dm", "Dominica" },
00074         {"do", "Dominican Republic" },
00075         {"dz", "Algeria" },
00076         {"ec", "Ecuador" },
00077         {"ee", "Estonia" },
00078         {"eg", "Egypt" },
00079         {"eh", "Western Sahara" },
00080         {"er", "Eritrea" },
00081         {"es", "Spain" },
00082         {"et", "Ethiopia" },
00083         {"fi", "Finland" },
00084         {"fj", "Fiji" },
00085         {"fk", "Falkland Isl." },
00086         {"fm", "Micronesia" },
00087         {"fo", "Faroe Isl." },
00088         {"fr", "France" },
00089         {"ga", "Gabon" },
00090         {"gb", "United Kingdom" },
00091         {"gd", "Grenada" },
00092         {"ge", "Georgia" },
00093         {"gf", "French Guiana" },
00094         {"gg", "Guernsey" },
00095         {"gh", "Ghana" },
00096         {"gi", "Gibraltar" },
00097         {"gl", "Greenland" },
00098         {"gm", "Gambia" },
00099         {"gn", "Guinea" },
00100         {"gp", "Guadeloupe" },
00101         {"gq", "Equatorial Guinea" },
00102         {"gr", "Greece" },
00103         {"gs", "South Georgia and the S. Sandwich Isl." },
00104         {"gt", "Guatemala" },
00105         {"gu", "Guam" },
00106         {"gw", "Guinea-Bissau" },
00107         {"gy", "Guyana" },
00108         {"hk", "Hong Kong" },
00109         {"hm", "Heard and McDonald Isl." },
00110         {"hn", "Honduras" },
00111         {"hr", "Croatia" },
00112         {"ht", "Haiti" },
00113         {"hu", "Hungary" },
00114         {"id", "Indonesia" },
00115         {"ie", "Ireland" },
00116         {"il", "Israel" },
00117         {"im", "Isle of Man" },
00118         {"in", "India" },
00119         {"io", "British Indian Ocean Territory" },
00120         {"iq", "Iraq" },
00121         {"ir", "Iran" },
00122         {"is", "Iceland" },
00123         {"it", "Italy" },
00124         {"je", "Jersey" },
00125         {"jm", "Jamaica" },
00126         {"jo", "Jordan" },
00127         {"jp", "Japan" },
00128         {"ke", "Kenya" },
00129         {"kg", "Kyrgyzstan" },
00130         {"kh", "Cambodia" },
00131         {"ki", "Kiribati" },
00132         {"km", "Comoros" },
00133         {"kn", "Saint Kitts and Nevis" },
00134         {"kp", "North Korea" },
00135         {"kr", "South Korea" },
00136         {"kw", "Kuwait" },
00137         {"ky", "Cayman Isl." },
00138         {"kz", "Kazakhistan" },
00139         {"la", "Lao" },
00140         {"lb", "Lebanon" },
00141         {"lc", "Saint Lucia" },
00142         {"li", "Liechtenstein" },
00143         {"lk", "Sri Lanka" },
00144         {"lr", "Liberia" },
00145         {"ls", "Lesotho" },
00146         {"lt", "Lithuania" },
00147         {"lu", "Luxembourg" },
00148         {"lv", "Latvia" },
00149         {"ly", "Libya" },
00150         {"ma", "Morocco" },
00151         {"mc", "Monaco" },
00152         {"md", "Moldova" },
00153         {"mg", "Madagascar" },
00154         {"mh", "Marshall Isl." },
00155         {"mk", "Macedonia," },
00156         {"ml", "Mali" },
00157         {"mm", "Myanmar" },
00158         {"mn", "Mongolia" },
00159         {"mo", "Macao" },
00160         {"mp", "Northern Mariana Isl." },
00161         {"mq", "Martinique" },
00162         {"mr", "Mauritania" },
00163         {"ms", "Montserrat" },
00164         {"mt", "Malta" },
00165         {"mu", "Mauritius" },
00166         {"mv", "Maldives" },
00167         {"mw", "Malawi" },
00168         {"mx", "Mexico" },
00169         {"my", "Malaysia" },
00170         {"mz", "Mozambique" },
00171         {"na", "Namibia" },
00172         {"nc", "New Caledonia" },
00173         {"ne", "Niger" },
00174         {"nf", "Norfolk Isl." },
00175         {"ng", "Nigeria" },
00176         {"ni", "Nicaragua" },
00177         {"nl", "Netherlands" },
00178         {"no", "Norway" },
00179         {"np", "Nepal" },
00180         {"nr", "Nauru" },
00181         {"nu", "Niue" },
00182         {"nz", "New Zealand" },
00183         {"om", "Oman" },
00184         {"pa", "Panama" },
00185         {"pe", "Peru" },
00186         {"pf", "French Polynesia" },
00187         {"pg", "Papua New Guinea" },
00188         {"ph", "Philippines" },
00189         {"pk", "Pakistan" },
00190         {"pl", "Poland" },
00191         {"pm", "Saint Pierre and Miquelon" },
00192         {"pn", "Pitcairn" },
00193         {"pr", "Puerto Rico" },
00194         {"ps", "Palestinian Territory" },
00195         {"pt", "Portugal" },
00196         {"pw", "Palau" },
00197         {"py", "Paraguay" },
00198         {"qa", "Qatar" },
00199         {"re", "Reunion" },
00200         {"ro", "Romania" },
00201         {"ru", "Russian Federation" },
00202         {"rw", "Rwanda" },
00203         {"sa", "Saudi Arabia" },
00204         {"sb", "Solomon Isl." },
00205         {"sc", "Seychelles" },
00206         {"sd", "Sudan" },
00207         {"se", "Sweden" },
00208         {"sg", "Singapore" },
00209         {"sh", "Saint Helena" },
00210         {"si", "Slovenia" },
00211         {"sj", "Svalbard and Jan Mayen" },
00212         {"sk", "Slovakia" },
00213         {"sl", "Sierra Leone" },
00214         {"sm", "San Marino" },
00215         {"sn", "Senegal" },
00216         {"so", "Somalia" },
00217         {"sr", "Suriname" },
00218         {"st", "Sao Tome and Principe" },
00219         {"sv", "El Salvador" },
00220         {"sy", "Syria" },
00221         {"sz", "Swaziland" },
00222         {"tc", "Turks and Caicos Isl." },
00223         {"td", "Chad" },
00224         {"tf", "French Southern Territories" },
00225         {"tg", "Togo" },
00226         {"th", "Thailand" },
00227         {"tj", "Tajikistan" },
00228         {"tk", "Tokelau" },
00229         {"tl", "Timor-Leste" },
00230         {"tm", "Turkmenistan" },
00231         {"tn", "Tunisia" },
00232         {"to", "Tonga" },
00233         // {"tp", "East Timor" } ==> now "Timor-Leste", 'tl' Root-Zone
00234         {"tr", "Turkey" },
00235         {"tt", "Trinidad and Tobago" },
00236         {"tv", "Tuvalu" },
00237         {"tw", "Taiwan" },
00238         {"tz", "Tanzania" },
00239         {"ua", "Ukraine" },
00240         {"ug", "Uganda" },
00241         {"uk", "United" },
00242         {"um", "US Minor Outlying Isl." },
00243         {"us", "United States" },
00244         {"uy", "Uruguay" },
00245         {"uz", "Uzbekistan" },
00246         {"va", "Holy See" },
00247         {"vc", "Saint Vicent and the Grenadines" },
00248         {"ve", "Venezuela" },
00249         {"vg", "British Virgin Isl." },
00250         {"vi", "US Virgin Isl." },
00251         {"vn", "Viet Nam" },
00252         {"vu", "Vanuatu" },
00253         {"wf", "Wallis and Futuna" },
00254         {"ws", "Samoa" },
00255         {"ye", "Yemen" },
00256         {"yt", "Mayotte" },
00257         // {"yu", "Yugoslavia" } ==> refer to 'cs' (Serbia...)
00258         {"za", "South Africa" },
00259         {"zm", "Zambia" },
00260         {"zw", "Zimbabwe" },
00261         {"\0", "\0"}};
00262 gStrControl gStrControl::myself;
00263 
00264 ////////////////////////////////////////////////////////////
00265 gDateDay::gDateDay (t_uint32 aDd)
00266     : dd( aDd )
00267 {
00268 }
00269 
00270 gDateDay::~gDateDay ()
00271 {
00272 }
00273 
00274 t_uint16 gDateDay::GetYear ()
00275 {
00276  return dd / 10000;
00277 }
00278 
00279 t_uint16 gDateDay::GetMonth ()
00280 {
00281  return (dd % 10000)/100;
00282 }
00283 
00284 t_uint16 gDateDay::GetDay ()
00285 {
00286  return dd%100;
00287 }
00288 
00289 bool gDateDay::SetDay (t_uint32 aDd)
00290 {
00291  dd = aDd;
00292  return IsValid();
00293 }
00294 
00295 gStorage* gDateDay::NewObject ()
00296 {
00297  gDateDay* a = new gDateDay( dd );
00298  return a;
00299 }
00300 
00301 bool gDateDay::SaveGuts (FILE* f)
00302 {
00303  if ( CanSave( f )==false ) return false;
00304  // e.g.: 20031231 (last day of 2003)
00305  return fprintf( f, "%08lu", (unsigned long)dd );
00306 }
00307 
00308 bool gDateDay::RestoreGuts (FILE* f)
00309 {
00310  unsigned long lVal;
00311  if ( CanRestore( f )==false ) return false;
00312  if ( fscanf( f, "%lu", &lVal )<1 ) return false;
00313  dd = lVal;
00314  return true;
00315 }
00316 ////////////////////////////////////////////////////////////
00317 sTcbBin::sTcbBin ()
00318     : cLevel( '0' ),
00319       revisionRef( 1 ),  // Revision 1, draft
00320       cNormRef( 'D' ),
00321       cpCode( 0 ),
00322       cLinearInd( 'a' ),
00323       nSymb( 0 ),
00324       linearTbl( nil ),
00325       bigTbl( nil )
00326 {
00327  unsigned i;
00328  linearTbl = new t_gUniPage[ 256 ];
00329  for (i=0; i<256; i++) linearTbl[i] = 0;
00330  strcpy(verMajor,"TCB1A");
00331 }
00332 
00333 sTcbBin::~sTcbBin ()
00334 {
00335  delete[] linearTbl;
00336  delete[] bigTbl;
00337 }
00338 
00339 bool sTcbBin::IsLinear ()
00340 {
00341  return cLinearInd=='a' || cLinearInd=='b';
00342 }
00343 
00344 int sTcbBin::ReadFromStream (FILE* f)
00345 {
00346  int error;
00347  t_uint32 aUD4;
00348  t_uint32 sIdx, sMax;
00349  t_uint16 aMagicOffset;
00350  t_uchar aBuf[100];
00351 
00352  if ( f==nil ) return -1;
00353 
00354  error = fread(verMajor,6,1,f);
00355  if ( error<1 ) return 1;
00356  error = fread(&aUD4,4,1,f);
00357  if ( error<1 ) return 1;
00358  aMagicOffset = (t_uint16)( FROM_UD4(aUD4) );
00359  if ( aMagicOffset!=72 ) return 2;
00360  error = fscanf(f,"%c",&cLevel);
00361  if ( error<1 ) return 1;
00362 
00363  error = fread(&aUD4,4,1,f);
00364  if ( error<1 ) return 1;
00365  revisionDate.SetDay( FROM_UD4(aUD4) );
00366 
00367  error = fread(&revisionRef,1,1,f);
00368  if ( error<1 ) return 1;
00369 
00370  error = fread(&cNormRef,1,1,f);
00371  if ( error<1 ) return 1;
00372 
00373  error = fread(&sDescTag,13,1,f);
00374  if ( error<1 ) return 1;
00375 
00376  memset(aBuf,0x0,100);
00377  error = fread(aBuf,34,1,f);
00378  if ( error<1 ) return 1;
00379  sDescStr = (char*)aBuf;
00380 
00381  error = fread(&aUD4,4,1,f);
00382  if ( error<1 ) return 1;
00383  cpCode = FROM_UD4(aUD4);
00384 
00385  error = fread(&cLinearInd,1,1,f);
00386  if ( error<1 ) return 1;
00387 
00388  memset(aBuf,0x00,10);
00389  error = fread(aBuf,3,1,f);
00390  if ( error<1 ) return 1;
00391  if ( strncmp((char*)(aBuf+1),"  ",2)!=0 ) return 2;
00392 
00393  error = fread(&aUD4,4,1,f);
00394  if ( error<1 ) return 1;
00395  nSymb = FROM_UD4(aUD4);
00396 
00397  ASSERTION(linearTbl!=nil,"linearTbl!=nil");
00398  sMax = nSymb>256 ? 256 : nSymb;
00399  for (sIdx=1; sIdx<sMax; sIdx++) {
00400      error = fread(&aUD4,4,1,f);
00401      if ( error<1 ) return 1;
00402      linearTbl[sIdx] = FROM_UD4( aUD4 );
00403  }
00404 
00405  return 0;
00406 }
00407 
00408 int sTcbBin::ReadFromFile (char* fName)
00409 {
00410  int error;
00411  FILE* f;
00412  if ( fName==nil || fName[0]==0 ) return -1;
00413  f = fopen(fName,"rb");
00414  error = ReadFromStream( f );
00415  //printf("sTcbBin::ReadFromFile: %s (error=%d)\n",fName,error) : DBG
00416  if ( f!=nil ) fclose( f );
00417  return error;
00418 }
00419 ////////////////////////////////////////////////////////////
00420 bool sUnCodeSymbol::IsValid ()
00421 {
00422  return
00423      (cIsOpenClose=='Y' || cIsOpenClose=='N') &&
00424      (twoLetterCat[0]>='A' && twoLetterCat[0]<='Z');
00425 }
00426 
00427 void sUnCodeSymbol::SetCode (t_gUniPage aCode)
00428 {
00429  bool isAlpha;
00430 
00431  uniCode = aCode;
00432  extUtMask = 0;
00433  if ( aCode>0xFF ) return;
00434  if ( aCode>='0' && aCode<='9' ) {
00435      extUtMask = EXTUMASK_ISDIGIT | EXTUMASK_ISPRINT;
00436      return;
00437  }
00438  if ( aCode==' ' || aCode=='\t' || aCode=='\f' ||
00439       aCode=='\n' || aCode=='\r' || aCode=='\v' ) {
00440      extUtMask = EXTUMASK_ISSPACE | EXTUMASK_ISPRINT;
00441      return;
00442  }
00443  ASSERTION(twoLetterCat[0]!=0,"twoLetterCat[0]!=0");
00444  isAlpha = twoLetterCat[0]=='L';
00445  extUtMask = isAlpha;
00446  extUtMask |= (aCode>=' ' && aCode<127) ? EXTUMASK_ISPRINT : 0x0;
00447  // Note: other values above ASCII 127 decimal are not
00448  // parsed since it is deterministic, as follow:
00449  if ( aCode>=0x00A1 ) extUtMask |= EXTUMASK_ISPRINT;
00450 }
00451 
00452 int sUnCodeSymbol::SaveBin (FILE* f)
00453 {
00454  unsigned i;
00455  t_uint16 aUD2;
00456  t_uint32 aUD4;
00457 
00458  if ( f==nil ) return -1;
00459  if ( IsValid()==false ) return -1;
00460 
00461  aUD4 = TO_UD4(uniCode);
00462  fwrite(&aUD4,4,1,f);
00463 
00464  //for (i=0; i<257; i++) symBufExt[i] = 0;
00465  memset(symBufExt,0x00,257);
00466 
00467  if ( strSymNameLen>0 ) {
00468      ASSERTION(symbolName!=nil,"symbolName!=nil");
00469      strncpy( symBufExt, symbolName->Str(), strSymNameLen-1 );
00470      fwrite(symBufExt,strSymNameLen,1,f);
00471  }
00472  fwrite(twoLetterCat,2,1,f);
00473  fprintf(f,"0");
00474  fwrite(thrLetterStyle,4,1,f); // 3octets+0x00
00475 
00476  aUD4 = TO_UD4(ucCompat);
00477  fwrite(&aUD4,4,1,f);
00478 
00479  for (i=0; i<10; i++) symBufExt[i] = 0;
00480  strncpy( symBufExt, strNumber.Str(), 9 );
00481  fwrite(symBufExt,10,1,f);
00482  fprintf(f,"%c",cIsOpenClose);
00483 
00484  aUD4 = TO_UD4(extEqClose);
00485  fwrite(&aUD4,4,1,f);
00486 
00487  for (i=0; i<18; i++) symBufExt[i] = 0;
00488  strncpy( symBufExt, strNote.Str(), 16 );
00489  fwrite(symBufExt,18,1,f); // 16octets+0x00+0x00
00490 
00491  aUD4 = TO_UD4(ucUpper);
00492  fwrite(&aUD4,4,1,f);
00493 
00494  aUD4 = TO_UD4(ucDown);
00495  fwrite(&aUD4,4,1,f);
00496 
00497  for (i=0; i<17; i++) symBufExt[i] = 0;
00498  fwrite(symBufExt,4,1,f);
00499  fwrite(symBufExt,2,1,f);
00500 
00501  aUD4 = 0xFFFFFFFF;
00502  fwrite(&aUD4,4,1,f);
00503  ASSERTION((aUD4>>30)==0x3,"dummy-test");
00504 
00505  for (i=0; i<61; i++) symBufExt[i] = 0;
00506  fwrite(symBufExt,61,1,f); // 60octets+0x00
00507 
00508  fprintf(f,"%c",refVersLetter);
00509 
00510  aUD2 = TO_UD2(extUtMask);
00511  return fwrite(&aUD2,2,1,f)<1;
00512 }
00513 
00514 int sUnCodeSymbol::ReadBin (FILE* f)
00515 {
00516  int error;
00517  t_uint16 aUD2;
00518  t_uint32 aUD4;
00519 
00520  if ( f==nil ) return -1;
00521 
00522  error = fread(&aUD4,4,1,f);
00523  if ( error<1 ) return error;
00524  uniCode = FROM_UD4(aUD4);
00525 
00526  memset(symBufExt,0x00,257);
00527 
00528  delete symbolName;
00529  symbolName = nil;
00530  if ( strSymNameLen>0 ) {
00531      error = fread(symBufExt,strSymNameLen,1,f);
00532      if ( error<1 ) return 1;
00533      if ( symBufExt[strSymNameLen-1]!=0x00 ) return 2;
00534      symbolName = new gString( (char*)symBufExt );
00535  }
00536 
00537  error = fread(twoLetterCat,3,1,f); // 3octet+0x00
00538  if ( error<1 ) return 1;
00539  if ( twoLetterCat[2]!='0' ) return 2;
00540  twoLetterCat[2] = 0;
00541 
00542  error = fread(thrLetterStyle,4,1,f); // 4octet+0x00
00543  if ( error<1 ) return 1;
00544  if ( thrLetterStyle[3]!=0x00 ) return 2;
00545 
00546  error = fread(&aUD4,4,1,f);
00547  if ( error<1 ) return 1;
00548  ucCompat = FROM_UD4(aUD4);
00549 
00550  memset(symBufExt,0x00,11);
00551  error = fread(symBufExt,10,1,f);
00552  if ( error<1 ) return 1;
00553  if ( symBufExt[9]!=0x00 ) return 2;
00554  strNote = (char*)symBufExt;
00555 
00556  error = fscanf(f,"%c",&cIsOpenClose );
00557  if ( error<1 ) return 1;
00558 
00559  error = fread(&aUD4,4,1,f);
00560  if ( error<1 ) return 1;
00561  extEqClose = FROM_UD4(aUD4);
00562 
00563  memset(symBufExt,0x00,19);
00564  error = fread(symBufExt,18,1,f); // 16octet+0x00+0x00
00565  strNote = (char*)symBufExt;
00566 
00567  error = fread(&aUD4,4,1,f);
00568  if ( error<1 ) return 1;
00569  ucUpper = FROM_UD4(aUD4);
00570 
00571  error = fread(&aUD4,4,1,f);
00572  if ( error<1 ) return 1;
00573  ucDown = FROM_UD4(aUD4);
00574 
00575  error = fread(symBufExt,4,1,f); // 4 pad nulls
00576  if ( error<1 ) return 1;
00577  error = fread(symBufExt,2,1,f); // 2 pad nulls
00578  if ( error<1 ) return 1;
00579 
00580  error = fread(&aUD4,4,1,f);
00581  if ( error<1 ) return 1;
00582  if ( aUD4!=0xFFFFFFFF ) return 2;
00583 
00584  memset(symBufExt,0x00,61);
00585  error = fread(symBufExt,61,1,f); // 60octet+0x00
00586  if ( error<1 || symBufExt[60]!=0x00 ) return 1;
00587  // String symbol name Locale
00588  strLocale = (char*)symBufExt;
00589 
00590  error = fread(&refVersLetter,1,1,f);
00591  if ( error<1 ) return 1;
00592 
00593  error = fread(&aUD2,2,1,f);
00594  if ( error<1 ) return 1;
00595  extUtMask = FROM_UD2(aUD2);
00596 
00597  return IsValid() ? 0 : 2;
00598 }
00599 ////////////////////////////////////////////////////////////
00600 char* sHtmlSymbol::GetHtmlStr ()
00601 {
00602  memset(sBuf,0x00,50);
00603  if ( IsOk()==false ) return sBuf;
00604  if ( IsNormal() ) {
00605      strcpy( sBuf, sTransHtm.Str() );
00606      return sBuf;
00607  }
00608  sprintf( sBuf, "&%s;", sTransHtm.Str() );
00609  return sBuf;
00610 }
00611 ////////////////////////////////////////////////////////////
00612 sUnCodeBin::sUnCodeBin ()
00613     : n( 0 ),
00614       mapTab( nil ),
00615       verHtml( '3' ),
00616       descStg( e_Desc60ByteDef ),
00617       revisionRef( THB_VERS_REVISION ),
00618       cExtTbl( '2' ),
00619       nHtmlTrans( 0 ),
00620       mapHtm( nil ),
00621       cHtmAsciiStt( 0x0 )
00622 {
00623  short ix;
00624  for (ix=0; ix<=16; ix++) revReferenceStr[ix] = 0;
00625  sprintf( verMajor, "THB_Z" );
00626  strcpy( revReferenceStr, "Henrique Moreira" );
00627  sHtmlUnmap = (char*)"[hs.";
00628 }
00629 
00630 sUnCodeBin::~sUnCodeBin ()
00631 {
00632  delete[] mapTab;
00633  delete[] mapHtm;
00634 }
00635 
00636 int sUnCodeBin::GetMajorVersion ()
00637 {
00638  if ( verMajor[3]<'1' ) return -1;
00639  return (int)(verMajor[3]-'1');
00640 }
00641 
00642 char sUnCodeBin::GetDescStgChr ()
00643 {
00644  switch ( descStg ) {
00645  case e_DescNone:
00646      return 'a';
00647  case e_Desc40Byte:
00648      return 'b';
00649  case e_Desc60ByteDef:
00650      return 'c';
00651  case e_Desc80Byte:
00652      return 'd';
00653  case e_Desc255Byte:
00654      return 'e';
00655  default:
00656      break;
00657  }
00658  ASSERTION_FALSE("descStg");
00659  return '\0';
00660 }
00661 
00662 bool sUnCodeBin::IsFlat (t_uchar& chr)
00663 {
00664  chr = ';';
00665  return chr==';'; // Fixedly Flat!
00666 }
00667 
00668 bool sUnCodeBin::IsFlatOk ()
00669 {
00670  unsigned i, nElem=n<256?n:256;
00671  t_uchar chr;
00672  t_gUniPage lastCode=0x0, thisCode;
00673 
00674  if ( IsFlat(chr)==false ) return false;
00675  // Check:
00676  //  a) sequential symbols in 'mapTab'
00677  //  b) no gaps between 0x00 and 0xFF
00678  ASSERTION(mapTab!=nil,"mapTab!=nil");
00679  for (i=2; i<=nElem; i++) {
00680      thisCode = mapTab[i].uniCode;
00681      if ( thisCode<=lastCode ) return false;
00682      lastCode = thisCode;
00683  }
00684  return true;
00685 }
00686 
00687 t_uint32 sUnCodeBin::FindCode (t_gUniPage aCode)
00688 {
00689  unsigned i;
00690  for (i=1; i<=n; i++) {
00691      if ( aCode==mapTab[i].uniCode ) return i;
00692  }
00693  return 0;
00694 }
00695 
00696 char sUnCodeBin::GetLetterCompat (t_gUniPage aCode)
00697 {
00698  unsigned i;
00699  t_gUniPage ucCompat;
00700  ASSERTION(mapTab!=NULL,"mapTab!=NULL");
00701  ASSERTION(aCode<N(),"aCode<N()");
00702  i = FindCode(aCode);
00703  ASSERTION(i==aCode,"revise assert"); // Note: this can be not-linear!
00704  ucCompat = mapTab[i].ucCompat;
00705  if ( ucCompat==0 ) {
00706      return mapTab[i].IsLetter() && i<127 ? i : '*';
00707  }
00708  if ( ucCompat>=127 ) return 0;
00709  return ucCompat;
00710 }
00711 
00712 bool sUnCodeBin::HasHtml ()
00713 {
00714  bool isOk = verHtml>'0' && cExtTbl>'2';
00715  DBGPRINT("DBG:HasHtml?%d,cHtmAsciiStt=%03u\n",isOk,(unsigned)cHtmAsciiStt);
00716  return isOk==true && cHtmAsciiStt>'\0';
00717 }
00718 
00719 int sUnCodeBin::AllocateSymbols (int nSymbols)
00720 {
00721  if ( nSymbols<=0 ) {
00722      n = 0;
00723      delete[] mapTab;
00724      mapTab = nil;
00725      return 0;
00726  }
00727  ASSERTION(mapTab==nil,"mapTab==nil");
00728  n = (unsigned)nSymbols;
00729  mapTab = new sUnCodeSymbol[ n+1 ];
00730  ASSERTION(mapTab!=nil,"mapTab!=nil");
00731  return nSymbols;
00732 }
00733 
00734 int sUnCodeBin::SetVersion (t_uchar aMajorVersion, t_uchar aMinorAlpha)
00735 {
00736  if ( aMajorVersion<'1' || aMajorVersion>'9' ) return -1;
00737  if ( aMinorAlpha<'A' || aMinorAlpha>'Z' ) return -1;
00738  verMajor[3] = aMajorVersion;
00739  verMajor[4] = aMinorAlpha;
00740  return 0;
00741 }
00742 
00743 int sUnCodeBin::SetNTables (bool hasHtmlTrans, int nExtTbl)
00744 {
00745  cExtTbl = hasHtmlTrans?'3':'2';
00746  // Other values for cExtTbl are for future use
00747  return nExtTbl>=0;
00748 }
00749 
00750 int sUnCodeBin::SaveToFile (char* fName)
00751 {
00752  FILE* f;
00753  int error;
00754 
00755  if ( verMajor[4]<'A' ) return -2;
00756  if ( mapTab==nil ) return -3;
00757  if ( IsFlatOk()==false ) return -4;
00758 
00759  if ( fName==NULL || fName[0]==0 ) return -1;
00760  f = fopen(fName,"wb");
00761  error = SaveToStream( f );
00762  if ( f!=NULL ) fclose( f );
00763  return error;
00764 }
00765 
00766 int sUnCodeBin::SaveToStream (FILE* f)
00767 {
00768  int error;
00769  int scanCode;
00770  unsigned i;
00771  t_uint16 aUD2;
00772  t_uint32 aUD4;
00773  t_uint32 nStrCompat=0;
00774  t_uchar chr;
00775 
00776  if ( f==NULL ) return -1;
00777 
00778  if ( fprintf(f,"%s",verMajor)<1 ||
00779       fprintf(f,"%c%c0",0x00,verHtml)<1 ) {
00780      return -1;
00781  }
00782 
00783  fprintf(f,"%c %c",GetDescStgChr(),0x00);
00784  aUD4 = TO_UD4(revisionDate.GetValue32());
00785  fwrite(&aUD4,4,1,f);
00786 
00787  fwrite(&revisionRef,1,1,f);
00788  fwrite(&revReferenceStr,17,1,f);
00789  IsFlat( chr );
00790  fprintf(f,"Si.%c%c",0x00,chr); // Usually "Si._;"
00791 
00792  aUD2 = TO_UD2(3); // Fixedly with HTML-TRANS
00793  fwrite(&aUD2,2,1,f);
00794 
00795  aUD4 = TO_UD4(n);
00796  error = fwrite(&aUD4,4,1,f);
00797  if ( error<1 ) return 1;
00798 
00799  for (i=1, error=0; i<=n; i++) {
00800      if ( mapTab[i].SaveBin( f )!=0 ) error = 1;
00801      nStrCompat += mapTab[i].strCompat.IsEmpty()==false;
00802  }
00803  if ( error!=0 ) return 1;
00804 
00805  // TABLE OF COMPATIBILITY NOTES (section four)
00806  // The number of non empty 'strCompat' is nStrCompat
00807  aUD4 = TO_UD4(nStrCompat);
00808  fwrite(&aUD4,4,1,f);
00809 
00810  for (i=1, error=0; i<=n; i++) {
00811      if ( mapTab[i].strCompat.IsEmpty()==false ) {
00812          // Write that strCompat
00813          aUD4 = TO_UD4(mapTab[i].uniCode);
00814          fwrite(&aUD4,4,1,f);
00815          gString sNote( mapTab[i].strCompat );
00816          fprintf(f,sNote[1]=='<'?"<>":"  ");
00817          memset(mapTab[0].symBufExt,0x00,257);
00818          strncpy(mapTab[0].symBufExt,sNote.Str(),36);
00819          scanCode = fwrite(mapTab[0].symBufExt,36,1,f);
00820          if ( scanCode<1 ) error = 1;
00821      }
00822  }
00823  if ( error!=0 ) return 1;
00824 
00825  // TABLE OF HTML-TRANS (section five)
00826  aUD4 = TO_UD4( nHtmlTrans );
00827  error = fwrite(&aUD4,4,1,f);
00828  if ( error<1 ) return 1;
00829 
00830  if ( HasHtml() ) {
00831      error = fprintf(f,"HTML%-2s;%c%c%c%c%c%c~",
00832                      sHtmlUnmap.Str(),
00833                      0x20, // 'Regular field'
00834                      0x00, // Pad null
00835                      cHtmAsciiStt,
00836                      '%',
00837                      '%',
00838                      '%');
00839      if ( error<1 ) return 1;
00840      unsigned count, aLen;
00841      i = (unsigned)cHtmAsciiStt;
00842      for (count=0; count<nHtmlTrans; count++, i++) {
00843          aLen = mapHtm[i].sTransHtm.Length();
00844          if ( aLen>9 ) return 2;
00845          memset(mapTab[0].symBufExt,0x00,10);
00846          strcpy( mapTab[0].symBufExt, mapHtm[i].sTransHtm.Str() );
00847          DBGPRINT("DBG: write[%u]: {%s}\n",i,mapTab[0].symBufExt);
00848          error = fwrite(mapTab[0].symBufExt,9,1,f);
00849          if ( error<1 ) return 1;
00850          error = fwrite(&mapHtm[i].cCompNote,1,1,f);
00851          if ( error<1 ) return 1;
00852      }
00853  }
00854 
00855  return 0;
00856 }
00857 
00858 int sUnCodeBin::ReadFromFile (char* fName)
00859 {
00860  // Returns 0 on success,
00861  // -3 if mapTab is not null
00862  // -1 if name or file not opened,
00863  //  2 if file is not THB or has invalid fields,
00864  //  1 if file too short or other.
00865  ;
00866  FILE* f;
00867  int error;
00868 
00869  if ( mapTab!=nil ) return -3;
00870  if ( fName==NULL || fName[0]==0 ) return -1;
00871  f = fopen(fName,"rb");
00872  error = ReadFromStream( f );
00873  //printf("sUnCodeBin::ReadFromFile: %s (error=%d)\n",fName,error) : DBG
00874  if ( f!=NULL ) fclose( f );
00875  return error;
00876 }
00877 
00878 int sUnCodeBin::ReadFromStream (FILE* f)
00879 {
00880  int error;
00881  bool isThisFlat;
00882  unsigned i;
00883  t_uint16 nrExtTables;
00884  t_uchar chr, chr2;
00885  char bufMe[257];
00886  t_uint16 aUD2;
00887  t_uint32 aUD4;
00888  t_uint32 idx, nStrCompat=0;
00889  t_gUniPage aCode;
00890 
00891  if ( f==NULL ) return -1;
00892 
00893  memset(bufMe,0x00,257);
00894 
00895  error = fread(bufMe,6,1,f);
00896  if ( error<1 ) return 1;
00897  if ( strncmp(bufMe,verMajor,3)!=0 ||
00898       bufMe[5]!=0x00 ) return 2;
00899 
00900  strcpy( verMajor, bufMe );
00901 
00902  error = fscanf(f,"%c%c%c",&verHtml,&cUniLevel,&chr);
00903  if ( error<3 ) return 1;
00904 
00905  switch ( chr ) {
00906  case 'a':
00907      descStg = e_DescNone;
00908      break;
00909  case 'b':
00910      descStg = e_Desc40Byte;
00911      break;
00912  case 'c':
00913      descStg = e_Desc60ByteDef;
00914      break;
00915  case 'd':
00916      descStg = e_Desc80Byte;
00917      break;
00918  case 'e':
00919      descStg = e_Desc255Byte;
00920      break;
00921  default:
00922      return 2;
00923  }
00924 
00925  error = fscanf(f,"%c%c",&chr,&chr);
00926  if ( error<2 ) return 2;
00927 
00928  error = fread(&aUD4,4,1,f);
00929  if ( error<1 ) return 1;
00930 
00931  revisionDate.SetDay( FROM_UD4(aUD4) );
00932 
00933  error = fscanf(f,"%c",&revisionRef);
00934  if ( error<1 || revisionRef==0xFF ) return 1;
00935 
00936  error = fread(revReferenceStr,17,1,f); // 16octet+0x00
00937 
00938  error = fread(bufMe,4,1,f); // "Si."+0x00
00939  if ( error<1 ) return 1;
00940  if ( strncmp(bufMe,"Si.",3)!=0 ) return 2;
00941 
00942  fscanf(f,"%c",&chr);
00943  IsFlat( chr2 );
00944  isThisFlat = chr==chr2;
00945 
00946  error = fread(&aUD2,2,1,f);
00947  nrExtTables = FROM_UD2(aUD2);
00948  if ( error<1 || nrExtTables<2 ) return 2;
00949  cExtTbl = nrExtTables;
00950  ASSERTION(cExtTbl<4,"cExtTbl<4: >=4 for future use");
00951 
00952  error = fread(&aUD4,4,1,f);
00953  if ( error<1 ) return 1;
00954 
00955  n = FROM_UD4(aUD4);
00956 
00957  // Now read the table
00958  mapTab = new sUnCodeSymbol[ n+1 ];
00959  ASSERTION(mapTab!=nil,"mapTab!=nil");
00960 
00961  mapTab[0].strSymNameLen = (short)descStg; // Usually 60
00962 
00963  for (i=0, error=0; i<n; i++) {
00964      if ( mapTab[i].ReadBin( f )!=0 ) return 1;
00965      DBGPRINT("DBG:%03ud(0x%02X):%04X\n",i,i,mapTab[i].uniCode);
00966  }
00967 
00968  error = fread(&aUD4,4,1,f);
00969  if ( error>=1 && n>1 ) {
00970      nStrCompat = FROM_UD4(aUD4);
00971      for (i=1; i<=nStrCompat; i++) {
00972          error = fread(&aUD4,4,1,f);
00973          if ( error<1 ) continue;
00974          aCode = FROM_UD4(aUD4);
00975          error = fread(&aUD2,2,1,f); // 2 chars
00976          if ( error<1 ) continue;
00977          error = fread(mapTab[0].symBufExt,36,1,f);
00978          if ( error<1 ) return 1;
00979          idx = FindCode( aCode );
00980          if ( idx>1 ) {
00981              mapTab[idx].strCompat = (char*)mapTab[0].symBufExt;
00982          }
00983      }
00984  }
00985 
00986  error = fread(&aUD4,4,1,f);
00987  if ( error<1 ) return 1;
00988 
00989  nHtmlTrans = FROM_UD4(aUD4);
00990  ASSERTION(mapHtm==nil,"mapHtm==nil");
00991  mapHtm = new sHtmlSymbol[ 256 ];
00992  ASSERTION(mapHtm!=nil,"mapHtm!=nil");
00993 
00994  if ( nHtmlTrans>0 ) {
00995      memset(bufMe,0x00,257);
00996      error = fread(bufMe,4,1,f);
00997      if ( error<1 ) return 1;
00998      if ( strncmp(bufMe,"HTML",4)!=0 ) return 2;
00999      error = fread(bufMe,4,1,f);
01000      if ( error<1 ) return 1;
01001      bufMe[4] = 0;
01002      sHtmlUnmap = (char*)bufMe;
01003      // Semicolon, regular, and null field
01004      error = fread(bufMe,3,1,f);
01005      if ( strcmp(bufMe,"; ")!=0 ) return 2;
01006      fscanf(f,"%c",&cHtmAsciiStt);
01007      if ( cHtmAsciiStt<0x80 ) return 2;
01008      error = fread(bufMe,4,1,f);
01009      if ( error<1 || strncmp(bufMe,"%%%~",4)!=0 ) return 2;
01010      // Iterate through all 'mapHtm'
01011      unsigned count;
01012      i = (unsigned)cHtmAsciiStt;
01013      for (count=0; count<nHtmlTrans; count++, i++) {
01014          error = fread(bufMe,10,1,f);
01015          if ( error<1 ) return 1;
01016          mapHtm[i].cCompNote = bufMe[9];
01017          bufMe[9] = 0;
01018          mapHtm[i].sTransHtm = (char*)bufMe;
01019          DBGPRINT("DBG:::%u:%-9s!%c\n",i,mapHtm[i].sTransHtm.Str(),mapHtm[i].cCompNote);
01020      }
01021      for (i=' '; i<127; i++) {
01022          mapHtm[i].SetCompatibleZero();
01023          mapHtm[i].sTransHtm.Add( (char)i );
01024      }
01025      mapHtm[' '].sTransHtm = (char*)"nbsp";
01026      mapHtm[' '].SetCompatible( true );
01027      mapHtm['"'].sTransHtm = (char*)"quot"; // &#34;
01028      mapHtm['"'].SetCompatible( true );
01029      mapHtm['&'].sTransHtm = (char*)"amp";  // &#38
01030      mapHtm['&'].SetCompatible( true );
01031      mapHtm['<'].sTransHtm = (char*)"lt";   // &#60
01032      mapHtm['<'].SetCompatible( true );
01033      mapHtm['>'].sTransHtm = (char*)"gt";   // &#62
01034      mapHtm['>'].SetCompatible( true );
01035  }
01036 
01037  error = isThisFlat ? 0 : 16;
01038  return error;
01039 }
01040 ////////////////////////////////////////////////////////////
01041 gStrControl::gStrControl ()
01042     : lastOpError( 0 ),
01043       fReport( stderr ),
01044       isInit( false ),
01045       useCaseCp( false ),
01046       doDigConvertRelaxed( false ),
01047       defIsoPage( 1 )
01048 {
01049  sPath = (char*)"/usr/share";
01050  sPathUnicode = sPath;
01051  sPathUnicode.Add( gSLASHCHR );
01052  sPathUnicode.Add( "unicodeplus" );
01053  isInit = Init( sPathUnicode.Str(), defIsoPage );
01054  DBGPRINT_MIN("DBG:gStrControl:isInit?%d,path=%s\n",isInit,sPathUnicode.Str());
01055  gStorageControl::Self().StaticAlloc( "gStrControl", 3 );
01056 }
01057 
01058 gStrControl::~gStrControl ()
01059 {
01060 }
01061 
01062 bool gStrControl::IsOkChar (t_uchar c)
01063 {
01064  return qckValidChr[c]!=0;
01065 }
01066 
01067 int gStrControl::GetFilenameCode (t_gCpCode aCpCode, gString& sCodepage)
01068 {
01069  unsigned uLen = sPathUnicode.Length()+30;
01070  gString sTemp( uLen, '\0' );
01071  if ( aCpCode>899999 ) return -1;
01072  snprintf( sTemp.Str(), uLen, "%s%ccp%06u.tcb",
01073            GetPathUnicode(),
01074            gSLASHCHR,
01075            aCpCode );
01076  sCodepage = sTemp;
01077  return 0;
01078 }
01079 
01080 int gStrControl::Compare (char* s1, char* s2, bool doIgnoreCase)
01081 {
01082  ASSERTION(s1!=nil,"s1!=nil");
01083  ASSERTION(s2!=nil,"s2!=nil");
01084  if ( doIgnoreCase==false ) return strcmp( s1, s2 );
01085  gString uS1( s1 );
01086  gString uS2( s2 );
01087  uS1.UpString();
01088  uS2.UpString();
01089  return strcmp( uS1.Str(), uS2.Str() );
01090 }
01091 
01092 int gStrControl::Init (char* strPath, t_gCpCode aIsoPage)
01093 {
01094  int lastOpError;
01095 
01096  if ( aIsoPage<1 ) return -1;
01097  // Temporary: strPath nil should provide a default path
01098  ASSERTION(strPath!=nil,"gStrControl(0)");
01099 
01100  gDir dir( strPath );
01101  lastOpError = dir.lastOpError;
01102  if ( lastOpError!=0 ) return lastOpError;
01103 
01104  gString sThbName( strPath );
01105  sThbName.Add( gSLASHCHR );
01106  sThbName.Add( "unicode256.thb" );
01107  sPathnameThb = sThbName;
01108 
01109  return thisInit( sPathnameThb.Str(), dir, aIsoPage );
01110 }
01111 
01112 bool gStrControl::UseCaseCodepage (bool doUseCaseCp)
01113 {
01114  useCaseCp = doUseCaseCp;
01115  // if ( doUseCaseCp==false ) return false
01116  // Read-out codepages, etc...
01117  return doUseCaseCp;
01118 }
01119 
01120 int gStrControl::InitTab (t_gCpCode aIsoPage)
01121 {
01122  ASSERTION_FALSE("InitTab");
01123  if ( sPath.IsEmpty() ) return -1;
01124  return 0;
01125 }
01126 
01127 int gStrControl::ConvertToUInt32 (char* s, t_uint32& vRes)
01128 {
01129  // Return 0 on success
01130  unsigned posErr;
01131  return
01132      ConvertToUInt32( s,
01133                       10,
01134                       e_DigConvAny,
01135                       vRes,
01136                       posErr );
01137 }
01138 
01139 int gStrControl::ConvertToInt32 (char* s, t_int32& vRes)
01140 {
01141  // Return 0 on success
01142  unsigned posErr;
01143  return
01144      ConvertToInt32( s,
01145                      10,
01146                      e_DigConvAny,
01147                      vRes,
01148                      posErr );
01149 }
01150 
01151 int gStrControl::ConvertToUInt32 (char* s,
01152                                   unsigned base,
01153                                   eDigitConv caseSense,
01154                                   t_uint32& vRes,
01155                                   unsigned& posErr)
01156 {
01157  // Return 0 on success
01158  unsigned i, len, kU, kD;
01159  t_uchar chr;
01160  static t_uchar convTblUp[17]="0123456789ABCDEF";
01161  static t_uchar convTblDn[17]="0123456789abcdef";
01162  t_uint64 uRes=0;
01163  bool doRelax = IsDigConvRelaxed();
01164 
01165  posErr = 0;
01166  if ( s==nil || base>16 ) return -1;
01167  gString sVal( s );
01168  sVal.Trim();
01169  len = sVal.Length();
01170  if ( len==0 ) {
01171      if ( caseSense!=e_DigConvAnyEmpty0 ) return -1;
01172      vRes = 0;
01173      return 0;
01174  }
01175  uRes = 0;
01176  for (i=1; i<=len; i++) {
01177      chr = sVal[i];
01178      posErr = i;
01179      for (kU=0; kU<base; kU++)
01180          if ( chr==convTblUp[kU] ) break;
01181      for (kD=0; kD<base; kD++)
01182          if ( chr==convTblDn[kD] ) break;
01183 
01184      switch ( caseSense ) {
01185      case e_DigConvLower:
01186          if ( kD>=base ) {
01187              if ( doRelax ) return ReturnAndAssignUInt32( -1, uRes, vRes );
01188              return -1;
01189          }
01190          uRes *= base;
01191          uRes += (t_uint32)kD;
01192          break;
01193      case e_DigConvUpper:
01194          if ( kU>=base ) {
01195              if ( doRelax ) return ReturnAndAssignUInt32( -1, uRes, vRes );
01196              return -1;
01197          }
01198          uRes *= base;
01199          uRes += (t_uint32)kU;
01200          break;
01201      case e_DigConvAny:
01202      case e_DigConvAnyEmpty0:
01203          if ( kU>=base && kD>=base ) {
01204              if ( doRelax ) return ReturnAndAssignUInt32( -1, uRes, vRes );
01205              return -1;
01206          }
01207          uRes *= base;
01208          if ( kU<base )
01209              uRes += (t_uint32)kU;
01210          else
01211              uRes += (t_uint32)kD;
01212          break;
01213      default:
01214          ASSERTION_FALSE("ConvertToUInt32(1)");
01215          break;
01216      }
01217  }
01218  posErr = 0;
01219  ReturnAndAssignUInt32( 0, uRes, vRes );
01220  return 0;
01221 }
01222 
01223 int gStrControl::ConvertToInt32 (char* s,
01224                                  unsigned base,
01225                                  eDigitConv caseSense,
01226                                  t_int32& vRes,
01227                                  unsigned& posErr)
01228 {
01229  // Return 0 on success
01230  int error;
01231  t_uint32 vAux = 0;
01232  t_int32 mySign;
01233  gString sTrim;
01234  bool isSigned;
01235 
01236  if ( s==nil ) return -1;
01237  sTrim.Set( s );
01238  if ( caseSense==e_DigConvAny ) sTrim.Trim();
01239  char* str = sTrim.Str();
01240  isSigned = str[0]=='-';
01241  mySign = isSigned ? -1 : 1;
01242  error = ConvertToUInt32( str+isSigned, base, caseSense, vAux, posErr );
01243  if ( error!=0 ) return error;
01244  // Check ranges
01245  if ( (long long)vAux >= MAX_LONG_L ) return 1;
01246 
01247  // All seem o.k., set the value for output: 'vRes'
01248  vRes = (t_int32)vAux * mySign;
01249 
01250  return 0;
01251 }
01252 
01253 void gStrControl::ConvertBinToStr (t_uint32 v, t_int16 places, gString& sRes)
01254 {
01255  unsigned i, n;
01256  char c;
01257  gString sReverse;
01258 
01259  sRes.SetEmpty();
01260 
01261  for (n=0; v>0; n++) {
01262      c = (v & 1) ? '1' : '0';
01263      sReverse.Add( c );
01264      v >>= 1;
01265  }
01266  if ( n==0 ) {
01267      sReverse.Set( "0" );
01268      n++;
01269  }
01270 
01271  for (i=n; (int)i<places; i++) {
01272      sRes.Add( "0" );
01273  }
01274  for (i=n; i>0; i--) {
01275      sRes.Add( sReverse[i] );
01276  }
01277 }
01278 
01279 int gStrControl::ReturnAndAssignUInt32 (int returnValue, t_uint64 value, t_uint32& vRes)
01280 {
01281  vRes = 0;
01282  if ( value > MAX_U4B_ULL ) return -2;
01283  vRes = value;
01284  return returnValue;
01285 }
01286 
01287 int gStrControl::thisInit (char* thbFilename, gDir& dir, t_gCpCode aIsoPage)
01288 {
01289  short qckIdx;
01290 
01291  DBGPRINT_MIN("DBG:gStrControl::thisInit: aIsoPage=%ld, m=%u, thb=%s\n",(long)aIsoPage,dir.N(),thbFilename);
01292  // memset: to be quick
01293  memset( qckValidChr, 0, 256 );
01294  for (qckIdx=(short)' '; qckIdx<256; qckIdx++) qckValidChr[qckIdx] = qckIdx>=' ' && qckIdx<127;
01295 
01296  return 0;
01297 }
01298 
01299 
01300 unsigned gStrControl::thisFind (char* s,
01301                                 char* sub,
01302                                 unsigned startPos,
01303                                 bool doIgnoreCase,
01304                                 bool doUseCaseCp)
01305 {
01306  char* ptr;
01307 
01308  if ( s==nil || sub==nil ) return 0;
01309  ASSERTION(startPos>=1,"startPos>=1");
01310 
01311  gString uStr( s );
01312  gString uSub( sub );
01313 
01314  if ( doIgnoreCase ) {
01315      uStr.UpString();
01316      uSub.UpString();
01317      s = uStr.Str();
01318      sub = uSub.Str();
01319  }
01320 
01321  ptr = strstr( s+startPos-1, sub );
01322 
01323  ASSERTION(doUseCaseCp==false,"doUseCaseCp==false: TODO");
01324 
01325  if ( ptr!=0 ) return ptr+startPos-s;
01326  return 0;
01327 }
01328 
01329 unsigned gStrControl::thisFindChr (char* s,
01330                                    t_uchar subChr,
01331                                    unsigned startPos,
01332                                    bool doIgnoreCase,
01333                                    bool doUseCaseCp)
01334 {
01335  char sAux[2];
01336  sAux[0] = (char)subChr;
01337  sAux[1] = 0;
01338  return thisFind( s, sAux, startPos, doIgnoreCase, doUseCaseCp );
01339 }
01340 ////////////////////////////////////////////////////////////
01341 sFileKind::sFileKind ()
01342 {
01343 }
01344 
01345 sFileKind::sFileKind (gString& s)
01346 {
01347  Process( s );
01348 }
01349 
01350 sFileKind::~sFileKind ()
01351 {
01352 }
01353 
01354 int sFileKind::Process (gString& s)
01355 {
01356  unsigned i, n, pos;
01357 
01358  sAll = s;
01359  gParam aParam( s, ";" );
01360  n = aParam.N();
01361  for (i=1; i<=n; i++) compL.Add( aParam.Str(i) );
01362  if ( n==0 ) return -1;
01363  gString sLeft( compL.Str(1) );
01364  gString sRight( n<2 ? (char*)"\0" : aParam.Str(2) );
01365  pos = sLeft.Find(',');
01366  if ( pos>0 ) sLeft.Delete(1,pos);
01367  sLeft.Trim();
01368  gParam leftParam( sLeft, "/" );
01369  n = leftParam.N();
01370  if ( n<2 ) return 1;
01371  sMain = leftParam.Str( 1 );
01372  sSub = leftParam.Str( 2 );
01373  mainL.Add( sMain );
01374  mainL.Add( sSub );
01375 
01376  if ( sRight.Find("charset=")>0 ) {
01377      sCharset.CopyFromTo( sRight, 9 );
01378  }
01379 
01380  return 0;
01381 }
01382 
01383 void sFileKind::Show (bool doShowAll)
01384 {
01385  if ( doShowAll ) {
01386      printf("All:%s\n",sAll.Str());
01387      printf("Main:"); mainL.Show(true);
01388      printf("Comp:"); compL.Show(true);
01389  }
01390  printf("[%s|%s]%s!\n",sMain.Str(),sSub.Str(),sCharset.Str());
01391 }
01392 ////////////////////////////////////////////////////////////
01393 gUniString::gUniString ()
01394     : gStringGeneric(
01395         e_String,
01396         gStringGeneric::e_StrAlloc,
01397         (t_uchar*)"\0",
01398         0)
01399 {
01400 }
01401 
01402 gUniString::gUniString (char* s)
01403     : gStringGeneric(
01404         e_String,
01405         gStringGeneric::e_StrAlloc,
01406         (t_uchar*)s,
01407         0)
01408 {
01409  ASSERTION(s!=nil,"s!=nil");
01410 }
01411 
01412 gUniString::gUniString (t_uchar* s)
01413     : gStringGeneric(
01414         e_String,
01415         gStringGeneric::e_StrAlloc,
01416         s,
01417         0)
01418 {
01419  ASSERTION(s!=nil,"s!=nil");
01420 }
01421 
01422 t_uint32 gUniString::GetHexa (eDigitConv caseSense)
01423 {
01424  unsigned posErr, vRes=0;
01425  gStrControl::Self().ConvertToUInt32( (char*)str,
01426                                       16,
01427                                       caseSense,
01428                                       vRes,
01429                                       posErr );
01430  return vRes;
01431 }
01432 
01433 t_uint32 gUniString::GetHexa0x (eDigitConv caseSense)
01434 {
01435  unsigned posErr, vRes=0;
01436  if ( str[0]!='0' || str[1]!='x' ) return 0;
01437  gStrControl::Self().ConvertToUInt32( (char*)(str+2),
01438                                       16,
01439                                       caseSense,
01440                                       vRes,
01441                                       posErr );
01442  return vRes;
01443 }
01444 
01445 void gUniString::SetEmpty ()
01446 {
01447  gStringGeneric::SetEmpty();
01448  thisUniUpdate();
01449 }
01450 
01451 void gUniString::Set (char* s)
01452 {
01453  ASSERTION(s!=nil,"gUniStringGeneric::Set");
01454  Set( (t_uchar*)s );
01455 }
01456 
01457 void gUniString::Set (t_uchar* s)
01458 {
01459  ASSERTION(s!=nil,"gUniStringGeneric::Set");
01460  gStringGeneric::Set( s );
01461  thisUniUpdate();
01462 }
01463 
01464 unsigned gUniString::Add (char c)
01465 {
01466  return Add( (t_uchar)c );
01467 }
01468 
01469 unsigned gUniString::Add (t_uchar c)
01470 {
01471  unsigned vRes;
01472  vRes = Add( (t_uchar)c );
01473  thisUniUpdate();
01474  return vRes;
01475 }
01476 
01477 unsigned gUniString::Add (char* s)
01478 {
01479  return Add( (t_uchar*)s );
01480 }
01481 
01482 unsigned gUniString::Add (t_uchar* s)
01483 {
01484  unsigned vRes;
01485  vRes = gStringGeneric::Add( s );
01486  thisUniUpdate();
01487  return vRes;
01488 }
01489 
01490 void gUniString::UpString ()
01491 {
01492  gStringGeneric::UpString();
01493 }
01494 
01495 void gUniString::DownString ()
01496 {
01497  gStringGeneric::DownString();
01498 }
01499 
01500 gUniString& gUniString::CopyFromTo (gUniString& copy, unsigned startPos, unsigned endPos)
01501 {
01502  thisUniCopyFromTo( copy, startPos, endPos );
01503  thisUniUpdate();
01504  return *this;
01505 }
01506 
01507 unsigned gUniString::Delete (unsigned startPos, unsigned endPos)
01508 {
01509  unsigned vRes = thisUniDelete( startPos, endPos );
01510  thisUniUpdate();
01511  return vRes;
01512 }
01513 
01514 t_uchar& gUniString::operator[] (int index)
01515 {
01516  if ( thisIsValidIndex(index)==false ) return myChrNul;
01517  thisUniUpdate();
01518  doRevalidateSize = true;
01519  return str[index-1];
01520 }
01521 
01522 void gUniString::Show (bool doShowAll)
01523 {
01524  gStringGeneric::Show(doShowAll);
01525 }
01526 
01527 gStorage* gUniString::NewObject ()
01528 {
01529  gUniString* a = new gUniString( str );
01530  return a;
01531 }
01532 
01533 t_uchar* gUniString::ToString (t_uchar* uBuf)
01534 {
01535  return str;
01536 }
01537 
01538 bool gUniString::SaveGuts (FILE* f)
01539 {
01540  if ( CanSave( f )==false ) return false;
01541  if ( str==nil ) return true;
01542  return fprintf(f,"%s",str)==1;
01543 }
01544 
01545 bool gUniString::RestoreGuts (FILE* f)
01546 {
01547  unsigned n=0;
01548  t_uchar uChr;
01549  gUCharBuffer sTemp;
01550 
01551  if ( CanRestore( f )==false ) return false;
01552  thisDelete();
01553 
01554  while ( fscanf(f,"%c",&uChr) ) {
01555      if ( uChr=='\n' || uChr==0 ) break;
01556      sTemp.uBuf[n++] = uChr;
01557      sTemp.uBuf[n] = 0;
01558      if ( n>=sTemp.size ) return false;
01559  }
01560  thisCopy( sTemp.uBuf, n );
01561  return true;
01562 }
01563 
01564 void gUniString::thisUniUpdate()
01565 {
01566 }
01567 
01568 unsigned gUniString::thisUniDelete (unsigned startPos, unsigned endPos)
01569 {
01570  // This method is copied from gString::Delete !
01571  ;
01572  unsigned
01573      oldSize=size,
01574      i, k,
01575      p0=startPos==0?1:startPos,
01576      p1=endPos==0?size:gMIN(endPos,size);
01577 
01578  if ( startPos==0 && endPos==0 ) {
01579      SetEmpty();
01580      return oldSize;
01581  }
01582 
01583  if ( p0>size ) return 0;
01584 
01585  gString sTemp;
01586  for (i=1, k=0; i<p0; i++, k++) sTemp.Add( (char)str[k] );
01587  for (i=p1+1, k=p1; i<=size; i++, k++) sTemp.Add( (char)str[k] );
01588 
01589  Set( sTemp.Str() );
01590  ASSERTION(oldSize>=size,"oldSize>=size");
01591  oldSize -= size;
01592  return oldSize;
01593 }
01594 
01595 gUniString& gUniString::ConvertChrFromTo (t_uchar chrFrom, t_uchar chrTo)
01596 {
01597  unsigned i, len = Length();
01598 
01599  ASSERTION(chrFrom!=0,"chrFrom!=0");
01600  ASSERTION(chrTo!=0,"chrTo!=0");
01601  for (i=0; i<len; i++) {
01602      if ( str[ i ]==chrFrom ) str[ i ] = chrTo;
01603  }
01604 
01605  return *this;
01606 }
01607 
01608 int gUniString::thisUniCopyFromTo (gUniString& copy, unsigned startPos, unsigned endPos)
01609 {
01610  // This method is copied from gString::CopyFromTo !
01611  ;
01612  unsigned i, k, len = copy.Length();
01613 
01614  thisDelete();
01615  if ( startPos==0 ) startPos = 1;
01616  if ( endPos==0 ) endPos = len;
01617  if ( endPos>len ) endPos = len;
01618  if ( startPos>endPos ) return -1;
01619 
01620  thisCopy( (t_uchar*)"\0", 1+endPos-startPos );
01621 
01622  for (i=startPos, k=0; i<=endPos; i++) {
01623      str[k++] = copy[i];
01624  }
01625  str[k] = 0;
01626  doRevalidateSize = true;
01627  return 0;
01628 }
01629 ////////////////////////////////////////////////////////////
01630 

Generated on Sat Aug 18 02:40:59 2007 for xpfweb_v2x lib by  doxygen 1.4.2