gstringext.h

Go to the documentation of this file.
00001 #ifndef gSTRINGEXT_X_H
00002 #define gSTRINGEXT_X_H
00003 
00004 #include "gstring.h"
00005 #include "glist.h"
00006 #include "gdir.h"
00007 
00008 #define THB_MAJOR_VERSION     '1'
00009 #define THB_MINOR_VERSION_APH 'A'
00010 #define THB_VERS_REVISION     0
00011 #define SYM_REFVERS_UNICODE   'D'
00012 
00013 #define EXTUMASK_ISALPHA      1
00014 #define EXTUMASK_ISDIGIT      2
00015 #define EXTUMASK_ISSPACE      4
00016 #define EXTUMASK_ISPRINT      8
00017 
00018 
00019 typedef t_uint16 t_gPageCode;
00020 typedef t_uint32 t_gUniPage;
00021 typedef t_uint32 t_gCpCode;
00022 
00023 enum eDigitConv {
00024     e_DigConvLower,
00025     e_DigConvUpper,
00026     e_DigConvAny,
00027     e_DigConvAnyEmpty0
00028 };
00029 ////////////////////////////////////////////////////////////
00030 class gDateDay : public gUInt {
00031 public:
00032     gDateDay (t_uint32 aDd=0) ;
00033     virtual ~gDateDay () ;
00034 
00035     // Get methods
00036     virtual bool IsValid () {
00037         return dd>0;
00038     }
00039     virtual t_uint32 GetValue32 () {
00040         return dd;
00041     }
00042     t_uint16 GetYear () ;
00043     t_uint16 GetMonth () ;
00044     t_uint16 GetDay () ;
00045 
00046     virtual int MinimumStorageSize () {
00047         return MaximumStorageSize();
00048     }
00049 
00050     // Set methods
00051     bool SetDay (t_uint32 aDd) ;
00052 
00053     // Save/etc methods
00054     virtual gStorage* NewObject () ;
00055     virtual bool SaveGuts (FILE* f) ;
00056     virtual bool RestoreGuts (FILE* f) ;
00057 
00058 protected:
00059     t_uint32 dd;
00060 
00061 private:
00062     // Operators,empty
00063     gDateDay (gDateDay& ) ;
00064     gDateDay& operator= (gDateDay& ) ;
00065 };
00066 ////////////////////////////////////////////////////////////
00067 struct sIanaCountry2 {
00068     char twoLetter[3];
00069     char* strCountry;  // english designation of country
00070 };
00071 ////////////////////////////////////////////////////////////
00072 struct sCodeToUni {
00073     sCodeToUni ()
00074         : lCode( 0x0000 ),
00075           uniCode( 0 ) {
00076     }
00077     t_gPageCode lCode;
00078     t_gUniPage uniCode;
00079 };
00080 
00081 struct sTcbBin {
00082     sTcbBin () ;
00083     ~sTcbBin () ;
00084 
00085     char verMajor[6];        // 5 octet
00086     char cLevel;             // '0'
00087     gDateDay revisionDate;
00088     t_uchar revisionRef;
00089     char cNormRef;           // 'I'=ISO, 'C'=codepage, 'D' other
00090     char sDescTag[13];       // Short description ("ISO8859-1")
00091     gString sDescStr;
00092     t_gCpCode cpCode;        // e.g. 885901 (ISO8859-1)
00093     char cLinearInd;         // 'a'/'b' or 'B'
00094     t_uint32 nSymb;          // number of symbols,
00095                              // including 0x00
00096     t_gUniPage* linearTbl;   // 0-based, for 'a' linear
00097     sCodeToUni* bigTbl;      // sorted by lCode, for 'B'
00098 
00099     bool IsLinear () ;
00100 
00101     int ReadFromStream (FILE* f) ;
00102     int ReadFromFile (char* fName) ;
00103 };
00104 ////////////////////////////////////////////////////////////
00105 struct sUnCodeSymbol {
00106     sUnCodeSymbol ()
00107         : uniCode( 0x7FFFF ),
00108           symbolName( nil ),
00109           statZero( '0' ),
00110           cIsOpenClose( ' ' ),
00111           extEqClose( 0 ),
00112           ucUpper( 0 ),
00113           ucDown( 0 ),
00114           ucUpRngExt( 0 ),
00115           refVersLetter( (t_uchar)SYM_REFVERS_UNICODE ),
00116           extUtMask( 0x0000 ) {
00117         twoLetterCat[0] = twoLetterCat[1] = twoLetterCat[2] = 0;
00118         thrLetterStyle[0] = thrLetterStyle[1] = 0;
00119         thrLetterStyle[2] = thrLetterStyle[3] = 0;
00120     }
00121     ~sUnCodeSymbol () {
00122         delete symbolName;
00123     }
00124 
00125     t_gUniPage uniCode;
00126     gString* symbolName;
00127     char twoLetterCat[3]; //Category (e.g. Lu=letter, uppercase)
00128     char statZero;        // Not relevant, always '0'
00129     char thrLetterStyle[4];
00130     gString strCompat;    // e.g.: <fraction> 0031 2044 0034
00131     t_gUniPage ucCompat;  // Not in UniCode: uniCode char equivalent, 0x0 if not applicable
00132     gString strNumber;    // e.g.: 1/2
00133     char cIsOpenClose;    // Either Y or N; e.g. '(' is Y.
00134     t_gUniPage extEqClose;// Not in UniCode: '(' points to ')', not vice-versa
00135     gString strNote;      // LATIN SMALL LETTER SHARP S has note "German"
00136     t_gUniPage ucUpper;   // Uppercase equivalent code
00137     t_gUniPage ucDown;    // Downcase equivalent code
00138     t_gUniPage ucUpRngExt;// Uppercase extended range (not used)
00139     gString strLocale;    // Usually empty
00140     t_uchar refVersLetter;// 'D' stands for UniCode version 4
00141     t_uint16 extUtMask;   // Not in UniCode: utilization mask
00142 
00143     static short strSymNameLen;  // 60 octet, including 0x00
00144     static char symBufExt[257];
00145 
00146     // Get methods
00147     bool IsValid () ;
00148     bool HasName () {
00149         return symbolName!=nil;
00150     }
00151     bool IsLetter () {
00152         return twoLetterCat[0]=='L';
00153     }
00154     bool IsLetterUpcase () {
00155         return IsLetter()==true && twoLetterCat[1]=='u';
00156     }
00157     bool IsLetterDowncase () {
00158         return IsLetter()==true && twoLetterCat[1]=='l';
00159     }
00160 
00161     // Set methods
00162     void SetCode (t_gUniPage aCode) ;
00163 
00164     // Save/etc methods
00165     int SaveBin (FILE* f) ;
00166     int ReadBin (FILE* f) ;
00167 };
00168 
00169 struct sHtmlSymbol {
00170     sHtmlSymbol ()
00171         : cCompNote( (t_uchar)'@' ) {
00172     }
00173     gString sTransHtm;
00174     t_uchar cCompNote;
00175     // Aux members
00176     static char sBuf[50];
00177     // Get methods
00178     bool IsNormal () {
00179         return cCompNote=='`';
00180     }
00181     bool IsOk () {
00182         return cCompNote>='`' && cCompNote!='b' && cCompNote!='c' && cCompNote<='m';
00183     }
00184     int GetCompatLevel () {
00185         // @=invalid; a=1; b,c=-1; d=4; e=5, ...m
00186         return IsOk() ? (int)cCompNote-(int)'a'+1 : -1;
00187     }
00188     char* GetHtmlStr () ;
00189     // Set methods
00190     bool SetCompatible (bool isOk) {
00191         cCompNote = isOk ? 'a' : '@';
00192         return isOk;
00193     }
00194     bool SetCompatibleZero () {
00195         cCompNote = (t_uchar)'`';
00196         return true;
00197     }
00198 };
00199 
00200 struct sUnCodeBin {
00201     enum eDescStg {
00202         e_DescNone = 0,
00203         e_Desc40Byte = 40,
00204         e_Desc60ByteDef = 60,
00205         e_Desc80Byte = 80,
00206         e_Desc255Byte = 255
00207     };
00208 
00209     sUnCodeBin () ;
00210     ~sUnCodeBin () ;
00211 
00212     unsigned n;
00213     sUnCodeSymbol* mapTab;    // [1...]based index
00214     char verMajor[6];         // 5 octet
00215     t_uchar verHtml;
00216     t_uchar cUniLevel;        // '0'
00217     eDescStg descStg;
00218     gDateDay revisionDate;
00219     t_uchar revisionRef;
00220     char revReferenceStr[17]; // 16 octet
00221     t_uchar cExtTbl;          // '2':no HTML; 3:with
00222     // HTML-TRANS
00223     unsigned nHtmlTrans;      // number of symbols
00224     gString sHtmlUnmap;       // default "[hs."
00225     sHtmlSymbol* mapHtm;      // HTML-TRANS
00226     t_uchar cHtmAsciiStt;     // usually 0xA0
00227 
00228     // Get methods
00229     unsigned N () {
00230         return n;
00231     }
00232     int GetMajorVersion () ;
00233     bool HasHtml () ;
00234     char GetDescStgChr () ;
00235     bool IsFlat (t_uchar& chr) ;
00236     bool IsFlatOk () ;
00237     t_uint32 FindCode (t_gUniPage aCode) ;
00238 
00239     char GetLetterCompat (t_gUniPage aCode) ;
00240 
00241     // Set methods
00242     int AllocateSymbols (int nSymbols) ;
00243     int SetVersion (t_uchar aMajorVersion, t_uchar aMinorAlpha) ;
00244     int SetNTables (bool hasHtmlTrans, int nExtTbl) ;
00245 
00246     int SaveToFile (char* fName) ;
00247     int SaveToStream (FILE* f) ;
00248     int ReadFromFile (char* fName) ;
00249     int ReadFromStream (FILE* f) ;
00250 };
00251 ////////////////////////////////////////////////////////////
00252 class gStrControl {
00253 public:
00254     ~gStrControl () ;
00255 
00256     static gStrControl& Self () {
00257         return myself;
00258     }
00259 
00260     // Public data-members
00261     int lastOpError;
00262     FILE* fReport;
00263     static sIanaCountry2 tblIanaCountry[];
00264 
00265     // Get methods
00266     bool DoUseCaseCp () {
00267         return useCaseCp;
00268     }
00269     bool IsOkChar (t_uchar c) ;
00270 
00271     t_gCpCode GetDefaultIsoPage () {
00272         return defIsoPage;
00273     }
00274 
00275     bool IsDigConvRelaxed () {
00276         return doDigConvertRelaxed;
00277     }
00278 
00279     char* GetPathUnicode () {
00280         return sPathUnicode.Str();
00281     }
00282 
00283     int GetFilenameCode (t_gCpCode aCpCode, gString& sCodepage) ;
00284 
00285     // Other get methods
00286     bool Match (char* s1, char* s2, bool doIgnoreCase=false) {
00287         return Compare( s1, s2, doIgnoreCase )==0;
00288     }
00289     int Compare (char* s1, char* s2, bool doIgnoreCase=false) ;
00290     unsigned Find (char* s, char* sub, bool doIgnoreCase=false) {
00291         return thisFind( s, sub, 1, doIgnoreCase, DoUseCaseCp() );
00292     }
00293 
00294     unsigned Find (char* s, t_uchar subChr, bool doIgnoreCase=false) {
00295         return thisFindChr( s, subChr, 1, doIgnoreCase, DoUseCaseCp() );
00296     }
00297 
00298     // Set methods
00299     int Init (char* strPath=nil, t_gCpCode aIsoPage=1) ;
00300     int InitTab (t_gCpCode aIsoPage) ;
00301     bool UseCaseCodepage (bool doUseCaseCp) ;
00302 
00303     void SetConvertRelax (bool doRelax) {
00304         doDigConvertRelaxed = doRelax;
00305     }
00306 
00307     // Specific methods
00308     int ConvertToUInt32 (char* s,
00309                          t_uint32& vRes) ;
00310 
00311     int ConvertToInt32 (char* s,
00312                         t_int32& vRes) ;
00313 
00314     int ConvertToUInt32 (char* s,
00315                          unsigned base,
00316                          eDigitConv caseSense,
00317                          t_uint32& vRes,
00318                          unsigned& posErr) ;
00319 
00320     int ConvertToInt32 (char* s,
00321                          unsigned base,
00322                          eDigitConv caseSense,
00323                          t_int32& vRes,
00324                          unsigned& posErr) ;
00325 
00326     int ConvertHexToUInt32 (char* s,
00327                             eDigitConv caseSense,
00328                             t_uint32& vRes) {
00329         unsigned posErr;
00330         return ConvertToUInt32( s, 16, caseSense, vRes, posErr );
00331     }
00332 
00333     void ConvertBinToStr (t_uint32 v,
00334                           t_int16 places,  // <=0 for no justify
00335                           gString& sRes) ;
00336 
00337     void ConvertBinToStr (t_uint32 v,
00338                           gString& sRes) {
00339         ConvertBinToStr( v, 0, sRes );
00340     }
00341 
00342     int ReturnAndAssignUInt32 (int returnValue,
00343                                t_uint64 value,
00344                                t_uint32& vRes) ;
00345 
00346 protected:
00347     gStrControl () ;
00348 
00349     int thisInit (char* thbFilename, gDir& dir, t_gCpCode aIsoPage) ;
00350 
00351     unsigned thisFind (char* s,
00352                        char* sub,
00353                        unsigned startPos,
00354                        bool doIgnoreCase,
00355                        bool doUseCaseCp) ;
00356 
00357     unsigned thisFindChr (char* s,
00358                           t_uchar subChr,
00359                           unsigned startPos,
00360                           bool doIgnoreCase,
00361                           bool doUseCaseCp) ;
00362 
00363 private:
00364     static gStrControl myself;
00365     bool isInit;
00366     bool useCaseCp;
00367     bool doDigConvertRelaxed;
00368     t_gCpCode defIsoPage;
00369     gString sPath;
00370     gString sPathUnicode;
00371     gString sPathnameThb;
00372     t_uchar qckValidChr[256];
00373 
00374     // Operators,empty
00375     gStrControl (gStrControl& ) ; //empty
00376     gStrControl& operator= (gStrControl& ) ; //empty
00377 };
00378 ////////////////////////////////////////////////////////////
00379 struct sFileKind {
00380     sFileKind () ;
00381     sFileKind (gString& s) ;
00382     ~sFileKind () ;
00383     gString sAll;    // Complete string
00384     gString sMain;   // e.g.: text (of text/plain)
00385     gString sSub;    // e.g.: plain
00386     gString sCharset;// e.g.: iso-8859-1
00387     gList mainL;     // e.g.: (text plain)
00388     gList compL;     // e.g.: (text/plain charset=iso-8859-1)
00389     // Set methods
00390     int Process (gString& s) ;
00391     // Show methods
00392     void Show (bool doShowAll=true) ;
00393 };
00394 ////////////////////////////////////////////////////////////
00395 class gUniString : public gStringGeneric {
00396 public:
00397     gUniString () ;
00398     gUniString (char* s) ;
00399     gUniString (t_uchar* s) ;
00400 
00401     // Get methods
00402     t_uint32 GetHexa (eDigitConv caseSense=e_DigConvAny) ;
00403     t_uint32 GetHexa0x (eDigitConv caseSense=e_DigConvAny) ;
00404 
00405     // Set methods
00406     virtual void SetEmpty () ;
00407     void Set (char* s) ;
00408     void Set (t_uchar* s) ;
00409 
00410     unsigned Add (char c) ;
00411     unsigned Add (t_uchar c) ;
00412     unsigned Add (char* s) ;
00413     unsigned Add (t_uchar* s) ;
00414     virtual void UpString () ;
00415     virtual void DownString () ;
00416 
00417     virtual gUniString& CopyFromTo (gUniString& copy, unsigned startPos, unsigned endPos) ;
00418 
00419     virtual unsigned Delete (unsigned startPos=0, unsigned endPos=0) ;
00420 
00421     virtual gUniString& ConvertChrFromTo (t_uchar chrFrom, t_uchar chrTo) ;
00422 
00423     // Operators
00424     t_uchar& operator[] (int index) ;
00425 
00426     // Save/etc methods
00427     gStorage* NewObject () ;
00428     virtual t_uchar* ToString (t_uchar* uBuf) ;
00429     virtual bool SaveGuts (FILE* f) ;
00430     virtual bool RestoreGuts (FILE* f) ;
00431 
00432     // Show methods
00433     void Show (bool doShowAll) ;
00434 
00435 protected:
00436     void thisUniUpdate() ;
00437     unsigned thisUniDelete (unsigned startPos, unsigned endPos) ;
00438     int thisUniCopyFromTo (gUniString& copy, unsigned startPos, unsigned endPos) ;
00439 
00440 private:
00441     // Operators,empty
00442     gUniString (gUniString& ) ;
00443     gUniString& operator= (gUniString& ) ;
00444 };
00445 ////////////////////////////////////////////////////////////
00446 #endif //gSTRINGEXT_X_H
00447 

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