rsc/source/parser/rsckey.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <ctype.h>
  23 #include <string.h>
  24 #include <rscall.h>
  25 #include <rsctools.hxx>
  26 #include <rschash.hxx>
  27 #include <rsckey.hxx>
  28
  29 #ifdef _MSC_VER
  30 #define _cdecl __cdecl
  31 #endif
  32
  33 extern "C" {
  34     int SAL_CALL KeyCompare( const void * pFirst, const void * pSecond );
  35 }
  36
  37 int SAL_CALL KeyCompare( const void * pFirst, const void * pSecond )
  38 {
  39     if( static_cast<KEY_STRUCT const *>(pFirst)->nName > static_cast<KEY_STRUCT const *>(pSecond)->nName )
  40         return 1;
  41     else if( static_cast<KEY_STRUCT const *>(pFirst)->nName < static_cast<KEY_STRUCT const *>(pSecond)->nName )
  42         return -1;
  43     else
  44         return 0;
  45 }
  46
  47 RscNameTable::RscNameTable()
  48 {
  49     bSort    = true;
  50     nEntries = 0;
  51     pTable   = NULL;
  52 };
  53
  54 RscNameTable::~RscNameTable()
  55 {
  56     if( pTable )
  57         rtl_freeMemory( pTable );
  58 };
  59
  60
  61 void RscNameTable::SetSort( bool bSorted )
  62 {
  63     bSort = bSorted;
  64     if( bSort && pTable)
  65     {
  66         // Schluesselwort Feld sortieren
  67         qsort( (void *)pTable, nEntries,
  68                sizeof( KEY_STRUCT ), KeyCompare );
  69     }
  70 };
  71
  72 Atom RscNameTable::Put( Atom nName, sal_uInt32 nTyp, sal_IntPtr nValue )
  73 {
  74     if( pTable )
  75         pTable = static_cast<KEY_STRUCT *>(
  76                  rtl_reallocateMemory( (void *)pTable,
  77                  ((nEntries +1) * sizeof( KEY_STRUCT )) ));
  78     else
  79         pTable = static_cast<KEY_STRUCT *>(
  80                  rtl_allocateMemory( ((nEntries +1)
  81                                  * sizeof( KEY_STRUCT )) ));
  82
  83     pTable[ nEntries ].nName  = nName;
  84     pTable[ nEntries ].nTyp   = nTyp;
  85     pTable[ nEntries ].yylval = nValue;
  86     nEntries++;
  87     if( bSort )
  88         SetSort();
  89
  90     return nName;
  91 };
  92
  93 Atom RscNameTable::Put( const char * pName, sal_uInt32 nTyp, sal_IntPtr nValue )
  94 {
  95     return Put( pHS->getID( pName ), nTyp, nValue );
  96 };
  97
  98 Atom RscNameTable::Put( const char * pName, sal_uInt32 nTyp )
  99 {
 100     Atom  nId;
 101
 102     nId = pHS->getID( pName );
 103     return Put( nId, nTyp, (sal_IntPtr)nId );
 104 };
 105
 106 Atom RscNameTable::Put( Atom nName, sal_uInt32 nTyp, RscTop * pClass )
 107 {
 108     return Put( nName, nTyp, reinterpret_cast<sal_IntPtr>(pClass) );
 109 };
 110
 111 bool RscNameTable::Get( Atom nName, KEY_STRUCT * pEle )
 112 {
 113     KEY_STRUCT * pKey = NULL;
 114     KEY_STRUCT  aSearchName;
 115     sal_uInt32  i;
 116
 117     if( bSort )
 118     {
 119         // Suche nach dem Schluesselwort
 120         aSearchName.nName = nName;
 121         pKey = static_cast<KEY_STRUCT *>(bsearch(
 122                 &aSearchName, pTable,
 123                 nEntries, sizeof( KEY_STRUCT ), KeyCompare ));
 124     }
 125     else
 126     {
 127         i = 0;
 128         while( i < nEntries && !pKey )
 129         {
 130             if( pTable[ i ].nName == nName )
 131                 pKey = &pTable[ i ];
 132             i++;
 133         }
 134     }
 135
 136     if( pKey )
 137     {
 138         // Schluesselwort gefunden
 139         *pEle = *pKey;
 140         return true;
 141     }
 142     return false;
 143 };
 144
 145 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */