/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx
Warning:	line 2541, column 16 Assigned value is garbage or undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DTable.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/connectivity/inc -I /home/maarten/src/libreoffice/core/connectivity/source/inc -I /home/maarten/src/libreoffice/core/workdir/YaccTarget/connectivity/source/parse -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#include <dbase/DTable.hxx>
21#include <com/sun/star/container/ElementExistException.hpp>
22#include <com/sun/star/sdbc/ColumnValue.hpp>
23#include <com/sun/star/sdbc/DataType.hpp>
24#include <com/sun/star/ucb/XContentAccess.hpp>
25#include <com/sun/star/sdbc/XRow.hpp>
26#include <o3tl/safeint.hxx>
27#include <svl/converter.hxx>
28#include <dbase/DConnection.hxx>
29#include <dbase/DColumns.hxx>
30#include <tools/config.hxx>
31#include <tools/diagnose_ex.h>
32#include <dbase/DIndex.hxx>
33#include <dbase/DIndexes.hxx>
34#include <comphelper/processfactory.hxx>
35#include <rtl/math.hxx>
36#include <ucbhelper/content.hxx>
37#include <com/sun/star/ucb/ContentCreationException.hpp>
38#include <connectivity/dbexception.hxx>
39#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
40#include <comphelper/property.hxx>
41#include <comphelper/servicehelper.hxx>
42#include <comphelper/string.hxx>
43#include <unotools/tempfile.hxx>
44#include <unotools/ucbhelper.hxx>
45#include <comphelper/types.hxx>
46#include <cppuhelper/typeprovider.hxx>
47#include <cppuhelper/exc_hlp.hxx>
48#include <cppuhelper/queryinterface.hxx>
49#include <connectivity/dbtools.hxx>
50#include <connectivity/FValue.hxx>
51#include <connectivity/dbconversion.hxx>
52#include <connectivity/sdbcx/VColumn.hxx>
53#include <strings.hrc>
54#include <rtl/strbuf.hxx>
55#include <sal/log.hxx>
56#include <tools/date.hxx>

58#include <algorithm>
59#include <cassert>
60#include <memory>

62using namespace ::comphelper;
63using namespace connectivity;
64using namespace connectivity::sdbcx;
65using namespace connectivity::dbase;
66using namespace connectivity::file;
67using namespace ::ucbhelper;
68using namespace ::utl;
69using namespace ::cppu;
70using namespace ::dbtools;
71using namespace ::com::sun::star::uno;
72using namespace ::com::sun::star::ucb;
73using namespace ::com::sun::star::beans;
74using namespace ::com::sun::star::sdbcx;
75using namespace ::com::sun::star::sdbc;
76using namespace ::com::sun::star::container;
77using namespace ::com::sun::star::lang;
78using namespace ::com::sun::star::i18n;

80// stored as the Field Descriptor terminator
81#define FIELD_DESCRIPTOR_TERMINATOR0x0D 0x0D
82#define DBF_EOL0x1A                     0x1A

84namespace
85{
86std::size_t lcl_getFileSize(SvStream& _rStream)
87{
  std::size_t nFileSize = 0;
  _rStream.Seek(STREAM_SEEK_TO_END((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));
  _rStream.SeekRel(-1);
  char cEOL;
  _rStream.ReadChar( cEOL );
  nFileSize = _rStream.Tell();
  if ( cEOL == DBF_EOL0x1A )
      nFileSize -= 1;
  return nFileSize;
97}
98/**
  calculates the Julian date
100*/
101void lcl_CalcJulDate(sal_Int32& _nJulianDate,sal_Int32& _nJulianTime, const css::util::DateTime& rDateTime)
102{
  css::util::DateTime aDateTime = rDateTime;
  // weird: months fix
  if (aDateTime.Month > 12)
  {
      aDateTime.Month--;
      sal_uInt16 delta = rDateTime.Month / 12;
      aDateTime.Year += delta;
      aDateTime.Month -= delta * 12;
      aDateTime.Month++;
  }

  _nJulianTime = ((aDateTime.Hours*3600000)+(aDateTime.Minutes*60000)+(aDateTime.Seconds*1000)+(aDateTime.NanoSeconds/1000000));
  /* conversion factors */
  sal_uInt16 iy0;
  sal_uInt16 im0;
  if ( aDateTime.Month <= 2 )
  {
      iy0 = aDateTime.Year - 1;
      im0 = aDateTime.Month + 12;
  }
  else
  {
      iy0 = aDateTime.Year;
      im0 = aDateTime.Month;
  }
  sal_Int32 ia = iy0 / 100;
  sal_Int32 ib = 2 - ia + (ia >> 2);
  /* calculate julian date    */
  if ( aDateTime.Year <= 0 )
  {
      _nJulianDate = static_cast<sal_Int32>((365.25 * iy0) - 0.75)
          + static_cast<sal_Int32>(30.6001 * (im0 + 1) )
          + aDateTime.Day + 1720994;
  } // if ( rDateTime.Year <= 0 )
  else
  {
      _nJulianDate = static_cast<sal_Int32>(365.25 * iy0)
          + static_cast<sal_Int32>(30.6001 * (im0 + 1))
          + aDateTime.Day + 1720994;
  }
  double JD = _nJulianDate + 0.5;
  _nJulianDate = static_cast<sal_Int32>( JD + 0.5);
  const double gyr = aDateTime.Year + (0.01 * aDateTime.Month) + (0.0001 * aDateTime.Day);
  if ( gyr >= 1582.1015 ) /* on or after 15 October 1582  */
      _nJulianDate += ib;
148}

150/**
  calculates date time from the Julian Date
152*/
153void lcl_CalDate(sal_Int32 _nJulianDate,sal_Int32 _nJulianTime,css::util::DateTime& _rDateTime)
154{
  if ( _nJulianDate )
  {
      sal_Int32 ka = _nJulianDate;
      if ( _nJulianDate >= 2299161 )
      {
          sal_Int32 ialp = static_cast<sal_Int32>( (static_cast<double>(_nJulianDate) - 1867216.25 ) / 36524.25 );
          ka = _nJulianDate + 1 + ialp - ( ialp >> 2 );
      }
      sal_Int32 kb = ka + 1524;
      sal_Int32 kc =  static_cast<sal_Int32>( (static_cast<double>(kb) - 122.1 ) / 365.25 );
      sal_Int32 kd = static_cast<sal_Int32>(static_cast<double>(kc) * 365.25);
      sal_Int32 ke = static_cast<sal_Int32>(static_cast<double>( kb - kd ) / 30.6001 );
      _rDateTime.Day = static_cast<sal_uInt16>(kb - kd - static_cast<sal_Int32>( static_cast<double>(ke) * 30.6001 ));
      if ( ke > 13 )
          _rDateTime.Month = static_cast<sal_uInt16>(ke - 13);
      else
          _rDateTime.Month = static_cast<sal_uInt16>(ke - 1);
      if ( (_rDateTime.Month == 2) && (_rDateTime.Day > 28) )
          _rDateTime.Day = 29;
      if ( (_rDateTime.Month == 2) && (_rDateTime.Day == 29) && (ke == 3) )
          _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
      else if ( _rDateTime.Month > 2 )
          _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
      else
          _rDateTime.Year = static_cast<sal_uInt16>(kc - 4715);
  }

  if ( _nJulianTime )
  {
      double d_s = _nJulianTime / 1000.0;
      double d_m = d_s / 60.0;
      double d_h  = d_m / 60.0;
      _rDateTime.Hours = static_cast<sal_uInt16>(d_h);
      _rDateTime.Minutes = static_cast<sal_uInt16>((d_h - static_cast<double>(_rDateTime.Hours)) * 60.0);
      _rDateTime.Seconds = static_cast<sal_uInt16>(((d_m - static_cast<double>(_rDateTime.Minutes)) * 60.0)
              - (static_cast<double>(_rDateTime.Hours) * 3600.0));
  }
192}

194}


197void ODbaseTable::readHeader()
198{
  OSL_ENSURE(m_pFileStream,"No Stream available!")do { if (true && (!(m_pFileStream))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "199" ": "), "%s", "No Stream available!"); } } while (false
);
  if(!m_pFileStream)
      return;
  m_pFileStream->RefreshBuffer(); // Make sure, that the header information actually is read again
  m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN0L);

  sal_uInt8 nType=0;
  m_pFileStream->ReadUChar( nType );
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();

  m_pFileStream->ReadBytes(m_aHeader.dateElems, 3);
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();

  m_pFileStream->ReadUInt32( m_aHeader.nbRecords);
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();

  m_pFileStream->ReadUInt16( m_aHeader.headerLength);
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();

  m_pFileStream->ReadUInt16( m_aHeader.recordLength);
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();
  if (m_aHeader.recordLength == 0)
      throwInvalidDbaseFormat();

  m_pFileStream->ReadBytes(m_aHeader.trailer, 20);
  if(ERRCODE_NONEErrCode(0) != m_pFileStream->GetErrorCode())
      throwInvalidDbaseFormat();


  if ( ( ( m_aHeader.headerLength - 1 ) / 32 - 1 ) <= 0 ) // number of fields
  {
      // no dBASE file
      throwInvalidDbaseFormat();
  }
  else
  {
      // Consistency check of the header:
      m_aHeader.type = static_cast<DBFType>(nType);
      switch (m_aHeader.type)
      {
          case dBaseIII:
          case dBaseIV:
          case dBaseV:
          case VisualFoxPro:
          case VisualFoxProAuto:
          case dBaseFS:
          case dBaseFSMemo:
          case dBaseIVMemoSQL:
          case dBaseIIIMemo:
          case FoxProMemo:
              m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
              if( getConnection()->isTextEncodingDefaulted() &&
                 !dbfDecodeCharset(m_eEncoding, nType, m_aHeader.trailer[17]))
              {
                  m_eEncoding = RTL_TEXTENCODING_IBM_850(((rtl_TextEncoding) 4));
              }
              break;
          case dBaseIVMemo:
              m_pFileStream->SetEndian(SvStreamEndian::LITTLE);
              break;
          default:
          {
              throwInvalidDbaseFormat();
          }
      }
  }
270}

272void ODbaseTable::fillColumns()
273{
  m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN0L);
  m_pFileStream->Seek(32);

  if(!m_aColumns.is())
      m_aColumns = new OSQLColumns();
  else
      m_aColumns->clear();

  m_aTypes.clear();
  m_aPrecisions.clear();
  m_aScales.clear();

  // Number of fields:
  const sal_Int32 nFieldCount = (m_aHeader.headerLength - 1) / 32 - 1;
  OSL_ENSURE(nFieldCount,"No columns in table!")do { if (true && (!(nFieldCount))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "288" ": "), "%s", "No columns in table!"); } } while (false
);

  m_aColumns->reserve(nFieldCount);
  m_aTypes.reserve(nFieldCount);
  m_aPrecisions.reserve(nFieldCount);
  m_aScales.reserve(nFieldCount);

  OUString aTypeName;
  const bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
  const bool bFoxPro = m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto || m_aHeader.type == FoxProMemo;

  sal_Int32 i = 0;
  for (; i < nFieldCount; i++)
  {
      DBFColumn aDBFColumn;
303#if !defined(NDEBUG)
      sal_uInt64 const nOldPos(m_pFileStream->Tell());
305#endif
      m_pFileStream->ReadBytes(aDBFColumn.db_fnm, 11);
      m_pFileStream->ReadUChar(aDBFColumn.db_typ);
      m_pFileStream->ReadUInt32(aDBFColumn.db_adr);
      m_pFileStream->ReadUChar(aDBFColumn.db_flng);
      m_pFileStream->ReadUChar(aDBFColumn.db_dez);
      m_pFileStream->ReadBytes(aDBFColumn.db_free2, 14);
      assert(m_pFileStream->GetError() || m_pFileStream->Tell() == nOldPos + sizeof(aDBFColumn))(static_cast <bool> (m_pFileStream->GetError() || m_pFileStream
->Tell() == nOldPos + sizeof(aDBFColumn)) ? void (0) : __assert_fail
 ("m_pFileStream->GetError() || m_pFileStream->Tell() == nOldPos + sizeof(aDBFColumn)"
, "/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
, 312, __extension__ __PRETTY_FUNCTION__));
      if (m_pFileStream->GetError())
      {
          SAL_WARN("connectivity.drivers", "ODbaseTable::fillColumns: short read!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "ODbaseTable::fillColumns: short read!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "315" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODbaseTable::fillColumns: short read!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::fillColumns: short read!"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "315" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ODbaseTable::fillColumns: short read!") == 1) { ::
sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "315" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODbaseTable::fillColumns: short read!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::fillColumns: short read!"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "315" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          break;
      }
      if ( FIELD_DESCRIPTOR_TERMINATOR0x0D == aDBFColumn.db_fnm[0] ) // 0x0D stored as the Field Descriptor terminator.
          break;

      aDBFColumn.db_fnm[sizeof(aDBFColumn.db_fnm)-1] = 0; //ensure null termination for broken input
      const OUString aColumnName(reinterpret_cast<char *>(aDBFColumn.db_fnm), strlen(reinterpret_cast<char *>(aDBFColumn.db_fnm)), m_eEncoding);

      bool bIsRowVersion = bFoxPro && ( aDBFColumn.db_free2[0] & 0x01 ) == 0x01;

      m_aRealFieldLengths.push_back(aDBFColumn.db_flng);
      sal_Int32 nPrecision = aDBFColumn.db_flng;
      sal_Int32 eType;
      bool bIsCurrency = false;

      char cType[2];
      cType[0] = aDBFColumn.db_typ;
      cType[1] = 0;
      aTypeName = OUString(cType, 1, RTL_TEXTENCODING_ASCII_US(((rtl_TextEncoding) 11)));
      SAL_INFO( "connectivity.drivers","column type: " << aDBFColumn.db_typ)do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "column type: "
 << aDBFColumn.db_typ) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "335" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "column type: " << aDBFColumn.db_typ
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "column type: " << aDBFColumn.db_typ; ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "335" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "column type: " << aDBFColumn.db_typ) == 1)
 { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "335" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "column type: " << aDBFColumn.db_typ
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "column type: " << aDBFColumn.db_typ; ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "335" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

      switch (aDBFColumn.db_typ)
      {
      case 'C':
          eType = DataType::VARCHAR;
          aTypeName = "VARCHAR";
          break;
      case 'F':
      case 'N':
          aTypeName = "DECIMAL";
          if ( aDBFColumn.db_typ == 'N' )
              aTypeName = "NUMERIC";
          eType = DataType::DECIMAL;

          // for numeric fields two characters more are written, then the precision of the column description predescribes,
          // to keep room for the possible sign and the comma. This has to be considered...
          nPrecision = SvDbaseConverter::ConvertPrecisionToOdbc(nPrecision,aDBFColumn.db_dez);
          // This is not true for older versions...
          break;
      case 'L':
          eType = DataType::BIT;
          aTypeName = "BOOLEAN";
          break;
      case 'Y':
          bIsCurrency = true;
          eType = DataType::DOUBLE;
          aTypeName = "DOUBLE";
          break;
      case 'D':
          eType = DataType::DATE;
          aTypeName = "DATE";
          break;
      case 'T':
          eType = DataType::TIMESTAMP;
          aTypeName = "TIMESTAMP";
          break;
      case 'I':
          eType = DataType::INTEGER;
          aTypeName = "INTEGER";
          break;
      case 'M':
          if ( bFoxPro && ( aDBFColumn.db_free2[0] & 0x04 ) == 0x04 )
          {
              eType = DataType::LONGVARBINARY;
              aTypeName = "LONGVARBINARY";
          }
          else
          {
              aTypeName = "LONGVARCHAR";
              eType = DataType::LONGVARCHAR;
          }
          nPrecision = 2147483647;
          break;
      case 'P':
          aTypeName = "LONGVARBINARY";
          eType = DataType::LONGVARBINARY;
          nPrecision = 2147483647;
          break;
      case '0':
      case 'B':
          if ( m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto )
          {
              aTypeName = "DOUBLE";
              eType = DataType::DOUBLE;
          }
          else
          {
              aTypeName = "LONGVARBINARY";
              eType = DataType::LONGVARBINARY;
              nPrecision = 2147483647;
          }
          break;
      default:
          eType = DataType::OTHER;
      }

      m_aTypes.push_back(eType);
      m_aPrecisions.push_back(nPrecision);
      m_aScales.push_back(aDBFColumn.db_dez);

      Reference< XPropertySet> xCol = new sdbcx::OColumn(aColumnName,
                                                  aTypeName,
                                                  OUString(),
                                                  OUString(),
                                                  ColumnValue::NULLABLE,
                                                  nPrecision,
                                                  aDBFColumn.db_dez,
                                                  eType,
                                                  false,
                                                  bIsRowVersion,
                                                  bIsCurrency,
                                                  bCase,
                                                  m_CatalogName, getSchema(), getName());
      m_aColumns->push_back(xCol);
  } // for (; i < nFieldCount; i++)
  OSL_ENSURE(i,"No columns in table!")do { if (true && (!(i))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "431" ": "), "%s", "No columns in table!"); } } while (false
);
432}

434ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables, ODbaseConnection* _pConnection)
  : ODbaseTable_BASE(_pTables,_pConnection)
436{
  // initialize the header
  m_aHeader.type = dBaseIII;
  m_eEncoding = getConnection()->getTextEncoding();
440}

442ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables, ODbaseConnection* _pConnection,
                       const OUString& Name,
                       const OUString& Type,
                       const OUString& Description ,
                       const OUString& SchemaName,
                       const OUString& CatalogName )
  : ODbaseTable_BASE(_pTables,_pConnection,Name,
                     Type,
                     Description,
                     SchemaName,
                     CatalogName)
453{
  m_eEncoding = getConnection()->getTextEncoding();
455}


458void ODbaseTable::construct()
459{
  // initialize the header
  m_aHeader.type = dBaseIII;
  m_aHeader.nbRecords = 0;
  m_aHeader.headerLength = 0;
  m_aHeader.recordLength = 0;
  m_aMemoHeader.db_size = 0;

  OUString sFileName(getEntry(m_pConnection, m_Name));

  INetURLObject aURL;
  aURL.SetURL(sFileName);

  OSL_ENSURE( m_pConnection->matchesExtension( aURL.getExtension() ),do { if (true && (!(m_pConnection->matchesExtension
( aURL.getExtension() )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "473" ": "), "%s", "ODbaseTable::ODbaseTable: invalid extension!"
); } } while (false)
      "ODbaseTable::ODbaseTable: invalid extension!")do { if (true && (!(m_pConnection->matchesExtension
( aURL.getExtension() )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "473" ": "), "%s", "ODbaseTable::ODbaseTable: invalid extension!"
); } } while (false);
      // getEntry is expected to ensure the correct file name

  m_pFileStream = createStream_simpleError( sFileName, StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
  m_bWriteable = ( m_pFileStream != nullptr );

  if ( !m_pFileStream )
  {
      m_bWriteable = false;
      m_pFileStream = createStream_simpleError( sFileName, StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
  }

  if(!m_pFileStream)
      return;

  readHeader();
  if (HasMemoFields())
  {
  // Create Memo-Filename (.DBT):
  // nyi: Ugly for Unix and Mac!

      if ( m_aHeader.type == FoxProMemo || m_aHeader.type == VisualFoxPro || m_aHeader.type == VisualFoxProAuto) // foxpro uses another extension
          aURL.SetExtension("fpt");
      else
          aURL.SetExtension("dbt");

      // If the memo file isn't found, the data will be displayed anyhow.
      // However, updates can't be done
      // but the operation is executed
      m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READWRITE | StreamMode::NOCREATE | StreamMode::SHARE_DENYWRITE);
      if ( !m_pMemoStream )
      {
          m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ | StreamMode::NOCREATE | StreamMode::SHARE_DENYNONE);
      }
      if (m_pMemoStream)
          ReadMemoHeader();
  }
  fillColumns();

  std::size_t nFileSize = lcl_getFileSize(*m_pFileStream);
  m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN0L);
  // seems to be empty or someone wrote bullshit into the dbase file
  // try and recover if m_aHeader.db_slng is sane
  if (m_aHeader.nbRecords == 0 && m_aHeader.recordLength)
  {
      std::size_t nRecords = (nFileSize-m_aHeader.headerLength)/m_aHeader.recordLength;
      if (nRecords > 0)
          m_aHeader.nbRecords = nRecords;
  }

  // Buffersize dependent on the file size
  m_pFileStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
                            nFileSize > 100000 ? 16384 :
                            nFileSize > 10000 ? 4096 : 1024);

  if (m_pMemoStream)
  {
      // set the buffer exactly to the length of a record
      nFileSize = m_pMemoStream->TellEnd();
      m_pMemoStream->Seek(STREAM_SEEK_TO_BEGIN0L);

      // Buffersize dependent on the file size
      m_pMemoStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
                                    nFileSize > 100000 ? 16384 :
                                    nFileSize > 10000 ? 4096 :
                                    m_aMemoHeader.db_size);
  }

  AllocBuffer();
542}

544void ODbaseTable::ReadMemoHeader()
545{
  m_pMemoStream->SetEndian(SvStreamEndian::LITTLE);
  m_pMemoStream->RefreshBuffer();         // make sure that the header information is actually read again
  m_pMemoStream->Seek(0);

  (*m_pMemoStream).ReadUInt32( m_aMemoHeader.db_next );
  switch (m_aHeader.type)
  {
      case dBaseIIIMemo:  // dBase III: fixed block size
      case dBaseIVMemo:
          // sometimes dBase3 is attached to dBase4 memo
          m_pMemoStream->Seek(20);
          (*m_pMemoStream).ReadUInt16( m_aMemoHeader.db_size );
          if (m_aMemoHeader.db_size > 1 && m_aMemoHeader.db_size != 512)  // 1 is also for dBase 3
              m_aMemoHeader.db_typ  = MemodBaseIV;
          else if (m_aMemoHeader.db_size == 512)
          {
              // There are files using size specification, though they are dBase-files
              char sHeader[4];
              m_pMemoStream->Seek(m_aMemoHeader.db_size);
              m_pMemoStream->ReadBytes(sHeader, 4);

              if ((m_pMemoStream->GetErrorCode() != ERRCODE_NONEErrCode(0)) || static_cast<sal_uInt8>(sHeader[0]) != 0xFF || static_cast<sal_uInt8>(sHeader[1]) != 0xFF || static_cast<sal_uInt8>(sHeader[2]) != 0x08)
                  m_aMemoHeader.db_typ  = MemodBaseIII;
              else
                  m_aMemoHeader.db_typ  = MemodBaseIV;
          }
          else
          {
              m_aMemoHeader.db_typ  = MemodBaseIII;
              m_aMemoHeader.db_size = 512;
          }
          break;
      case VisualFoxPro:
      case VisualFoxProAuto:
      case FoxProMemo:
          m_aMemoHeader.db_typ    = MemoFoxPro;
          m_pMemoStream->Seek(6);
          m_pMemoStream->SetEndian(SvStreamEndian::BIG);
          (*m_pMemoStream).ReadUInt16( m_aMemoHeader.db_size );
          break;
      default:
          SAL_WARN( "connectivity.drivers", "ODbaseTable::ReadMemoHeader: unsupported memo type!" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "587" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "587" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "587" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::ReadMemoHeader: unsupported memo type!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "587" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          break;
  }
590}

592OUString ODbaseTable::getEntry(file::OConnection const * _pConnection,const OUString& _sName )
593{
  OUString sURL;
  try
  {
      Reference< XResultSet > xDir = _pConnection->getDir()->getStaticResultSet();
      Reference< XRow> xRow(xDir,UNO_QUERY);
      OUString sName;
      OUString sExt;
      INetURLObject aURL;
      xDir->beforeFirst();
      while(xDir->next())
      {
          sName = xRow->getString(1);
          aURL.SetSmartProtocol(INetProtocol::File);
          OUString sUrl = _pConnection->getURL() + "/" + sName;
          aURL.SetSmartURL( sUrl );

          // cut the extension
          sExt = aURL.getExtension();

          // name and extension have to coincide
          if ( _pConnection->matchesExtension( sExt ) )
          {
              sName = sName.replaceAt(sName.getLength() - (sExt.getLength() + 1), sExt.getLength() + 1, OUString());
              if ( sName == _sName )
              {
                  Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY );
                  sURL = xContentAccess->queryContentIdentifierString();
                  break;
              }
          }
      }
      xDir->beforeFirst(); // move back to before first record
  }
  catch(const Exception&)
  {
      OSL_ASSERT(false)do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "629" ": "), "OSL_ASSERT: %s", "false"); } } while (false
);
  }
  return sURL;
632}

634void ODbaseTable::refreshColumns()
635{
  ::osl::MutexGuard aGuard( m_aMutex );

  ::std::vector< OUString> aVector;
  aVector.reserve(m_aColumns->size());

  for (auto const& column : *m_aColumns)
      aVector.push_back(Reference< XNamed>(column,UNO_QUERY_THROW)->getName());

  if(m_xColumns)
      m_xColumns->reFill(aVector);
  else
      m_xColumns = new ODbaseColumns(this,m_aMutex,aVector);
648}

650void ODbaseTable::refreshIndexes()
651{
  ::std::vector< OUString> aVector;
  if(m_pFileStream && (!m_xIndexes || m_xIndexes->getCount() == 0))
  {
      INetURLObject aURL;
      aURL.SetURL(getEntry(m_pConnection,m_Name));

      aURL.setExtension("inf");
      Config aInfFile(aURL.getFSysPath(FSysStyle::Detect));
      aInfFile.SetGroup(dBASE_III_GROUP"dBase III");
      sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
      OString aKeyName;

      for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
      {
          // References the key an index-file?
          aKeyName = aInfFile.GetKeyName( nKey );
          //...if yes, add the index list of the table
          if (aKeyName.startsWith("NDX"))
          {
              OString aIndexName = aInfFile.ReadKey(aKeyName);
              aURL.setName(OStringToOUString(aIndexName, m_eEncoding));
              try
              {
                  Content aCnt(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
                  if (aCnt.isDocument())
                  {
                      aVector.push_back(aURL.getBase());
                  }
              }
              catch(const Exception&) // an exception is thrown when no file exists
              {
              }
          }
      }
  }
  if(m_xIndexes)
      m_xIndexes->reFill(aVector);
  else
      m_xIndexes = new ODbaseIndexes(this,m_aMutex,aVector);
691}


694void SAL_CALL ODbaseTable::disposing()
695{
  OFileTable::disposing();
  ::osl::MutexGuard aGuard(m_aMutex);
  m_aColumns = nullptr;
699}

701Sequence< Type > SAL_CALL ODbaseTable::getTypes(  )
702{
  Sequence< Type > aTypes = OTable_TYPEDEF::getTypes();
  std::vector<Type> aOwnTypes;
  aOwnTypes.reserve(aTypes.getLength());

  const Type* pBegin = aTypes.getConstArray();
  const Type* pEnd = pBegin + aTypes.getLength();
  for(;pBegin != pEnd;++pBegin)
  {
      if(*pBegin != cppu::UnoType<XKeysSupplier>::get() &&
         *pBegin != cppu::UnoType<XDataDescriptorFactory>::get())
      {
          aOwnTypes.push_back(*pBegin);
      }
  }
  aOwnTypes.push_back(cppu::UnoType<css::lang::XUnoTunnel>::get());
  return Sequence< Type >(aOwnTypes.data(), aOwnTypes.size());
719}


722Any SAL_CALL ODbaseTable::queryInterface( const Type & rType )
723{
  if( rType == cppu::UnoType<XKeysSupplier>::get()||
      rType == cppu::UnoType<XDataDescriptorFactory>::get())
      return Any();

  Any aRet = OTable_TYPEDEF::queryInterface(rType);
  return aRet.hasValue() ? aRet : ::cppu::queryInterface(rType,static_cast< css::lang::XUnoTunnel*> (this));
730}


733Sequence< sal_Int8 > ODbaseTable::getUnoTunnelId()
734{
  static ::cppu::OImplementationId implId;

  return implId.getImplementationId();
738}

740// css::lang::XUnoTunnel

742sal_Int64 ODbaseTable::getSomething( const Sequence< sal_Int8 > & rId )
743{
  return (isUnoTunnelId<ODbaseTable>(rId))
              ? reinterpret_cast< sal_Int64 >( this )
              : ODbaseTable_BASE::getSomething(rId);
747}

749bool ODbaseTable::fetchRow(OValueRefRow& _rRow, const OSQLColumns & _rCols, bool bRetrieveData)
750{
  if (!m_pBuffer)
      return false;

  // Read the data
  bool bIsCurRecordDeleted = static_cast<char>(m_pBuffer[0]) == '*';

  // only read the bookmark

  // Mark record as deleted
  _rRow->setDeleted(bIsCurRecordDeleted);
  *(*_rRow)[0] = m_nFilePos;

  if (!bRetrieveData)
      return true;

  std::size_t nByteOffset = 1;
  // Fields:
  OSQLColumns::const_iterator aIter = _rCols.begin();
  OSQLColumns::const_iterator aEnd  = _rCols.end();
  const std::size_t nCount = _rRow->size();
  for (std::size_t i = 1; aIter != aEnd && nByteOffset <= m_nBufferSize && i < nCount;++aIter, i++)
  {
      // Lengths depending on data type:
      sal_Int32 nLen = 0;
      sal_Int32 nType = 0;
      nLen    = m_aPrecisions[i-1];
      nType   = m_aTypes[i-1];

      switch(nType)
      {
          case DataType::INTEGER:
          case DataType::DOUBLE:
          case DataType::TIMESTAMP:
          case DataType::DATE:
          case DataType::BIT:
          case DataType::LONGVARCHAR:
          case DataType::LONGVARBINARY:
              nLen = m_aRealFieldLengths[i-1];
              break;
          case DataType::DECIMAL:
              nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,m_aScales[i-1]);
              break;  // the sign and the comma

          case DataType::BINARY:
          case DataType::OTHER:
              nByteOffset += nLen;
              continue;
      }

      // Is the variable bound?
      if ( !(*_rRow)[i]->isBound() )
      {
          // No - next field.
          nByteOffset += nLen;
          OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!")do { if (true && (!(nByteOffset <= m_nBufferSize))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "805" ": "), "%s", "ByteOffset > m_nBufferSize!"); } }
 while (false);
          continue;
      } // if ( !(_rRow->get())[i]->isBound() )
      if ( ( nByteOffset + nLen) > m_nBufferSize )
          break; // length doesn't match buffer size.

      char *pData = reinterpret_cast<char *>(m_pBuffer.get() + nByteOffset);

      if (nType == DataType::CHAR || nType == DataType::VARCHAR)
      {
          sal_Int32 nLastPos = -1;
          for (sal_Int32 k = 0; k < nLen; ++k)
          {
              if (pData[k] != ' ')
                  // Record last non-empty position.
                  nLastPos = k;
          }
          if (nLastPos < 0)
          {
              // Empty string.  Skip it.
              (*_rRow)[i]->setNull();
          }
          else
          {
              // Commit the string.  Use intern() to ref-count it.
              *(*_rRow)[i] = OUString::intern(pData, static_cast<sal_Int32>(nLastPos+1), m_eEncoding);
          }
      } // if (nType == DataType::CHAR || nType == DataType::VARCHAR)
      else if ( DataType::TIMESTAMP == nType )
      {
          sal_Int32 nDate = 0,nTime = 0;
          memcpy(&nDate, pData, 4);
          memcpy(&nTime, pData+ 4, 4);
          if ( !nDate && !nTime )
          {
              (*_rRow)[i]->setNull();
          }
          else
          {
              css::util::DateTime aDateTime;
              lcl_CalDate(nDate,nTime,aDateTime);
              *(*_rRow)[i] = aDateTime;
          }
      }
      else if ( DataType::INTEGER == nType )
      {
          sal_Int32 nValue = 0;
          if (o3tl::make_unsigned(nLen) > sizeof(nValue))
              return false;
          memcpy(&nValue, pData, nLen);
          *(*_rRow)[i] = nValue;
      }
      else if ( DataType::DOUBLE == nType )
      {
          double d = 0.0;
          if (getBOOL((*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY39)))) // Currency is treated separately
          {
              sal_Int64 nValue = 0;
              if (o3tl::make_unsigned(nLen) > sizeof(nValue))
                  return false;
              memcpy(&nValue, pData, nLen);

              if ( m_aScales[i-1] )
                  d = (nValue / pow(10.0,static_cast<int>(m_aScales[i-1])));
              else
                  d = static_cast<double>(nValue);
          }
          else
          {
              if (o3tl::make_unsigned(nLen) > sizeof(d))
                  return false;
              memcpy(&d, pData, nLen);
          }

          *(*_rRow)[i] = d;
      }
      else
      {
          sal_Int32 nPos1 = -1, nPos2 = -1;
          // If the string contains Nul-characters, then convert them to blanks!
          for (sal_Int32 k = 0; k < nLen; k++)
          {
              if (pData[k] == '\0')
                  pData[k] = ' ';

              if (pData[k] != ' ')
              {
                  if (nPos1 < 0)
                      // first non-empty char position.
                      nPos1 = k;

                  // last non-empty char position.
                  nPos2 = k;
              }
          }

          if (nPos1 < 0)
          {
              // Empty string.  Skip it.
              nByteOffset += nLen;
              (*_rRow)[i]->setNull();   // no values -> done
              continue;
          }

          OUString aStr = OUString::intern(pData+nPos1, nPos2-nPos1+1, m_eEncoding);

          switch (nType)
          {
              case DataType::DATE:
              {
                  if (aStr.getLength() != nLen)
                  {
                      (*_rRow)[i]->setNull();
                      break;
                  }
                  const sal_uInt16  nYear   = static_cast<sal_uInt16>(aStr.copy( 0, 4 ).toInt32());
                  const sal_uInt16  nMonth  = static_cast<sal_uInt16>(aStr.copy( 4, 2 ).toInt32());
                  const sal_uInt16  nDay    = static_cast<sal_uInt16>(aStr.copy( 6, 2 ).toInt32());

                  const css::util::Date aDate(nDay,nMonth,nYear);
                  *(*_rRow)[i] = aDate;
              }
              break;
              case DataType::DECIMAL:
                  *(*_rRow)[i] = ORowSetValue(aStr);
              break;
              case DataType::BIT:
              {
                  bool b;
                  switch (*pData)
                  {
                      case 'T':
                      case 'Y':
                      case 'J':   b = true; break;
                      default:    b = false; break;
                  }
                  *(*_rRow)[i] = b;
              }
              break;
              case DataType::LONGVARBINARY:
              case DataType::BINARY:
              case DataType::LONGVARCHAR:
              {
                  const long nBlockNo = aStr.toInt32();   // read blocknumber
                  if (nBlockNo > 0 && m_pMemoStream) // Read data from memo-file, only if
                  {
                      if ( !ReadMemo(nBlockNo, (*_rRow)[i]->get()) )
                          break;
                  }
                  else
                      (*_rRow)[i]->setNull();
              }   break;
              default:
                  SAL_WARN( "connectivity.drivers","Wrong type")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "Wrong type"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "958" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Wrong type"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "Wrong type"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "958" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Wrong type") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "958" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "Wrong type"), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "Wrong type"; ::
sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "958" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }
          (*_rRow)[i]->setTypeKind(nType);
      }

      nByteOffset += nLen;
      OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!")do { if (true && (!(nByteOffset <= m_nBufferSize))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "964" ": "), "%s", "ByteOffset > m_nBufferSize!"); } }
 while (false);
  }
  return true;
967}


970void ODbaseTable::FileClose()
971{
  ::osl::MutexGuard aGuard(m_aMutex);
  // if not everything has been written yet
  if (m_pMemoStream && m_pMemoStream->IsWritable())
      m_pMemoStream->Flush();

  m_pMemoStream.reset();

  ODbaseTable_BASE::FileClose();
980}

982bool ODbaseTable::CreateImpl()
983{
  OSL_ENSURE(!m_pFileStream, "SequenceError")do { if (true && (!(!m_pFileStream))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "984" ": "), "%s", "SequenceError"); } } while (false);

  if ( m_pConnection->isCheckEnabled() && ::dbtools::convertName2SQLName(m_Name,OUString()) != m_Name )
  {
      const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
              STR_SQL_NAME_ERRORreinterpret_cast<char const *>("STR_SQL_NAME_ERROR" "\004"
 u8"The name '$name$' doesn't match SQL naming constraints."),
              "$name$", m_Name
           ) );
      ::dbtools::throwGenericSQLException( sError, *this );
  }

  INetURLObject aURL;
  aURL.SetSmartProtocol(INetProtocol::File);
  OUString aName = getEntry(m_pConnection, m_Name);
  if(aName.isEmpty())
  {
      OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
      if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
          aIdent += "/";
      aIdent += m_Name;
      aName = aIdent;
  }
  aURL.SetURL(aName);

  if ( !m_pConnection->matchesExtension( aURL.getExtension() ) )
      aURL.setExtension(m_pConnection->getExtension());

  try
  {
      Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
      if (aContent.isDocument())
      {
          // Only if the file exists with length > 0 raise an error
          std::unique_ptr<SvStream> pFileStream(createStream_simpleError( aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), StreamMode::READ));

          if (pFileStream && pFileStream->TellEnd())
              return false;
      }
  }
  catch(const Exception&) // an exception is thrown when no file exists
  {
  }

  bool bMemoFile = false;

  bool bOk = CreateFile(aURL, bMemoFile);

  FileClose();

  if (!bOk)
  {
      try
      {
          Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
          aContent.executeCommand( "delete", css::uno::Any( true ) );
      }
      catch(const Exception&) // an exception is thrown when no file exists
      {
      }
      return false;
  }

  if (bMemoFile)
  {
      OUString aExt = aURL.getExtension();
      aURL.setExtension("dbt");                      // extension for memo file

      bool bMemoAlreadyExists = false;
      try
      {
          Content aMemo1Content(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
          bMemoAlreadyExists = aMemo1Content.isDocument();
      }
      catch(const Exception&) // an exception is thrown when no file exists
      {
      }
      if (bMemoAlreadyExists)
      {
          aURL.setExtension(aExt);      // kill dbf file
          try
          {
              Content aMemoContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
              aMemoContent.executeCommand( "delete", css::uno::Any( true ) );
          }
          catch(const Exception&)
          {
              css::uno::Any anyEx = cppu::getCaughtException();
              const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                      STR_COULD_NOT_DELETE_FILEreinterpret_cast<char const *>("STR_COULD_NOT_DELETE_FILE"
 "\004" u8"The file $filename$ could not be deleted."),
                      "$name$", aName
                   ) );
              ::dbtools::throwGenericSQLException( sError, *this, anyEx );
          }
      }
      if (!CreateMemoFile(aURL))
      {
          aURL.setExtension(aExt);      // kill dbf file
          try
          {
              Content aMemoContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());
              aMemoContent.executeCommand( "delete", css::uno::Any( true ) );
          }
          catch(const ContentCreationException&)
          {
              css::uno::Any anyEx = cppu::getCaughtException();
              const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                      STR_COULD_NOT_DELETE_FILEreinterpret_cast<char const *>("STR_COULD_NOT_DELETE_FILE"
 "\004" u8"The file $filename$ could not be deleted."),
                      "$name$", aName
                   ) );
              ::dbtools::throwGenericSQLException( sError, *this, anyEx );
          }
          return false;
      }
      m_aHeader.type = dBaseIIIMemo;
  }
  else
      m_aHeader.type = dBaseIII;

  return true;
1103}

1105void ODbaseTable::throwInvalidColumnType(const char* pErrorId, const OUString& _sColumnName)
1106{
  try
  {
      // we have to drop the file because it is corrupted now
      DropImpl();
  }
  catch(const Exception&)
  {
  }

  const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
          pErrorId,
          "$columnname$", _sColumnName
       ) );
  ::dbtools::throwGenericSQLException( sError, *this );
1121}

1123// creates in principle dBase IV file format
1124bool ODbaseTable::CreateFile(const INetURLObject& aFile, bool& bCreateMemo)
1125{
  bCreateMemo = false;
  Date aDate( Date::SYSTEM );                     // current date

  m_pFileStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::DecodeMechanism::NONE),StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC );

  if (!m_pFileStream)
      return false;

  sal_uInt8 nDbaseType = dBaseIII;
  Reference<XIndexAccess> xColumns(getColumns(),UNO_QUERY);
  Reference<XPropertySet> xCol;
  const OUString sPropType = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE12);

  try
  {
      const sal_Int32 nCount = xColumns->getCount();
      for(sal_Int32 i=0;i<nCount;++i)
      {
          xColumns->getByIndex(i) >>= xCol;
          OSL_ENSURE(xCol.is(),"This should be a column!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1145" ": "), "%s", "This should be a column!"); } } while
 (false);

          switch (getINT32(xCol->getPropertyValue(sPropType)))
          {
              case DataType::DOUBLE:
              case DataType::INTEGER:
              case DataType::TIMESTAMP:
              case DataType::LONGVARBINARY:
                  nDbaseType = VisualFoxPro;
                  i = nCount; // no more columns need to be checked
                  break;
          } // switch (getINT32(xCol->getPropertyValue(sPropType)))
      }
  }
  catch ( const Exception& )
  {
      try
      {
          // we have to drop the file because it is corrupted now
          DropImpl();
      }
      catch(const Exception&) { }
      throw;
  }

  char aBuffer[21] = {}; // write buffer

  m_pFileStream->Seek(0);
  (*m_pFileStream).WriteUChar( nDbaseType );                            // dBase format
  (*m_pFileStream).WriteUChar( aDate.GetYearUnsigned() % 100 );         // current date


  (*m_pFileStream).WriteUChar( aDate.GetMonth() );
  (*m_pFileStream).WriteUChar( aDate.GetDay() );
  (*m_pFileStream).WriteUInt32( 0 );                                    // number of data records
  (*m_pFileStream).WriteUInt16( (m_xColumns->getCount()+1) * 32 + 1 );  // header information,
                                                                        // pColumns contains always an additional column
  (*m_pFileStream).WriteUInt16( 0 );                                     // record length will be determined later
  m_pFileStream->WriteBytes(aBuffer, 20);

  sal_uInt16 nRecLength = 1;                                              // Length 1 for deleted flag
  sal_Int32  nMaxFieldLength = m_pConnection->getMetaData()->getMaxColumnNameLength();
  OUString aName;
  const OUString sPropName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11);
  const OUString sPropPrec = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION14);
  const OUString sPropScale = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE15);

  try
  {
      const sal_Int32 nCount = xColumns->getCount();
      for(sal_Int32 i=0;i<nCount;++i)
      {
          xColumns->getByIndex(i) >>= xCol;
          OSL_ENSURE(xCol.is(),"This should be a column!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1198" ": "), "%s", "This should be a column!"); } } while
 (false);

          char cTyp( 'C' );

          xCol->getPropertyValue(sPropName) >>= aName;

          OString aCol;
          if ( DBTypeConversion::convertUnicodeString( aName, aCol, m_eEncoding ) > nMaxFieldLength)
          {
              throwInvalidColumnType( STR_INVALID_COLUMN_NAME_LENGTHreinterpret_cast<char const *>("STR_INVALID_COLUMN_NAME_LENGTH"
 "\004" u8"Invalid column name length for column '$columnname$'."
), aName );
          }

          m_pFileStream->WriteOString( aCol );
          m_pFileStream->WriteBytes(aBuffer, 11 - aCol.getLength());

          sal_Int32 nPrecision = 0;
          xCol->getPropertyValue(sPropPrec) >>= nPrecision;
          sal_Int32 nScale = 0;
          xCol->getPropertyValue(sPropScale) >>= nScale;

          bool bBinary = false;

          switch (getINT32(xCol->getPropertyValue(sPropType)))
          {
              case DataType::CHAR:
              case DataType::VARCHAR:
                  cTyp = 'C';
                  break;
              case DataType::DOUBLE:
                  if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY39)))) // Currency will be treated separately
                      cTyp = 'Y';
                  else
                      cTyp = 'B';
                  break;
              case DataType::INTEGER:
                  cTyp = 'I';
                  break;
              case DataType::TINYINT:
              case DataType::SMALLINT:
              case DataType::BIGINT:
              case DataType::DECIMAL:
              case DataType::NUMERIC:
              case DataType::REAL:
                  cTyp = 'N';                             // only dBase 3 format
                  break;
              case DataType::TIMESTAMP:
                  cTyp = 'T';
                  break;
              case DataType::DATE:
                  cTyp = 'D';
                  break;
              case DataType::BIT:
                  cTyp = 'L';
                  break;
              case DataType::LONGVARBINARY:
                  bBinary = true;
                  [[fallthrough]];
              case DataType::LONGVARCHAR:
                  cTyp = 'M';
                  break;
              default:
                  {
                      throwInvalidColumnType(STR_INVALID_COLUMN_TYPEreinterpret_cast<char const *>("STR_INVALID_COLUMN_TYPE"
 "\004" u8"Invalid column type for column '$columnname$'."), aName);
                  }
          }

          (*m_pFileStream).WriteChar( cTyp );
          if ( nDbaseType == VisualFoxPro )
              (*m_pFileStream).WriteUInt32( nRecLength-1 );
          else
              m_pFileStream->WriteBytes(aBuffer, 4);

          switch(cTyp)
          {
              case 'C':
                  OSL_ENSURE(nPrecision < 255, "ODbaseTable::Create: Column too long!")do { if (true && (!(nPrecision < 255))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1273" ": "), "%s", "ODbaseTable::Create: Column too long!"
); } } while (false);
                  if (nPrecision > 254)
                  {
                      throwInvalidColumnType(STR_INVALID_COLUMN_PRECISIONreinterpret_cast<char const *>("STR_INVALID_COLUMN_PRECISION"
 "\004" u8"Invalid precision for column '$columnname$'."), aName);
                  }
                  (*m_pFileStream).WriteUChar( std::min(static_cast<unsigned>(nPrecision), 255U) );      // field length
                  nRecLength = nRecLength + static_cast<sal_uInt16>(std::min(static_cast<sal_uInt16>(nPrecision), sal_uInt16(255UL)));
                  (*m_pFileStream).WriteUChar( 0 );                                                                // decimals
                  break;
              case 'F':
              case 'N':
                  OSL_ENSURE(nPrecision >=  nScale,do { if (true && (!(nPrecision >= nScale))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1285" ": "), "%s", "ODbaseTable::Create: Field length must be larger than decimal places!"
); } } while (false)
                          "ODbaseTable::Create: Field length must be larger than decimal places!")do { if (true && (!(nPrecision >= nScale))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1285" ": "), "%s", "ODbaseTable::Create: Field length must be larger than decimal places!"
); } } while (false);
                  if (nPrecision <  nScale)
                  {
                      throwInvalidColumnType(STR_INVALID_PRECISION_SCALEreinterpret_cast<char const *>("STR_INVALID_PRECISION_SCALE"
 "\004" u8"Precision is less than scale for column '$columnname$'."
), aName);
                  }
                  if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY39)))) // Currency will be treated separately
                  {
                      (*m_pFileStream).WriteUChar( 10 );          // standard length
                      (*m_pFileStream).WriteUChar( 4 );
                      nRecLength += 10;
                  }
                  else
                  {
                      sal_Int32 nPrec = SvDbaseConverter::ConvertPrecisionToDbase(nPrecision,nScale);

                      (*m_pFileStream).WriteUChar( nPrec );
                      (*m_pFileStream).WriteUChar( nScale );
                      nRecLength += static_cast<sal_uInt16>(nPrec);
                  }
                  break;
              case 'L':
                  (*m_pFileStream).WriteUChar( 1 );
                  (*m_pFileStream).WriteUChar( 0 );
                  ++nRecLength;
                  break;
              case 'I':
                  (*m_pFileStream).WriteUChar( 4 );
                  (*m_pFileStream).WriteUChar( 0 );
                  nRecLength += 4;
                  break;
              case 'Y':
              case 'B':
              case 'T':
              case 'D':
                  (*m_pFileStream).WriteUChar( 8 );
                  (*m_pFileStream).WriteUChar( 0 );
                  nRecLength += 8;
                  break;
              case 'M':
                  bCreateMemo = true;
                  (*m_pFileStream).WriteUChar( 10 );
                  (*m_pFileStream).WriteUChar( 0 );
                  nRecLength += 10;
                  if ( bBinary )
                      aBuffer[0] = 0x06;
                  break;
              default:
                  throwInvalidColumnType(STR_INVALID_COLUMN_TYPEreinterpret_cast<char const *>("STR_INVALID_COLUMN_TYPE"
 "\004" u8"Invalid column type for column '$columnname$'."), aName);
          }
          m_pFileStream->WriteBytes(aBuffer, 14);
          aBuffer[0] = 0x00;
      }

      (*m_pFileStream).WriteUChar( FIELD_DESCRIPTOR_TERMINATOR0x0D );              // end of header
      (*m_pFileStream).WriteChar( char(DBF_EOL0x1A) );
      m_pFileStream->Seek(10);
      (*m_pFileStream).WriteUInt16( nRecLength );                                     // set record length afterwards

      if (bCreateMemo)
      {
          m_pFileStream->Seek(0);
          if (nDbaseType == VisualFoxPro)
              (*m_pFileStream).WriteUChar( FoxProMemo );
          else
              (*m_pFileStream).WriteUChar( dBaseIIIMemo );
      } // if (bCreateMemo)
  }
  catch ( const Exception& )
  {
      try
      {
          // we have to drop the file because it is corrupted now
          DropImpl();
      }
      catch(const Exception&) { }
      throw;
  }
  return true;
1363}


1366// creates in principle dBase III file format
1367bool ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
1368{
  // filehandling macro for table creation
  m_pMemoStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::DecodeMechanism::NONE),StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE);

  if (!m_pMemoStream)
      return false;

  m_pMemoStream->SetStreamSize(512);

  m_pMemoStream->Seek(0);
  (*m_pMemoStream).WriteUInt32( 1 );                  // pointer to the first free block

  m_pMemoStream->Flush();
  m_pMemoStream.reset();
  return true;
1383}

1385bool ODbaseTable::Drop_Static(const OUString& _sUrl, bool _bHasMemoFields, OCollection* _pIndexes )
1386{
  INetURLObject aURL;
  aURL.SetURL(_sUrl);

  bool bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));

  if(bDropped)
  {
      if (_bHasMemoFields)
      {  // delete the memo fields
          aURL.setExtension("dbt");
          bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
      }

      if(bDropped)
      {
          if(_pIndexes)
          {
              try
              {
                  sal_Int32 i = _pIndexes->getCount();
                  while (i)
                  {
                      _pIndexes->dropByIndex(--i);
                  }
              }
              catch(const SQLException&)
              {
              }
          }
          aURL.setExtension("inf");

          // as the inf file does not necessarily exist, we aren't allowed to use UCBContentHelper::Kill
          try
          {
              ::ucbhelper::Content aDeleteContent( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext() );
              aDeleteContent.executeCommand( "delete", makeAny( true ) );
          }
          catch(const Exception&)
          {
              // silently ignore this...
          }
      }
  }
  return bDropped;
1431}

1433bool ODbaseTable::DropImpl()
1434{
  FileClose();

  if(!m_xIndexes)
      refreshIndexes(); // look for indexes which must be deleted as well

  bool bDropped = Drop_Static(getEntry(m_pConnection,m_Name),HasMemoFields(),m_xIndexes.get());
  if(!bDropped)
  {// we couldn't drop the table so we have to reopen it
      construct();
      if(m_xColumns)
          m_xColumns->refresh();
  }
  return bDropped;
1448}


1451bool ODbaseTable::InsertRow(OValueRefVector& rRow, const Reference<XIndexAccess>& _xCols)
1452{
  // fill buffer with blanks
  if (!AllocBuffer())
      return false;

  memset(m_pBuffer.get(), 0, m_aHeader.recordLength);
  m_pBuffer[0] = ' ';

  // Copy new row completely:
  // ... and add at the end as new Record:
  std::size_t nTempPos = m_nFilePos;

  m_nFilePos = static_cast<std::size_t>(m_aHeader.nbRecords) + 1;
  bool bInsertRow = UpdateBuffer( rRow, nullptr, _xCols, true );
  if ( bInsertRow )
  {
      std::size_t nFileSize = 0, nMemoFileSize = 0;

      nFileSize = lcl_getFileSize(*m_pFileStream);

      if (HasMemoFields() && m_pMemoStream)
      {
          m_pMemoStream->Seek(STREAM_SEEK_TO_END((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));
          nMemoFileSize = m_pMemoStream->Tell();
      }

      if (!WriteBuffer())
      {
          m_pFileStream->SetStreamSize(nFileSize);                // restore old size

          if (HasMemoFields() && m_pMemoStream)
              m_pMemoStream->SetStreamSize(nMemoFileSize);    // restore old size
          m_nFilePos = nTempPos;              // restore file position
      }
      else
      {
          (*m_pFileStream).WriteChar( char(DBF_EOL0x1A) ); // write EOL
          // raise number of datasets in the header:
          m_pFileStream->Seek( 4 );
          (*m_pFileStream).WriteUInt32( m_aHeader.nbRecords + 1 );

          m_pFileStream->Flush();

          // raise number if successfully
          m_aHeader.nbRecords++;
          *rRow[0] = m_nFilePos;                                // set bookmark
          m_nFilePos = nTempPos;
      }
  }
  else
      m_nFilePos = nTempPos;

  return bInsertRow;
1505}


1508bool ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow, const Reference<XIndexAccess>& _xCols)
1509{
  // fill buffer with blanks
  if (!AllocBuffer())
      return false;

  // position on desired record:
  std::size_t nPos = m_aHeader.headerLength + static_cast<long>(m_nFilePos-1) * m_aHeader.recordLength;
  m_pFileStream->Seek(nPos);
  m_pFileStream->ReadBytes(m_pBuffer.get(), m_aHeader.recordLength);

  std::size_t nMemoFileSize( 0 );
  if (HasMemoFields() && m_pMemoStream)
  {
      m_pMemoStream->Seek(STREAM_SEEK_TO_END((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));
      nMemoFileSize = m_pMemoStream->Tell();
  }
  if (!UpdateBuffer(rRow, pOrgRow, _xCols, false) || !WriteBuffer())
  {
      if (HasMemoFields() && m_pMemoStream)
          m_pMemoStream->SetStreamSize(nMemoFileSize);    // restore old size
  }
  else
  {
      m_pFileStream->Flush();
  }
  return true;
1535}


1538bool ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
1539{
  // Set the Delete-Flag (be it set or not):
  // Position on desired record:
  std::size_t nFilePos = m_aHeader.headerLength + static_cast<long>(m_nFilePos-1) * m_aHeader.recordLength;
  m_pFileStream->Seek(nFilePos);

  OValueRefRow aRow = new OValueRefVector(_rCols.size());

  if (!fetchRow(aRow,_rCols,true))
      return false;

  Reference<XPropertySet> xCol;
  OUString aColName;
  ::comphelper::UStringMixEqual aCase(isCaseSensitive());
  for (sal_Int32 i = 0; i < m_xColumns->getCount(); i++)
  {
      Reference<XPropertySet> xIndex = isUniqueByColumnName(i);
      if (xIndex.is())
      {
          xCol.set(m_xColumns->getByIndex(i), css::uno::UNO_QUERY);
          OSL_ENSURE(xCol.is(),"ODbaseTable::DeleteRow column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1559" ": "), "%s", "ODbaseTable::DeleteRow column is null!"
); } } while (false);
          if(xCol.is())
          {
              xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;

              Reference<XUnoTunnel> xTunnel(xIndex,UNO_QUERY);
              OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!")do { if (true && (!(xTunnel.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1565" ": "), "%s", "No TunnelImplementation!"); } } while
 (false);
              ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelId()) );
              OSL_ENSURE(pIndex,"ODbaseTable::DeleteRow: No Index returned!")do { if (true && (!(pIndex))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1567" ": "), "%s", "ODbaseTable::DeleteRow: No Index returned!"
); } } while (false);

              OSQLColumns::const_iterator aIter = std::find_if(_rCols.begin(), _rCols.end(),
                  [&aCase, &aColName](const OSQLColumns::value_type& rxCol) {
                      return aCase(getString(rxCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME37))), aColName); });
              if (aIter == _rCols.end())
                  continue;

              auto nPos = static_cast<sal_Int32>(std::distance(_rCols.begin(), aIter)) + 1;
              pIndex->Delete(m_nFilePos,*(*aRow)[nPos]);
          }
      }
  }

  m_pFileStream->Seek(nFilePos);
  (*m_pFileStream).WriteUChar( '*' ); // mark the row in the table as deleted
  m_pFileStream->Flush();
  return true;
1585}

1587Reference<XPropertySet> ODbaseTable::isUniqueByColumnName(sal_Int32 _nColumnPos)
1588{
  if(!m_xIndexes)
      refreshIndexes();
  if(m_xIndexes->hasElements())
  {
      Reference<XPropertySet> xCol;
      m_xColumns->getByIndex(_nColumnPos) >>= xCol;
      OSL_ENSURE(xCol.is(),"ODbaseTable::isUniqueByColumnName column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1595" ": "), "%s", "ODbaseTable::isUniqueByColumnName column is null!"
); } } while (false);
      OUString sColName;
      xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= sColName;

      Reference<XPropertySet> xIndex;
      for(sal_Int32 i=0;i<m_xIndexes->getCount();++i)
      {
          xIndex.set(m_xIndexes->getByIndex(i), css::uno::UNO_QUERY);
          if(xIndex.is() && getBOOL(xIndex->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE25))))
          {
              Reference<XNameAccess> xCols(Reference<XColumnsSupplier>(xIndex,UNO_QUERY_THROW)->getColumns());
              if(xCols->hasByName(sColName))
                  return xIndex;

          }
      }
  }
  return Reference<XPropertySet>();
1613}

1615static double toDouble(const OString& rString)
1616{
  return ::rtl::math::stringToDouble( rString, '.', ',' );
1618}


1621bool ODbaseTable::UpdateBuffer(OValueRefVector& rRow, const OValueRefRow& pOrgRow, const Reference<XIndexAccess>& _xCols, const bool bForceAllFields)
1622{
  OSL_ENSURE(m_pBuffer,"Buffer is NULL!")do { if (true && (!(m_pBuffer))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1623" ": "), "%s", "Buffer is NULL!"); } } while (false
);
  if ( !m_pBuffer )
      return false;
  sal_Int32 nByteOffset  = 1;

  // Update fields:
  Reference<XPropertySet> xCol;
  Reference<XPropertySet> xIndex;
  OUString aColName;
  const sal_Int32 nColumnCount = m_xColumns->getCount();
  std::vector< Reference<XPropertySet> > aIndexedCols(nColumnCount);

  ::comphelper::UStringMixEqual aCase(isCaseSensitive());

  Reference<XIndexAccess> xColumns = m_xColumns.get();
  // first search a key that exist already in the table
  for (sal_Int32 i = 0; i < nColumnCount; ++i)
  {
      sal_Int32 nPos = i;
      if(_xCols != xColumns)
      {
          m_xColumns->getByIndex(i) >>= xCol;
          OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1645" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
          xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;

          for(nPos = 0;nPos<_xCols->getCount();++nPos)
          {
              Reference<XPropertySet> xFindCol(
                  _xCols->getByIndex(nPos), css::uno::UNO_QUERY);
              OSL_ENSURE(xFindCol.is(),"ODbaseTable::UpdateBuffer column is null!")do { if (true && (!(xFindCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1652" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
              if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11))),aColName))
                  break;
          }
          if (nPos >= _xCols->getCount())
              continue;
      }

      ++nPos;
      xIndex = isUniqueByColumnName(i);
      aIndexedCols[i] = xIndex;
      if (xIndex.is())
      {
          // first check if the value is different to the old one and when if it conform to the index
          if(pOrgRow.is() && (rRow[nPos]->getValue().isNull() || rRow[nPos] == (*pOrgRow)[nPos]))
              continue;
          else
          {
              Reference<XUnoTunnel> xTunnel(xIndex,UNO_QUERY);
              OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!")do { if (true && (!(xTunnel.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1671" ": "), "%s", "No TunnelImplementation!"); } } while
 (false);
              ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelId()) );
              OSL_ENSURE(pIndex,"ODbaseTable::UpdateBuffer: No Index returned!")do { if (true && (!(pIndex))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1673" ": "), "%s", "ODbaseTable::UpdateBuffer: No Index returned!"
); } } while (false);

              if (pIndex->Find(0,*rRow[nPos]))
              {
                  // There is no unique value
                  if ( aColName.isEmpty() )
                  {
                      m_xColumns->getByIndex(i) >>= xCol;
                      OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1681" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
                      xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;
                      xCol.clear();
                  } // if ( !aColName.getLength() )
                  const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                          STR_DUPLICATE_VALUE_IN_COLUMNreinterpret_cast<char const *>("STR_DUPLICATE_VALUE_IN_COLUMN"
 "\004" u8"Duplicate value found in column '$columnname$'.")
                          ,"$columnname$", aColName
                       ) );
                  ::dbtools::throwGenericSQLException( sError, *this );
              }
          }
      }
  }

  // when we are here there is no double key in the table

  for (sal_Int32 i = 0; i < nColumnCount && nByteOffset <= m_nBufferSize ; ++i)
  {
      // Lengths for each data type:
      assert(i >= 0)(static_cast <bool> (i >= 0) ? void (0) : __assert_fail
 ("i >= 0", "/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
, 1700, __extension__ __PRETTY_FUNCTION__));
      OSL_ENSURE(o3tl::make_unsigned(i) < m_aPrecisions.size(),"Illegal index!")do { if (true && (!(o3tl::make_unsigned(i) < m_aPrecisions
.size()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN)
, ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1701" ": "), "%s", "Illegal index!"); } } while (false);
      sal_Int32 nLen = 0;
      sal_Int32 nType = 0;
      sal_Int32 nScale = 0;
      if ( o3tl::make_unsigned(i) < m_aPrecisions.size() )
      {
          nLen    = m_aPrecisions[i];
          nType   = m_aTypes[i];
          nScale  = m_aScales[i];
      }
      else
      {
          m_xColumns->getByIndex(i) >>= xCol;
          if ( xCol.is() )
          {
              xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION14)) >>= nLen;
              xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE12))      >>= nType;
              xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE15))     >>= nScale;
          }
      }

      bool bSetZero = false;
      switch (nType)
      {
          case DataType::INTEGER:
          case DataType::DOUBLE:
          case DataType::TIMESTAMP:
              bSetZero = true;
              [[fallthrough]];
          case DataType::LONGVARBINARY:
          case DataType::DATE:
          case DataType::BIT:
          case DataType::LONGVARCHAR:
              nLen = m_aRealFieldLengths[i];
              break;
          case DataType::DECIMAL:
              nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,nScale);
              break;  // The sign and the comma
          default:
              break;

      } // switch (nType)

      sal_Int32 nPos = i;
      if(_xCols != xColumns)
      {
          m_xColumns->getByIndex(i) >>= xCol;
          OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1748" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
          xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;
          for(nPos = 0;nPos<_xCols->getCount();++nPos)
          {
              Reference<XPropertySet> xFindCol(
                  _xCols->getByIndex(nPos), css::uno::UNO_QUERY);
              if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11))),aColName))
                  break;
          }
          if (nPos >= _xCols->getCount())
          {
              nByteOffset += nLen;
              continue;
          }
      }


      ++nPos; // the row values start at 1
      const ORowSetValue &thisColVal = rRow[nPos]->get();
      const bool thisColIsBound = thisColVal.isBound();
      const bool thisColIsNull = !thisColIsBound || thisColVal.isNull();
      // don't overwrite non-bound columns
      if ( ! (bForceAllFields || thisColIsBound) )
      {
          // No - don't overwrite this field, it has not changed.
          nByteOffset += nLen;
          continue;
      }
      if (aIndexedCols[i].is())
      {
          Reference<XUnoTunnel> xTunnel(aIndexedCols[i],UNO_QUERY);
          OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!")do { if (true && (!(xTunnel.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1779" ": "), "%s", "No TunnelImplementation!"); } } while
 (false);
          ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelId()) );
          OSL_ENSURE(pIndex,"ODbaseTable::UpdateBuffer: No Index returned!")do { if (true && (!(pIndex))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1781" ": "), "%s", "ODbaseTable::UpdateBuffer: No Index returned!"
); } } while (false);
          // Update !!
          if (pOrgRow.is() && !thisColIsNull)
              pIndex->Update(m_nFilePos, *(*pOrgRow)[nPos], thisColVal);
          else
              pIndex->Insert(m_nFilePos, thisColVal);
      }

      char* pData = reinterpret_cast<char *>(m_pBuffer.get() + nByteOffset);
      if (thisColIsNull)
      {
          if ( bSetZero )
              memset(pData,0,nLen);   // Clear to NULL char ('\0')
          else
              memset(pData,' ',nLen); // Clear to space/blank ('\0x20')
          nByteOffset += nLen;
          OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!")do { if (true && (!(nByteOffset <= m_nBufferSize))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1797" ": "), "%s", "ByteOffset > m_nBufferSize!"); }
 } while (false);
          continue;
      }

      try
      {
          switch (nType)
          {
              case DataType::TIMESTAMP:
                  {
                      sal_Int32 nJulianDate = 0, nJulianTime = 0;
                      lcl_CalcJulDate(nJulianDate,nJulianTime, thisColVal);
                      // Exactly 8 bytes to copy:
                      memcpy(pData,&nJulianDate,4);
                      memcpy(pData+4,&nJulianTime,4);
                  }
                  break;
              case DataType::DATE:
              {
                  css::util::Date aDate;
                  if(thisColVal.getTypeKind() == DataType::DOUBLE)
                      aDate = ::dbtools::DBTypeConversion::toDate(thisColVal.getDouble());
                  else
                      aDate = thisColVal;
                  char s[sizeof("-327686553565535")];
                      // reserve enough space for hypothetical max length
                  snprintf(s,
                      sizeof(s),
                      "%04" SAL_PRIdINT32"d" "%02" SAL_PRIuUINT32"u" "%02" SAL_PRIuUINT32"u",
                      static_cast<sal_Int32>(aDate.Year),
                      static_cast<sal_uInt32>(aDate.Month),
                      static_cast<sal_uInt32>(aDate.Day));

                  // Exactly 8 bytes to copy (even if s could hypothetically be longer):
                  memcpy(pData,s,8);
              } break;
              case DataType::INTEGER:
                  {
                      sal_Int32 nValue = thisColVal;
                      if (o3tl::make_unsigned(nLen) > sizeof(nValue))
                          return false;
                      memcpy(pData,&nValue,nLen);
                  }
                  break;
              case DataType::DOUBLE:
                  {
                      const double d = thisColVal;
                      m_xColumns->getByIndex(i) >>= xCol;

                      if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY39)))) // Currency is treated separately
                      {
                          sal_Int64 nValue = 0;
                          if ( m_aScales[i] )
                              nValue = static_cast<sal_Int64>(d * pow(10.0,static_cast<int>(m_aScales[i])));
                          else
                              nValue = static_cast<sal_Int64>(d);
                          if (o3tl::make_unsigned(nLen) > sizeof(nValue))
                              return false;
                          memcpy(pData,&nValue,nLen);
                      } // if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency is treated separately
                      else
                      {
                          if (o3tl::make_unsigned(nLen) > sizeof(d))
                              return false;
                          memcpy(pData,&d,nLen);
                      }
                  }
                  break;
              case DataType::DECIMAL:
              {
                  memset(pData,' ',nLen); // Clear to NULL

                  const double n = thisColVal;

                  // one, because const_cast GetFormatPrecision on SvNumberFormat is not constant,
                  // even though it really could and should be
                  const OString aDefaultValue( ::rtl::math::doubleToString( n, rtl_math_StringFormat_F, nScale, '.', nullptr, 0));
                  const sal_Int32 nValueLen = aDefaultValue.getLength();
                  if ( nValueLen <= nLen )
                  {
                      // Write value right-justified, padded with blanks to the left.
                      memcpy(pData+nLen-nValueLen,aDefaultValue.getStr(),nValueLen);
                      // write the resulting double back
                      *rRow[nPos] = toDouble(aDefaultValue);
                  }
                  else
                  {
                      m_xColumns->getByIndex(i) >>= xCol;
                      OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!")do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1885" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
                      xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;
                      std::vector< std::pair<const char* , OUString > > aStringToSubstitutes;
                      aStringToSubstitutes.push_back(std::pair<const char* , OUString >("$columnname$", aColName));
                      aStringToSubstitutes.push_back(std::pair<const char* , OUString >("$precision$", OUString::number(nLen)));
                      aStringToSubstitutes.push_back(std::pair<const char* , OUString >("$scale$", OUString::number(nScale)));
                      aStringToSubstitutes.push_back(std::pair<const char* , OUString >("$value$", OStringToOUString(aDefaultValue,RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76)))));

                      const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                              STR_INVALID_COLUMN_DECIMAL_VALUEreinterpret_cast<char const *>("STR_INVALID_COLUMN_DECIMAL_VALUE"
 "\004" u8"The '$columnname$' column has been defined as a \"Decimal\" type, the max. length is $precision$ characters (with $scale$ decimal places).\n\nThe specified value \"$value$ is longer than the number of digits allowed."
)
                              ,aStringToSubstitutes
                           ) );
                      ::dbtools::throwGenericSQLException( sError, *this );
                  }
              } break;
              case DataType::BIT:
                  *pData = thisColVal.getBool() ? 'T' : 'F';
                  break;
              case DataType::LONGVARBINARY:
              case DataType::LONGVARCHAR:
              {
                  char cNext = pData[nLen]; // Mark's scratch and replaced by 0
                  pData[nLen] = '\0';       // This is because the buffer is always a sign of greater ...

                  std::size_t nBlockNo = strtol(pData,nullptr,10); // Block number read

                  // Next initial character restore again:
                  pData[nLen] = cNext;
                  if (!m_pMemoStream)
                      break;
                  WriteMemo(thisColVal, nBlockNo);

                  OString aBlock(OString::number(nBlockNo));
                  //align aBlock at the right of a nLen sequence, fill to the left with '0'
                  OStringBuffer aStr;
                  comphelper::string::padToLength(aStr, nLen - aBlock.getLength(), '0');
                  aStr.append(aBlock);

                  // Copy characters:
                  memcpy(pData, aStr.getStr(), nLen);
              }   break;
              default:
              {
                  memset(pData,' ',nLen); // Clear to NULL

                  OUString sStringToWrite( thisColVal.getString() );

                  // convert the string, using the connection's encoding
                  OString sEncoded;

                  DBTypeConversion::convertUnicodeStringToLength( sStringToWrite, sEncoded, nLen, m_eEncoding );
                  memcpy( pData, sEncoded.getStr(), sEncoded.getLength() );

              }
              break;
          }
      }
      catch( const SQLException&  )
      {
          throw;
      }
      catch ( const Exception& )
      {
          m_xColumns->getByIndex(i) >>= xCol;
          OSL_ENSURE( xCol.is(), "ODbaseTable::UpdateBuffer column is null!" )do { if (true && (!(xCol.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1949" ": "), "%s", "ODbaseTable::UpdateBuffer column is null!"
); } } while (false);
          if ( xCol.is() )
              xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)) >>= aColName;

          const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                  STR_INVALID_COLUMN_VALUEreinterpret_cast<char const *>("STR_INVALID_COLUMN_VALUE"
 "\004" u8"The column '$columnname$' could not be updated. The value is invalid for that column."
),
                  "$columnname$", aColName
               ) );
          ::dbtools::throwGenericSQLException( sError, *this );
      }
      // And more ...
      nByteOffset += nLen;
      OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!")do { if (true && (!(nByteOffset <= m_nBufferSize))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "1961" ": "), "%s", "ByteOffset > m_nBufferSize!"); }
 } while (false);
  }
  return true;
1964}


1967void ODbaseTable::WriteMemo(const ORowSetValue& aVariable, std::size_t& rBlockNr)
1968{
  // if the BlockNo 0 is given, the block will be appended at the end
  std::size_t nSize = 0;
  OString aStr;
  css::uno::Sequence<sal_Int8> aValue;
  sal_uInt8 nHeader[4];
  const bool bBinary = aVariable.getTypeKind() == DataType::LONGVARBINARY && m_aMemoHeader.db_typ == MemoFoxPro;
  if ( bBinary )
  {
      aValue = aVariable.getSequence();
      nSize = aValue.getLength();
  }
  else
  {
      nSize = DBTypeConversion::convertUnicodeString( aVariable.getString(), aStr, m_eEncoding );
  }

  // append or overwrite
  bool bAppend = rBlockNr == 0;

  if (!bAppend)
  {
      switch (m_aMemoHeader.db_typ)
      {
          case MemodBaseIII: // dBase III-Memofield, ends with 2 * Ctrl-Z
              bAppend = nSize > (512 - 2);
              break;
          case MemoFoxPro:
          case MemodBaseIV: // dBase IV-Memofield with length
          {
              char sHeader[4];
              m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
              m_pMemoStream->SeekRel(4);
              m_pMemoStream->ReadBytes(sHeader, 4);

              std::size_t nOldSize;
              if (m_aMemoHeader.db_typ == MemoFoxPro)
                  nOldSize = ((static_cast<unsigned char>(sHeader[0]) * 256 +
                               static_cast<unsigned char>(sHeader[1])) * 256 +
                               static_cast<unsigned char>(sHeader[2])) * 256 +
                               static_cast<unsigned char>(sHeader[3]);
              else
                  nOldSize = ((static_cast<unsigned char>(sHeader[3]) * 256 +
                               static_cast<unsigned char>(sHeader[2])) * 256 +
                               static_cast<unsigned char>(sHeader[1])) * 256 +
                               static_cast<unsigned char>(sHeader[0])  - 8;

              // fits the new length in the used blocks
              std::size_t nUsedBlocks = ((nSize + 8) / m_aMemoHeader.db_size) + (((nSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0),
                    nOldUsedBlocks = ((nOldSize + 8) / m_aMemoHeader.db_size) + (((nOldSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0);
              bAppend = nUsedBlocks > nOldUsedBlocks;
          }
      }
  }

  if (bAppend)
  {
      sal_uInt64 const nStreamSize = m_pMemoStream->TellEnd();
      // fill last block
      rBlockNr = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);

      m_pMemoStream->SetStreamSize(rBlockNr * m_aMemoHeader.db_size);
      m_pMemoStream->Seek(STREAM_SEEK_TO_END((sal_uInt64) 0xFFFFFFFFFFFFFFFFul));
  }
  else
  {
      m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
  }

  switch (m_aMemoHeader.db_typ)
  {
      case MemodBaseIII: // dBase III-Memofield, ends with Ctrl-Z
      {
          const char cEOF = char(DBF_EOL0x1A);
          nSize++;
          m_pMemoStream->WriteBytes(aStr.getStr(), aStr.getLength());
          m_pMemoStream->WriteChar( cEOF ).WriteChar( cEOF );
      } break;
      case MemoFoxPro:
      case MemodBaseIV: // dBase IV-Memofield with length
      {
          if ( MemodBaseIV == m_aMemoHeader.db_typ )
              (*m_pMemoStream).WriteUChar( 0xFF )
                              .WriteUChar( 0xFF )
                              .WriteUChar( 0x08 );
          else
              (*m_pMemoStream).WriteUChar( 0x00 )
                              .WriteUChar( 0x00 )
                              .WriteUChar( 0x00 );

          sal_uInt32 nWriteSize = nSize;
          if (m_aMemoHeader.db_typ == MemoFoxPro)
          {
              if ( bBinary )
                  (*m_pMemoStream).WriteUChar( 0x00 ); // Picture
              else
                  (*m_pMemoStream).WriteUChar( 0x01 ); // Memo
              for (int i = 4; i > 0; nWriteSize >>= 8)
                  nHeader[--i] = static_cast<sal_uInt8>(nWriteSize % 256);
          }
          else
          {
              (*m_pMemoStream).WriteUChar( 0x00 );
              nWriteSize += 8;
              for (int i = 0; i < 4; nWriteSize >>= 8)
                  nHeader[i++] = static_cast<sal_uInt8>(nWriteSize % 256);
          }

          m_pMemoStream->WriteBytes(nHeader, 4);
          if ( bBinary )
              m_pMemoStream->WriteBytes(aValue.getConstArray(), aValue.getLength());
          else
              m_pMemoStream->WriteBytes(aStr.getStr(), aStr.getLength());
          m_pMemoStream->Flush();
      }
  }


  // Write the new block number
  if (bAppend)
  {
      sal_uInt64 const nStreamSize = m_pMemoStream->TellEnd();
      m_aMemoHeader.db_next = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);

      // Write the new block number
      m_pMemoStream->Seek(0);
      (*m_pMemoStream).WriteUInt32( m_aMemoHeader.db_next );
      m_pMemoStream->Flush();
  }
2097}


2100// XAlterTable
2101void SAL_CALL ODbaseTable::alterColumnByName( const OUString& colName, const Reference< XPropertySet >& descriptor )
2102{
  ::osl::MutexGuard aGuard(m_aMutex);
  checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);


  Reference<XDataDescriptorFactory> xOldColumn;
  m_xColumns->getByName(colName) >>= xOldColumn;

  try
  {
      alterColumn(m_xColumns->findColumn(colName)-1,descriptor,xOldColumn);
  }
  catch (const css::lang::IndexOutOfBoundsException&)
  {
      throw NoSuchElementException(colName, *this);
  }
2118}

2120void SAL_CALL ODbaseTable::alterColumnByIndex( sal_Int32 index, const Reference< XPropertySet >& descriptor )
2121{
  ::osl::MutexGuard aGuard(m_aMutex);
  checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);

  if(index < 0 || index >= m_xColumns->getCount())
      throw IndexOutOfBoundsException(OUString::number(index),*this);

  Reference<XDataDescriptorFactory> xOldColumn;
  m_xColumns->getByIndex(index) >>= xOldColumn;
  alterColumn(index,descriptor,xOldColumn);
2131}

2133void ODbaseTable::alterColumn(sal_Int32 index,
                            const Reference< XPropertySet >& descriptor ,
                            const Reference< XDataDescriptorFactory >& xOldColumn )
2136{
  if(index < 0 || index >= m_xColumns->getCount())
      throw IndexOutOfBoundsException(OUString::number(index),*this);

  try
  {
      OSL_ENSURE(descriptor.is(),"ODbaseTable::alterColumn: descriptor can not be null!")do { if (true && (!(descriptor.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2142" ": "), "%s", "ODbaseTable::alterColumn: descriptor can not be null!"
); } } while (false);
      // creates a copy of the original column and copy all properties from descriptor in xCopyColumn
      Reference<XPropertySet> xCopyColumn;
      if(xOldColumn.is())
          xCopyColumn = xOldColumn->createDataDescriptor();
      else
          xCopyColumn = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());

      ::comphelper::copyProperties(descriptor,xCopyColumn);

      // creates a temp file

      OUString sTempName = createTempFile();

      ODbaseTable* pNewTable = new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection));
      Reference<XPropertySet> xHoldTable = pNewTable;
      pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11),makeAny(sTempName));
      Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
      OSL_ENSURE(xAppend.is(),"ODbaseTable::alterColumn: No XAppend interface!")do { if (true && (!(xAppend.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2160" ": "), "%s", "ODbaseTable::alterColumn: No XAppend interface!"
); } } while (false);

      // copy the structure
      sal_Int32 i=0;
      for(;i < index;++i)
      {
          Reference<XPropertySet> xProp;
          m_xColumns->getByIndex(i) >>= xProp;
          Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
          Reference<XPropertySet> xCpy;
          if(xColumn.is())
              xCpy = xColumn->createDataDescriptor();
          else
              xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
          ::comphelper::copyProperties(xProp,xCpy);
          xAppend->appendByDescriptor(xCpy);
      }
      ++i; // now insert our new column
      xAppend->appendByDescriptor(xCopyColumn);

      for(;i < m_xColumns->getCount();++i)
      {
          Reference<XPropertySet> xProp;
          m_xColumns->getByIndex(i) >>= xProp;
          Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
          Reference<XPropertySet> xCpy;
          if(xColumn.is())
              xCpy = xColumn->createDataDescriptor();
          else
              xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
          ::comphelper::copyProperties(xProp,xCpy);
          xAppend->appendByDescriptor(xCpy);
      }

      // construct the new table
      if(!pNewTable->CreateImpl())
      {
          const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                  STR_COLUMN_NOT_ALTERABLEreinterpret_cast<char const *>("STR_COLUMN_NOT_ALTERABLE"
 "\004" u8"The column '$columnname$' could not be altered. May be the file system is write protected."
),
                  "$columnname$", ::comphelper::getString(descriptor->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)))
               ) );
          ::dbtools::throwGenericSQLException( sError, *this );
      }

      pNewTable->construct();

      // copy the data
      copyData(pNewTable,0);

      // now drop the old one
      if( DropImpl() ) // we don't want to delete the memo columns too
      {
          try
          {
              // rename the new one to the old one
              pNewTable->renameImpl(m_Name);
          }
          catch(const css::container::ElementExistException&)
          {
              const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
                      STR_COULD_NOT_DELETE_FILEreinterpret_cast<char const *>("STR_COULD_NOT_DELETE_FILE"
 "\004" u8"The file $filename$ could not be deleted."),
                      "$filename$", m_Name
                   ) );
              ::dbtools::throwGenericSQLException( sError, *this );
          }
          // release the temp file
          pNewTable = nullptr;
          ::comphelper::disposeComponent(xHoldTable);
      }
      else
      {
          pNewTable = nullptr;
      }
      FileClose();
      construct();
      if(m_xColumns)
          m_xColumns->refresh();

  }
  catch(const SQLException&)
  {
      throw;
  }
  catch(const Exception&)
  {
      TOOLS_WARN_EXCEPTION( "connectivity.drivers","")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "" <<
 " " << exceptionToString(tools_warn_exception)) == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2245" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2245" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2245" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2245" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      throw;
  }
2248}

2250Reference< XDatabaseMetaData> ODbaseTable::getMetaData() const
2251{
  return getConnection()->getMetaData();
2253}

2255void SAL_CALL ODbaseTable::rename( const OUString& newName )
2256{
  ::osl::MutexGuard aGuard(m_aMutex);
  checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
  if(m_pTables && m_pTables->hasByName(newName))
      throw ElementExistException(newName,*this);


  renameImpl(newName);

  ODbaseTable_BASE::rename(newName);

  construct();
  if(m_xColumns)
      m_xColumns->refresh();
2270}
2271namespace
2272{
  void renameFile(file::OConnection const * _pConnection,const OUString& oldName,
                  const OUString& newName,const OUString& _sExtension)
  {
      OUString aName = ODbaseTable::getEntry(_pConnection,oldName);
      if(aName.isEmpty())
      {
          OUString aIdent = _pConnection->getContent()->getIdentifier()->getContentIdentifier();
          if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
              aIdent += "/";
          aIdent += oldName;
          aName = aIdent;
      }
      INetURLObject aURL;
      aURL.SetURL(aName);

      aURL.setExtension( _sExtension );
      OUString sNewName(newName + "." + _sExtension);

      try
      {
          Content aContent(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE),Reference<XCommandEnvironment>(), comphelper::getProcessComponentContext());

          Sequence< PropertyValue > aProps( 1 );
          aProps[0].Name      = "Title";
          aProps[0].Handle    = -1; // n/a
          aProps[0].Value     <<= sNewName;
          Sequence< Any > aValues;
          aContent.executeCommand( "setPropertyValues",makeAny(aProps) ) >>= aValues;
          if(aValues.hasElements() && aValues[0].hasValue())
              throw Exception("setPropertyValues returned non-zero", nullptr);
      }
      catch(const Exception&)
      {
          throw ElementExistException(newName);
      }
  }
2309}

2311void ODbaseTable::renameImpl( const OUString& newName )
2312{
  ::osl::MutexGuard aGuard(m_aMutex);

  FileClose();


  renameFile(m_pConnection,m_Name,newName,m_pConnection->getExtension());
  if ( HasMemoFields() )
  {  // delete the memo fields
      renameFile(m_pConnection,m_Name,newName,"dbt");
  }
2323}

2325void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
2326{
  OUString sTempName = createTempFile();

  rtl::Reference xNewTable(new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection)));
  xNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11),makeAny(sTempName));
  {
      Reference<XAppend> xAppend(xNewTable->getColumns(),UNO_QUERY);
      bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
      // copy the structure
      for(sal_Int32 i=0;i < m_xColumns->getCount();++i)
      {
          Reference<XPropertySet> xProp;
          m_xColumns->getByIndex(i) >>= xProp;
          Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
          Reference<XPropertySet> xCpy;
          if(xColumn.is())
              xCpy = xColumn->createDataDescriptor();
          else
          {
              xCpy = new OColumn(bCase);
              ::comphelper::copyProperties(xProp,xCpy);
          }

          xAppend->appendByDescriptor(xCpy);
      }
      Reference<XPropertySet> xCpy = new OColumn(bCase);
      ::comphelper::copyProperties(_xNewColumn,xCpy);
      xAppend->appendByDescriptor(xCpy);
  }

  // construct the new table
  if(!xNewTable->CreateImpl())
  {
      const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
              STR_COLUMN_NOT_ADDABLEreinterpret_cast<char const *>("STR_COLUMN_NOT_ADDABLE"
 "\004" u8"The column '$columnname$' could not be added. May be the file system is write protected."
),
              "$columnname$", ::comphelper::getString(_xNewColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11)))
           ) );
      ::dbtools::throwGenericSQLException( sError, *this );
  }

  xNewTable->construct();
  // copy the data
  copyData(xNewTable.get(),xNewTable->m_xColumns->getCount());
  // drop the old table
  if(DropImpl())
  {
      xNewTable->renameImpl(m_Name);
      // release the temp file
  }
  xNewTable.clear();

  FileClose();
  construct();
  if(m_xColumns)
      m_xColumns->refresh();
2381}

2383void ODbaseTable::dropColumn(sal_Int32 _nPos)
2384{
  OUString sTempName = createTempFile();

  rtl::Reference xNewTable(new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection)));
  xNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME11),makeAny(sTempName));
  {
      Reference<XAppend> xAppend(xNewTable->getColumns(),UNO_QUERY);
      bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
      // copy the structure
      for(sal_Int32 i=0;i < m_xColumns->getCount();++i)
1
Assuming the condition is false→
2
←
Loop condition is false. Execution continues on line 109→
      {
          if(_nPos != i)
          {
              Reference<XPropertySet> xProp;
              m_xColumns->getByIndex(i) >>= xProp;
              Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
              Reference<XPropertySet> xCpy;
              if(xColumn.is())
                  xCpy = xColumn->createDataDescriptor();
              else
              {
                  xCpy = new OColumn(bCase);
                  ::comphelper::copyProperties(xProp,xCpy);
              }
              xAppend->appendByDescriptor(xCpy);
          }
      }
  }

  // construct the new table
  if(!xNewTable->CreateImpl())
3
←
Taking false branch→
  {
      const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
              STR_COLUMN_NOT_DROPreinterpret_cast<char const *>("STR_COLUMN_NOT_DROP" "\004"
 u8"The column at position '$position$' could not be dropped. May be the file system is write protected."
),
              "$position$", OUString::number(_nPos)
           ) );
      ::dbtools::throwGenericSQLException( sError, *this );
  }
  xNewTable->construct();
  // copy the data
  copyData(xNewTable.get(),_nPos);
4
←
Calling 'ODbaseTable::copyData'→
  // drop the old table
  if(DropImpl())
      xNewTable->renameImpl(m_Name);
      // release the temp file

  xNewTable.clear();

  FileClose();
  construct();
2434}

2436OUString ODbaseTable::createTempFile()
2437{
  OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
  if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
      aIdent += "/";

  OUString sTempName(aIdent);
  OUString sExt("." + m_pConnection->getExtension());
  OUString sName(m_Name);
  TempFile aTempFile(sName, true, &sExt, &sTempName);
  if(!aTempFile.IsValid())
      getConnection()->throwGenericSQLException(STR_COULD_NOT_ALTER_TABLEreinterpret_cast<char const *>("STR_COULD_NOT_ALTER_TABLE"
 "\004" u8"The table could not be altered."), *this);

  INetURLObject aURL;
  aURL.SetSmartProtocol(INetProtocol::File);
  aURL.SetURL(aTempFile.GetURL());

  OUString sNewName(aURL.getName().copy(0, aURL.getName().getLength() - sExt.getLength()));

  return sNewName;
2456}

2458void ODbaseTable::copyData(ODbaseTable* _pNewTable,sal_Int32 _nPos)
2459{
  sal_Int32 nPos = _nPos + 1; // +1 because we always have the bookmark column as well
  OValueRefRow aRow = new OValueRefVector(m_xColumns->getCount());
  OValueRefRow aInsertRow;
  if(_nPos)
5
←
Assuming '_nPos' is 0→
6
←
Taking false branch→
  {
      aInsertRow = new OValueRefVector(_pNewTable->m_xColumns->getCount());
      std::for_each(aInsertRow->begin(),aInsertRow->end(),TSetRefBound(true));
  }
  else
      aInsertRow = aRow;

  // we only have to bind the values which we need to copy into the new table
  std::for_each(aRow->begin(),aRow->end(),TSetRefBound(true));
  if(_nPos6.1
'_nPos' is 0
 && (_nPos < static_cast<sal_Int32>(aRow->size())))
      (*aRow)[nPos]->setBound(false);


  sal_Int32 nCurPos;
7
←
'nCurPos' declared without an initial value→
  OValueRefVector::const_iterator aIter;
  for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.nbRecords;++nRowPos)
8
←
Assuming 'nRowPos' is < field 'nbRecords'→
9
←
Loop condition is true.  Entering loop body→
  {
      bool bOk = seekRow( IResultSetHelper::BOOKMARK, nRowPos+1, nCurPos );
10
←
Passing value via 3rd parameter 'nCurPos'→
11
←
Calling 'ODbaseTable::seekRow'→
      if ( bOk )
      {
          bOk = fetchRow( aRow, *m_aColumns, true);
          if ( bOk && !aRow->isDeleted() ) // copy only not deleted rows
          {
              // special handling when pos == 0 then we don't have to distinguish between the two rows
              if(_nPos)
              {
                  aIter = aRow->begin()+1;
                  sal_Int32 nCount = 1;
                  for(OValueRefVector::iterator aInsertIter = aInsertRow->begin()+1; aIter != aRow->end() && aInsertIter != aInsertRow->end();++aIter,++nCount)
                  {
                      if(nPos != nCount)
                      {
                          (*aInsertIter)->setValue( (*aIter)->getValue() );
                          ++aInsertIter;
                      }
                  }
              }
              bOk = _pNewTable->InsertRow(*aInsertRow,_pNewTable->m_xColumns.get());
              SAL_WARN_IF(!bOk, "connectivity.drivers", "Row could not be inserted!")do { if (true && (!bOk)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "connectivity.drivers")) { case
 SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Row could not be inserted!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2502" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Row could not be inserted!"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Row could not be inserted!"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2502" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Row could not be inserted!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2502" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Row could not be inserted!"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "Row could not be inserted!"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2502" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }
          else
          {
              SAL_WARN_IF(!bOk, "connectivity.drivers", "Row could not be fetched!")do { if (true && (!bOk)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "connectivity.drivers")) { case
 SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Row could not be fetched!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2506" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Row could not be fetched!"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Row could not be fetched!"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2506" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Row could not be fetched!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2506" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Row could not be fetched!"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Row could not be fetched!"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2506" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }
      }
      else
      {
          OSL_ASSERT(false)do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2511" ": "), "OSL_ASSERT: %s", "false"); } } while (false
);
      }
  } // for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.db_anz;++nRowPos)
2514}

2516void ODbaseTable::throwInvalidDbaseFormat()
2517{
  FileClose();
  // no dbase file

  const OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
              STR_INVALID_DBASE_FILEreinterpret_cast<char const *>("STR_INVALID_DBASE_FILE"
 "\004" u8"The file '$filename$' is an invalid (or unrecognized) dBase file."
),
              "$filename$", getEntry(m_pConnection,m_Name)
           ) );
  ::dbtools::throwGenericSQLException( sError, *this );
2526}

2528void ODbaseTable::refreshHeader()
2529{
  if ( m_aHeader.nbRecords == 0 )
      readHeader();
2532}

2534bool ODbaseTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos)
2535{
  // prepare positioning:
  OSL_ENSURE(m_pFileStream,"ODbaseTable::seekRow: FileStream is NULL!")do { if (true && (!(m_pFileStream))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2537" ": "), "%s", "ODbaseTable::seekRow: FileStream is NULL!"
); } } while (false);
12
←
Taking false branch→
13
←
Loop condition is false.  Exiting loop→

  sal_uInt32  nNumberOfRecords = m_aHeader.nbRecords;
  sal_uInt32 nTempPos = m_nFilePos;
  m_nFilePos = nCurPos;
14
←
Assigned value is garbage or undefined

  switch(eCursorPosition)
  {
      case IResultSetHelper::NEXT:
          ++m_nFilePos;
          break;
      case IResultSetHelper::PRIOR:
          if (m_nFilePos > 0)
              --m_nFilePos;
          break;
      case IResultSetHelper::FIRST:
          m_nFilePos = 1;
          break;
      case IResultSetHelper::LAST:
          m_nFilePos = nNumberOfRecords;
          break;
      case IResultSetHelper::RELATIVE1:
          m_nFilePos = (m_nFilePos + nOffset < 0) ? 0
                          : static_cast<sal_uInt32>(m_nFilePos + nOffset);
          break;
      case IResultSetHelper::ABSOLUTE1:
      case IResultSetHelper::BOOKMARK:
          m_nFilePos = static_cast<sal_uInt32>(nOffset);
          break;
  }

  if (m_nFilePos > static_cast<sal_Int32>(nNumberOfRecords))
      m_nFilePos = static_cast<sal_Int32>(nNumberOfRecords) + 1;

  if (m_nFilePos == 0 || m_nFilePos == static_cast<sal_Int32>(nNumberOfRecords) + 1)
      goto Error;
  else
  {
      std::size_t nEntryLen = m_aHeader.recordLength;

      OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: invalid record position")do { if (true && (!(m_nFilePos >= 1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2577" ": "), "%s", "SdbDBFCursor::FileFetchRow: invalid record position"
); } } while (false);
      std::size_t nPos = m_aHeader.headerLength + static_cast<std::size_t>(m_nFilePos-1) * nEntryLen;

      m_pFileStream->Seek(nPos);
      if (m_pFileStream->GetError() != ERRCODE_NONEErrCode(0))
          goto Error;

      std::size_t nRead = m_pFileStream->ReadBytes(m_pBuffer.get(), nEntryLen);
      if (nRead != nEntryLen)
      {
          SAL_WARN("connectivity.drivers", "ODbaseTable::seekRow: short read!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "connectivity.drivers")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "ODbaseTable::seekRow: short read!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"
), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2587" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ODbaseTable::seekRow: short read!")
, 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::seekRow: short read!"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"),
 ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2587" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ODbaseTable::seekRow: short read!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2587" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ODbaseTable::seekRow: short read!")
, 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODbaseTable::seekRow: short read!"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("connectivity.drivers"),
 ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2587" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          goto Error;
      }
      if (m_pFileStream->GetError() != ERRCODE_NONEErrCode(0))
          goto Error;
  }
  goto End;

2595Error:
  switch(eCursorPosition)
  {
      case IResultSetHelper::PRIOR:
      case IResultSetHelper::FIRST:
          m_nFilePos = 0;
          break;
      case IResultSetHelper::LAST:
      case IResultSetHelper::NEXT:
      case IResultSetHelper::ABSOLUTE1:
      case IResultSetHelper::RELATIVE1:
          if (nOffset > 0)
              m_nFilePos = nNumberOfRecords + 1;
          else if (nOffset < 0)
              m_nFilePos = 0;
          break;
      case IResultSetHelper::BOOKMARK:
          m_nFilePos = nTempPos;   // last position
  }
  return false;

2616End:
  nCurPos = m_nFilePos;
  return true;
2619}

2621bool ODbaseTable::ReadMemo(std::size_t nBlockNo, ORowSetValue& aVariable)
2622{
  m_pMemoStream->Seek(nBlockNo * m_aMemoHeader.db_size);
  switch (m_aMemoHeader.db_typ)
  {
      case MemodBaseIII: // dBase III-Memofield, ends with Ctrl-Z
      {
          const char cEOF = char(DBF_EOL0x1A);
          OStringBuffer aBStr;
          static char aBuf[514];
          aBuf[512] = 0;          // avoid random value
          bool bReady = false;

          do
          {
              m_pMemoStream->ReadBytes(&aBuf, 512);

              sal_uInt16 i = 0;
              while (aBuf[i] != cEOF && ++i < 512)
                  ;
              bReady = aBuf[i] == cEOF;

              aBuf[i] = 0;
              aBStr.append(aBuf);

          } while (!bReady && !m_pMemoStream->eof());

          aVariable = OStringToOUString(aBStr.makeStringAndClear(),
              m_eEncoding);

      } break;
      case MemoFoxPro:
      case MemodBaseIV: // dBase IV-Memofield with length
      {
          bool bIsText = true;
          char sHeader[4];
          m_pMemoStream->ReadBytes(sHeader, 4);
          // Foxpro stores text and binary data
          if (m_aMemoHeader.db_typ == MemoFoxPro)
          {
              bIsText = sHeader[3] != 0;
          }
          else if (static_cast<sal_uInt8>(sHeader[0]) != 0xFF || static_cast<sal_uInt8>(sHeader[1]) != 0xFF || static_cast<sal_uInt8>(sHeader[2]) != 0x08)
          {
              return false;
          }

          sal_uInt32 nLength(0);
          (*m_pMemoStream).ReadUInt32( nLength );

          if (m_aMemoHeader.db_typ == MemodBaseIV)
              nLength -= 8;

          if ( nLength )
          {
              if ( bIsText )
              {
                  OStringBuffer aBuffer(read_uInt8s_ToOString(*m_pMemoStream, nLength));
                  //pad it out with ' ' to expected length on short read
                  sal_Int32 nRequested = sal::static_int_cast<sal_Int32>(nLength);
                  comphelper::string::padToLength(aBuffer, nRequested, ' ');
                  aVariable = OStringToOUString(aBuffer.makeStringAndClear(), m_eEncoding);
              } // if ( bIsText )
              else
              {
                  css::uno::Sequence< sal_Int8 > aData(nLength);
                  m_pMemoStream->ReadBytes(aData.getArray(), nLength);
                  aVariable = aData;
              }
          } // if ( nLength )
      }
  }
  return true;
2694}

2696bool ODbaseTable::AllocBuffer()
2697{
  sal_uInt16 nSize = m_aHeader.recordLength;
  SAL_WARN_IF(nSize == 0, "connectivity.drivers", "Size too small")do { if (true && (nSize == 0)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "connectivity.drivers")) { case
 SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Size too small") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2699" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Size too small"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "Size too small"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2699" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Size too small") == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2699" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Size too small"), 0); } else { ::std
::ostringstream sal_detail_stream; sal_detail_stream <<
 "Size too small"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("connectivity.drivers"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2699" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  if (m_nBufferSize != nSize)
  {
      m_pBuffer.reset();
  }

  // if there is no buffer available: allocate:
  if (!m_pBuffer && nSize > 0)
  {
      m_nBufferSize = nSize;
      m_pBuffer.reset(new sal_uInt8[m_nBufferSize+1]);
  }

  return m_pBuffer != nullptr;
2714}

2716bool ODbaseTable::WriteBuffer()
2717{
  OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: invalid record position")do { if (true && (!(m_nFilePos >= 1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/connectivity/source/drivers/dbase/DTable.cxx"
 ":" "2718" ": "), "%s", "SdbDBFCursor::FileFetchRow: invalid record position"
); } } while (false);

  // position on desired record:
  std::size_t nPos = m_aHeader.headerLength + static_cast<long>(m_nFilePos-1) * m_aHeader.recordLength;
  m_pFileStream->Seek(nPos);
  return m_pFileStream->WriteBytes(m_pBuffer.get(), m_aHeader.recordLength) > 0;
2724}

2726sal_Int32 ODbaseTable::getCurrentLastPos() const
2727{
  return m_aHeader.nbRecords;
2729}

2731/* vim:set shiftwidth=4 softtabstop=4 expandtab: */