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