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 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     pCur  = nullptr;
  37     nInc  = n;
  38     nSize =
  39     nOff  = 0;
  40 }
  41
  42 SbiBuffer::~SbiBuffer()
  43 {
  44 }
  45
  46 // Reach out the buffer
  47 // This lead to the deletion of the buffer!
  48
  49 char* SbiBuffer::GetBuffer()
  50 {
  51     char* p = pBuf.release();
  52     pCur = nullptr;
  53     return p;
  54 }
  55
  56 // Test, if the buffer can contain n Bytes.
  57 // In case of doubt it will be enlarged
  58
  59 bool SbiBuffer::Check( sal_Int32 n )
  60 {
  61     if( !n )
  62     {
  63         return true;
  64     }
  65     if( nOff + n  >  nSize )
  66     {
  67         if( nInc == 0 )
  68         {
  69             return false;
  70         }
  71
  72         sal_Int32 nn = 0;
  73         while( nn < n )
  74         {
  75             nn = nn + nInc;
  76         }
  77         char* p;
  78         if( ( nSize + nn ) > UP_LIMIT )
  79         {
  80             p = nullptr;
  81         }
  82         else
  83         {
  84             p = new char [nSize + nn];
  85         }
  86         if( !p )
  87         {
  88             pParser->Error( ERRCODE_BASIC_PROG_TOO_LARGE );
  89             nInc = 0;
  90             pBuf.reset();
  91             return false;
  92         }
  93         else
  94         {
  95             if( nSize ) memcpy( p, pBuf.get(), nSize );
  96             pBuf.reset(p);
  97             pCur = pBuf.get() + nOff;
  98             nSize = nSize + nn;
  99         }
 100     }
 101     return true;
 102 }
 103
 104 // Patch of a Location
 105
 106 void SbiBuffer::Patch( sal_uInt32 off, sal_uInt32 val )
 107 {
 108     if( ( off + sizeof( sal_uInt32 ) ) < nOff )
 109     {
 110         sal_uInt16 val1 = static_cast<sal_uInt16>( val & 0xFFFF );
 111         sal_uInt16 val2 = static_cast<sal_uInt16>( val >> 16 );
 112         sal_uInt8* p = reinterpret_cast<sal_uInt8*>(pBuf.get()) + off;
 113         *p++ = static_cast<char>( val1 & 0xFF );
 114         *p++ = static_cast<char>( val1 >> 8 );
 115         *p++ = static_cast<char>( val2 & 0xFF );
 116         *p   = static_cast<char>( val2 >> 8 );
 117     }
 118 }
 119
 120 // Forward References upon label and procedures
 121 // establish a linkage. The beginning of the linkage is at the passed parameter,
 122 // the end of the linkage is 0.
 123
 124 void SbiBuffer::Chain( sal_uInt32 off )
 125 {
 126     if( !(off && pBuf) )
 127         return;
 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 void SbiBuffer::operator +=( sal_Int8 n )
 152 {
 153     if( Check( 1 ) )
 154     {
 155         *pCur++ = static_cast<char>(n);
 156         nOff += 1;
 157     }
 158 }
 159
 160 bool SbiBuffer::operator +=( sal_uInt8 n )
 161 {
 162     if( Check( 1 ) )
 163     {
 164         *pCur++ = static_cast<char>(n);
 165         nOff += 1;
 166         return true;
 167     }
 168     else
 169     {
 170         return false;
 171     }
 172 }
 173
 174 void SbiBuffer::operator +=( sal_Int16 n )
 175 {
 176     if( Check( 2 ) )
 177     {
 178         *pCur++ = static_cast<char>( n & 0xFF );
 179         *pCur++ = static_cast<char>( n >> 8 );
 180         nOff += 2;
 181     }
 182 }
 183
 184 bool SbiBuffer::operator +=( sal_uInt16 n )
 185 {
 186     if( Check( 2 ) )
 187     {
 188         *pCur++ = static_cast<char>( n & 0xFF );
 189         *pCur++ = static_cast<char>( n >> 8 );
 190         nOff += 2;
 191         return true;
 192     }
 193     else
 194     {
 195         return false;
 196     }
 197 }
 198
 199 bool SbiBuffer::operator +=( sal_uInt32 n )
 200 {
 201     if( Check( 4 ) )
 202     {
 203         sal_uInt16 n1 = static_cast<sal_uInt16>( n & 0xFFFF );
 204         sal_uInt16 n2 = static_cast<sal_uInt16>( n >> 16 );
 205         operator +=(n1) && operator +=(n2);
 206         return true;
 207     }
 208     else
 209     {
 210         return false;
 211     }
 212 }
 213
 214 void SbiBuffer::operator +=( sal_Int32 n )
 215 {
 216     operator +=( static_cast<sal_uInt32>(n) );
 217 }
 218
 219
 220 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */