00001
00002
00003 #include <string.h>
00004 #include "gstringext.h"
00005 #include "garg.h"
00006 #include "gdir.h"
00007
00008
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
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
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
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 ),
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
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
00448
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
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);
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);
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);
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);
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);
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);
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);
00576 if ( error<1 ) return 1;
00577 error = fread(symBufExt,2,1,f);
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);
00586 if ( error<1 || symBufExt[60]!=0x00 ) return 1;
00587
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==';';
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
00676
00677
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");
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
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);
00791
00792 aUD2 = TO_UD2(3);
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
00806
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
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
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,
00834 0x00,
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
00861
00862
00863
00864
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
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);
00937
00938 error = fread(bufMe,4,1,f);
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
00958 mapTab = new sUnCodeSymbol[ n+1 ];
00959 ASSERTION(mapTab!=nil,"mapTab!=nil");
00960
00961 mapTab[0].strSymNameLen = (short)descStg;
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);
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
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
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";
01028 mapHtm['"'].SetCompatible( true );
01029 mapHtm['&'].sTransHtm = (char*)"amp";
01030 mapHtm['&'].SetCompatible( true );
01031 mapHtm['<'].sTransHtm = (char*)"lt";
01032 mapHtm['<'].SetCompatible( true );
01033 mapHtm['>'].sTransHtm = (char*)"gt";
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
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
01116
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
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
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
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
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
01245 if ( (long long)vAux >= MAX_LONG_L ) return 1;
01246
01247
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
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
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
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