basic/source/comp/buffer.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 <osl/thread.h>
  21 #include "buffer.hxx"
  22 #include "parser.hxx"
  23
  24 const static sal_uInt32 UP_LIMIT=0xFFFFFF00L;
  25
  26 // The SbiBuffer will be expanded in increments of at least 16 Bytes.
  27 // This is necessary, because many classes emanate from a buffer length
  28 // of x*16 Bytes.
  29
  30 SbiBuffer::SbiBuffer( SbiParser* p, short n )
  31 {
  32     pParser = p;
  33     n = ( (n + 15 ) / 16 ) * 16;
  34     if( !n ) n = 16;
  35     pBuf  = NULL;
  36     pCur  = NULL;
  37     nInc  = n;
  38     nSize =
  39     nOff  = 0;
  40 }
  41
  42 SbiBuffer::~SbiBuffer()
  43 {
  44     delete[] pBuf;
  45 }
  46
  47 // Reach out the buffer
  48 // This lead to the deletion of the buffer!
  49
  50 char* SbiBuffer::GetBuffer()
  51 {
  52     char* p = pBuf;
  53     pBuf = NULL;
  54     pCur = NULL;
  55     return p;
  56 }
  57
  58 // Test, if the buffer can contain n Bytes.
  59 // In case of doubt it will be enlarged
  60
  61 bool SbiBuffer::Check( sal_Int32 n )
  62 {
  63     if( !n )
  64     {
  65         return true;
  66     }
  67     if( nOff + n  >  nSize )
  68     {
  69         if( nInc == 0 )
  70         {
  71             return false;
  72         }
  73
  74         sal_Int32 nn = 0;
  75         while( nn < n )
  76         {
  77             nn = nn + nInc;
  78         }
  79         char* p;
  80         if( ( nSize + nn ) > UP_LIMIT )
  81         {
  82             p = NULL;
  83         }
  84         else
  85         {
  86             p = new char [nSize + nn];
  87         }
  88         if( !p )
  89         {
  90             pParser->Error( SbERR_PROG_TOO_LARGE );
  91             nInc = 0;
  92             delete[] pBuf; pBuf = NULL;
  93             return false;
  94         }
  95         else
  96         {
  97             if( nSize ) memcpy( p, pBuf, nSize );
  98             delete[] pBuf;
  99             pBuf = p;
 100             pCur = pBuf + nOff;
 101             nSize = nSize + nn;
 102         }
 103     }
 104     return true;
 105 }
 106
 107 // Patch of a Location
 108
 109 void SbiBuffer::Patch( sal_uInt32 off, sal_uInt32 val )
 110 {
 111     if( ( off + sizeof( sal_uInt32 ) ) < nOff )
 112     {
 113         sal_uInt16 val1 = static_cast<sal_uInt16>( val & 0xFFFF );
 114         sal_uInt16 val2 = static_cast<sal_uInt16>( val >> 16 );
 115         sal_uInt8* p = reinterpret_cast<sal_uInt8*>(pBuf) + off;
 116         *p++ = (char) ( val1 & 0xFF );
 117         *p++ = (char) ( val1 >> 8 );
 118         *p++ = (char) ( val2 & 0xFF );
 119         *p   = (char) ( val2 >> 8 );
 120     }
 121 }
 122
 123 // Forward References upon label und procedures
 124 // establish a linkage. The beginning of the linkage is at the passed parameter,
 125 // the end of the linkage is 0.
 126
 127 void SbiBuffer::Chain( sal_uInt32 off )
 128 {
 129     if( off && pBuf )
 130     {
 131         sal_uInt8 *ip;
 132         sal_uInt32 i = off;
 133         sal_uInt32 val1 = (nOff & 0xFFFF);
 134         sal_uInt32 val2 = (nOff >> 16);
 135         do
 136         {
 137             ip = reinterpret_cast<sal_uInt8*>(pBuf) + i;
 138             sal_uInt8* pTmp = ip;
 139                      i =  *pTmp++; i |= *pTmp++ << 8; i |= *pTmp++ << 16; i |= *pTmp++ << 24;
 140
 141             if( i >= nOff )
 142             {
 143                 pParser->Error( SbERR_INTERNAL_ERROR, "BACKCHAIN" );
 144                 break;
 145             }
 146             *ip++ = (char) ( val1 & 0xFF );
 147             *ip++ = (char) ( val1 >> 8 );
 148             *ip++ = (char) ( val2 & 0xFF );
 149             *ip   = (char) ( val2 >> 8 );
 150         } while( i );
 151     }
 152 }
 153
 154 bool SbiBuffer::operator +=( sal_Int8 n )
 155 {
 156     if( Check( 1 ) )
 157     {
 158         *pCur++ = (char) n;
 159         nOff += 1;
 160         return true;
 161     }
 162     else
 163     {
 164         return false;
 165     }
 166 }
 167
 168 bool SbiBuffer::operator +=( sal_uInt8 n )
 169 {
 170     if( Check( 1 ) )
 171     {
 172         *pCur++ = (char) n;
 173         nOff += 1;
 174         return true;
 175     }
 176     else
 177     {
 178         return false;
 179     }
 180 }
 181
 182 bool SbiBuffer::operator +=( sal_Int16 n )
 183 {
 184     if( Check( 2 ) )
 185     {
 186         *pCur++ = (char) ( n & 0xFF );
 187         *pCur++ = (char) ( n >> 8 );
 188         nOff += 2;
 189         return true;
 190     }
 191     else
 192     {
 193         return false;
 194     }
 195 }
 196
 197 bool SbiBuffer::operator +=( sal_uInt16 n )
 198 {
 199     if( Check( 2 ) )
 200     {
 201         *pCur++ = (char) ( n & 0xFF );
 202         *pCur++ = (char) ( n >> 8 );
 203         nOff += 2;
 204         return true;
 205     }
 206     else
 207     {
 208         return false;
 209     }
 210 }
 211
 212 bool SbiBuffer::operator +=( sal_uInt32 n )
 213 {
 214     if( Check( 4 ) )
 215     {
 216         sal_uInt16 n1 = static_cast<sal_uInt16>( n & 0xFFFF );
 217         sal_uInt16 n2 = static_cast<sal_uInt16>( n >> 16 );
 218         operator +=(n1) && operator +=(n2);
 219         return true;
 220     }
 221     else
 222     {
 223         return false;
 224     }
 225 }
 226
 227 bool SbiBuffer::operator +=( sal_Int32 n )
 228 {
 229     return operator +=( (sal_uInt32) n );
 230 }
 231
 232
 233 bool SbiBuffer::operator +=( const OUString& n )
 234 {
 235     sal_uInt32 len = n.getLength() + 1;
 236     if( Check( len ) )
 237     {
 238         OString aByteStr(OUStringToOString(n, osl_getThreadTextEncoding()));
 239         memcpy( pCur, aByteStr.getStr(), len );
 240         pCur += len;
 241         nOff += len;
 242         return true;
 243     }
 244     else
 245     {
 246         return false;
 247     }
 248 }
 249
 250 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */