rsc/inc/rscdef.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rscdef.hxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _RSCDEF_HXX
  31 #define _RSCDEF_HXX
  32
  33 #ifndef _TOOLS_UNQIDX_HXX
  34 #include <tools/unqidx.hxx>
  35 #endif
  36 #include <rsctree.hxx>
  37
  38 /****************** C L A S S E S ****************************************/
  39 class RscExpression;
  40 class RscFileTab;
  41 class RscDefine;
  42
  43 /*********** R s c E x p r e s s i o n ***********************************/
  44 #define RSCEXP_LONG     0
  45 #define RSCEXP_EXP              1
  46 #define RSCEXP_DEF              2
  47 #define RSCEXP_NOTHING  3
  48
  49 class RscExpType
  50 {
  51 public:
  52     union {
  53         RscExpression * pExp;
  54         RscDefine         * pDef;
  55         struct {
  56              short                       nHi;
  57              unsigned short  nLo;
  58         } aLong;
  59     } aExp;
  60     char cType;
  61     char cUnused;
  62     BOOL IsNumber()    const { return( RSCEXP_LONG         == cType ); }
  63     BOOL IsExpression()const { return( RSCEXP_EXP          == cType ); }
  64     BOOL IsDefinition()const { return( RSCEXP_DEF          == cType ); }
  65     BOOL IsNothing()   const { return( RSCEXP_NOTHING  == cType ); }
  66     void SetLong( INT32 lValue ){
  67             aExp.aLong.nHi = (short)(lValue >> 16);
  68             aExp.aLong.nLo = (unsigned short)lValue;
  69             cType = RSCEXP_LONG;
  70          }
  71     INT32 GetLong() const{
  72              return aExp.aLong.nLo |
  73                     ((INT32)aExp.aLong.nHi << 16);
  74          }
  75     BOOL Evaluate( INT32 * pValue ) const;
  76     void GetMacro( ByteString & ) const;
  77 };
  78
  79 /*********** R s c I d ***************************************************/
  80 class RscId
  81 {
  82     static              BOOL bNames;// FALSE, bei den Namenoperation nur Zahlen
  83 public:
  84     RscExpType  aExp;           // Zahl, Define oder Ausdruck
  85     INT32       GetNumber() const;
  86     void        Create( const RscExpType & rExpType );
  87     void        Create(){ aExp.cType = RSCEXP_NOTHING; }
  88
  89             RscId() { Create();                                                 }
  90
  91             RscId( RscDefine * pEle );
  92             RscId( INT32 lNumber )
  93                     { aExp.SetLong( lNumber );                  }
  94
  95             RscId( const RscExpType & rExpType )
  96                     { Create( rExpType );                               }
  97
  98             void Destroy();
  99
 100             ~RscId(){
 101                 Destroy();
 102             }
 103
 104             RscId( const RscId& rRscId );
 105
 106             RscId& operator = ( const RscId& rRscId );
 107
 108     static BOOL    IsSetNames();
 109     static void    SetNames( BOOL bSet = TRUE );
 110     operator         INT32() const;   // Gibt Nummer zurueck
 111     ByteString     GetName()  const;   // Gibt den Namen des Defines zurueck
 112     ByteString     GetMacro()  const;  // Gibt das Macro zurueck
 113     BOOL        operator <      ( const RscId& rRscId ) const;
 114     BOOL        operator >      ( const RscId& rRscId ) const;
 115     BOOL        operator == ( const RscId& rRscId ) const;
 116     BOOL        operator <=  ( const RscId& rRscId ) const
 117             { return !(operator > ( rRscId )); }
 118     BOOL        operator >= ( const RscId& rRscId ) const
 119             { return !(operator < ( rRscId )); }
 120     BOOL        IsId() const { return !aExp.IsNothing(); }
 121 };
 122
 123 /*********** R s c D e f i n e *******************************************/
 124 class RscDefine : public StringNode
 125 {
 126 friend class RscFileTab;
 127 friend class RscDefineList;
 128 friend class RscDefTree;
 129 friend class RscExpression;
 130 friend class RscId;
 131     ULONG                       lFileKey;       // zu welcher Datei gehoert das Define
 132     sal_uInt32                  nRefCount;      // Wieviele Referenzen auf dieses Objekt
 133     INT32                       lId;            // Identifier
 134     RscExpression * pExp;               // Ausdruck
 135 protected:
 136
 137             RscDefine( ULONG lFileKey, const ByteString & rDefName,
 138                        INT32 lDefId );
 139             RscDefine( ULONG lFileKey, const ByteString & rDefName,
 140                        RscExpression * pExpression );
 141             ~RscDefine();
 142     void        IncRef(){ nRefCount++; }
 143     sal_uInt32  GetRefCount() const    { return nRefCount; }
 144     void        DecRef();
 145     void        DefineToNumber();
 146     void        SetName( const ByteString & rNewName ){ aName = rNewName; }
 147     void        ChangeMacro( RscExpression * pExpression );
 148     void        ChangeMacro( INT32 lIdentifier );
 149
 150     using StringNode::Search;
 151 public:
 152     RscDefine * Search( const char * );
 153     ULONG               GetFileKey() const { return lFileKey; }
 154     BOOL                Evaluate();
 155     INT32               GetNumber() const  { return lId;          }
 156     ByteString  GetMacro();
 157 };
 158
 159 DECLARE_LIST( RscSubDefList, RscDefine * )
 160
 161 class RscDefineList : public RscSubDefList {
 162 friend class RscFile;
 163 friend class RscFileTab;
 164 private:
 165                 // pExpression wird auf jedenfall Eigentum der Liste
 166     RscDefine * New( ULONG lFileKey, const ByteString & rDefName,
 167                      INT32 lDefId, ULONG lPos );
 168     RscDefine * New( ULONG lFileKey, const ByteString & rDefName,
 169                      RscExpression * pExpression, ULONG lPos );
 170     BOOL                Befor( const RscDefine * pFree, const RscDefine * pDepend );
 171     BOOL                Remove( RscDefine * pDef );
 172     BOOL                Remove( ULONG nIndex );
 173     BOOL                Remove();
 174 public:
 175     void                WriteAll( FILE * fOutput );
 176 };
 177
 178 /*********** R s c E x p r e s s i o n ***********************************/
 179 class RscExpression {
 180 friend class RscFileTab;
 181     char                cOperation;
 182     RscExpType  aLeftExp;
 183     RscExpType  aRightExp;
 184 public:
 185                 RscExpression( RscExpType aLE, char cOp,
 186                                RscExpType aRE );
 187                 ~RscExpression();
 188     BOOL                Evaluate( INT32 * pValue );
 189     ByteString  GetMacro();
 190 };
 191
 192 /********************** R S C F I L E ************************************/
 193 class RscDepend {
 194     ULONG                        lKey;
 195 public:
 196             RscDepend( ULONG lIncKey ){ lKey = lIncKey; };
 197     ULONG       GetFileKey(){ return lKey; }
 198 };
 199 DECLARE_LIST( RscDependList, RscDepend * )
 200
 201 // Tabelle die alle Dateinamen enthaelt
 202 class RscFile : public RscDependList
 203 {
 204 friend class RscFileTab;
 205     BOOL                        bIncFile;       // Ist es eine Include-Datei
 206 public:
 207     BOOL                        bLoaded;        // Ist die Datei geladen
 208     BOOL                        bScanned;       // Wurde Datei nach Inclide abgesucht
 209     BOOL                        bDirty;         // Dirty-Flag
 210     ByteString          aFileName;      // Name der Datei
 211     ByteString          aPathName;      // Pfad und Name der Datei
 212     RscDefineList       aDefLst;        // Liste der Defines
 213
 214                     RscFile();
 215                     ~RscFile();
 216     BOOL                        InsertDependFile( ULONG lDepFile, ULONG lPos );
 217     void                        RemoveDependFile( ULONG lDepFile );
 218     BOOL                        Depend( ULONG lDepend, ULONG lFree );
 219     void                        SetIncFlag(){ bIncFile = TRUE; };
 220     BOOL                        IsIncFile(){  return bIncFile; };
 221 };
 222
 223 DECLARE_UNIQUEINDEX( RscSubFileTab, RscFile * )
 224 #define NOFILE_INDEX UNIQUEINDEX_ENTRY_NOTFOUND
 225
 226 class RscDefTree {
 227     RscDefine * pDefRoot;
 228 public:
 229     static BOOL Evaluate( RscDefine * pDef );
 230                 RscDefTree(){ pDefRoot = NULL; }
 231                 ~RscDefTree();
 232     void                Remove();
 233     BOOL                Evaluate();
 234     RscDefine * Search( const char * pName );
 235     void                Insert( RscDefine * pDef );
 236     void                Remove( RscDefine * pDef );
 237 };
 238
 239 class RscFileTab : public RscSubFileTab {
 240     RscDefTree aDefTree;
 241     ULONG               Find( const ByteString & rName );
 242 public:
 243                 RscFileTab();
 244                 ~RscFileTab();
 245
 246     RscDefine * FindDef( const char * );
 247     RscDefine * FindDef( const ByteString& rStr ) { return FindDef( rStr.GetBuffer() ); }
 248     RscDefine * FindDef( ULONG lKey, const ByteString & );
 249
 250     BOOL                Depend( ULONG lDepend, ULONG lFree );
 251     BOOL                TestDef( ULONG lFileKey, ULONG lPos,
 252                          const RscDefine * pDefDec );
 253     BOOL                TestDef( ULONG lFileKey, ULONG lPos,
 254                          const RscExpression * pExpDec );
 255
 256     RscDefine * NewDef( ULONG lKey, const ByteString & rDefName,
 257                         INT32 lId, ULONG lPos );
 258     RscDefine * NewDef( ULONG lKey, const ByteString & rDefName,
 259                         RscExpression *, ULONG lPos );
 260
 261     BOOL                ChangeDef( const ByteString & rDefName, INT32 lId );
 262     BOOL                ChangeDef( const ByteString & rDefName, RscExpression * );
 263
 264     BOOL IsDefUsed( const ByteString & );
 265     void DeleteDef( const ByteString & );
 266     BOOL ChangeDefName( const ByteString & rDefName,
 267                         const ByteString & rNewName );
 268
 269            // Alle Defines die in dieser Datei Definiert sind loeschen
 270     void   DeleteFileContext( ULONG lKey );
 271     void   DeleteFile( ULONG lKey );
 272     ULONG  NewCodeFile( const ByteString & rName );
 273     ULONG  NewIncFile( const ByteString & rName, const ByteString & rPath );
 274     RscFile * GetFile( ULONG lFileKey ){ return Get( lFileKey ); }
 275 };
 276
 277 #endif // _RSCDEF_HXX