Remove obsolete class Fl_String

Note: it's still in branch-1.4 and in git history for reference

3 files changed, 0 insertions, 828 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9c58ed958..f84d58d85 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -97,7 +97,6 @@ set(CPPFILES
   Fl_Single_Window.cxx
   Fl_Slider.cxx
   Fl_Spinner.cxx
-  Fl_String.cxx
   Fl_Sys_Menu_Bar.cxx
   Fl_System_Driver.cxx
   Fl_Table.cxx
diff --git a/src/Fl_String.H b/src/Fl_String.H
deleted file mode 100644
index b677da261..000000000
--- a/src/Fl_String.H
+++ /dev/null
@@ -1,159 +0,0 @@
-//
-// Basic Fl_String header for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file.  If this
-// file is missing or damaged, see the license at:
-//
-//     https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-//     https://www.fltk.org/bugs.php
-//
-
-#ifndef _FL_Fl_String_H_
-#define _FL_Fl_String_H_
-
-/**
- \cond DriverDev
- \addtogroup DriverDeveloper
- \{
- */
-
-/** \file src/Fl_String.H
-  Basic Fl_String class for FLTK.
-*/
-
-#include <FL/Fl_Export.H>
-
-#include <string>
-
-#if 1
-
-// Since fltk 1.5.0, Fl_String is no longer needed and now maps to std::string.
-// Fl_String is not part of the public API. All occurrences of Fl_String in the
-// core library and in Fluid should be replaced with std::string. When done,
-// src/Fl_String.H and src/Fl_String.cxx can be deleted.
-using Fl_String = std::string;
-
-#else
-
-// See: https://en.cppreference.com/w/cpp/string/basic_string/basic_string
-
-/**
-  Fl_String is the basic string class for FLTK.
-
-  In this version Fl_String can be used to store strings, copy strings,
-  move strings, and do basic string manipulation. Fl_String implements a
-  subset of std::string with a couple of extensions. std::string should be
-  a drop-in if we ever decide to allow templates and the std library.
-
-  Fl_String always maintains a trailing \e nul byte, but can also contain
-  \e nul bytes inside the string if the constructor
-  Fl_String(const char *str, int size) is used.
-
-  Assignment and copy constructors \b copy the string value such that the
-  source string can be freed immediately after the assignment.
-
-  c_str() and data() can be an empty string \c "", but never be \c NULL.
-
-  The method size() returns the full string size, whether the string contains
-  embedded \c nul bytes or not. The special method Fl_String::strlen() returns
-  the length of the string up to the first \e nul.
-
-  All methods of Fl_String work on a byte level. They are not UTF-8 aware,
-  but may hold and manipulate UTF-8 strings if done with care.
-
-  \since 1.4.0
-*/
-class FL_EXPORT Fl_String {
-
-private:
-  /*
-   FLTK does no small string optimization.
-   If the string is empty and capacity is not set, buffer_ will be NULL.
-   */
-  char *buffer_;
-  int size_;
-  int capacity_;
-
-  void init_();
-  void grow_(int n);
-  void shrink_(int n);
-  Fl_String &replace_(int at, int n_del, const char *src, int n_ins);
-
-protected:
-  static const char NUL;
-
-public:
-  static const int npos;
-
-  // ---- Assignment
-  Fl_String();
-  Fl_String(const Fl_String &str);
-  Fl_String(const char *cstr);
-  Fl_String(const char *str, int size);
-  ~Fl_String();
-  Fl_String& operator=(const Fl_String &str);
-  Fl_String& operator=(const char *cstr);
-  Fl_String &assign(const Fl_String &str);
-  Fl_String &assign(const char *cstr);
-  Fl_String &assign(const char *str, int size);
-
-  // ---- Element Access
-  char at(int pos) const;
-  char operator[](int n) const;
-  char &operator[](int n);
-  const char *data() const;
-  char *data();
-  const char *c_str() const;
-
-  // ---- Capacity
-  bool empty() const;
-  int size() const;
-  void reserve(int n);
-  int capacity() const;
-  void shrink_to_fit();
-
-  // --- Operations
-  void clear();
-  Fl_String &insert(int at, const char *src, int n_ins=npos);
-  Fl_String &insert(int at, const Fl_String &src);
-  Fl_String &erase(int at, int n_del);
-  void push_back(char c);
-  void pop_back();
-  Fl_String &append(const char *src, int n_ins=npos);
-  Fl_String &append(const Fl_String &src);
-  Fl_String &append(char c);
-  Fl_String &operator+=(const char *src);
-  Fl_String &operator+=(const Fl_String &src);
-  Fl_String &operator+=(char c);
-  int find(const Fl_String &needle, int start_pos=0) const;
-  Fl_String &replace(int at, int n_del, const char *src, int n_ins=npos);
-  Fl_String &replace(int at, int n_del, const Fl_String &src);
-  Fl_String substr(int pos=0, int n=npos) const;
-  void resize(int n);
-
-  // --- Non Standard
-  int strlen() const;
-  void debug(const char *info = 0) const;
-  void hexdump(const char *info = 0) const;
-}; // class Fl_String
-
-// ---- Non-member functions
-FL_EXPORT Fl_String operator+(const Fl_String& lhs, const Fl_String& rhs);
-FL_EXPORT Fl_String operator+(const Fl_String& lhs, const char* rhs);
-FL_EXPORT bool operator==(const Fl_String & lhs, const Fl_String & rhs);
-FL_EXPORT bool operator!=(const Fl_String & lhs, const Fl_String & rhs);
-
-#endif
-
-/**
-\}
-\endcond
-*/
-
-#endif // _FL_Fl_String_H_
diff --git a/src/Fl_String.cxx b/src/Fl_String.cxx
deleted file mode 100644
index 705b7cd9f..000000000
--- a/src/Fl_String.cxx
+++ /dev/null
@@ -1,668 +0,0 @@
-//
-// Basic Fl_String class for the Fast Light Tool Kit (FLTK).
-//
-// Copyright 2021-2023 by Bill Spitzak and others.
-//
-// This library is free software. Distribution and use rights are outlined in
-// the file "COPYING" which should have been included with this file.  If this
-// file is missing or damaged, see the license at:
-//
-//     https://www.fltk.org/COPYING.php
-//
-// Please see the following page on how to report bugs and issues:
-//
-//     https://www.fltk.org/bugs.php
-//
-
-#if 0
-
-/**
- \cond DriverDev
- \addtogroup DriverDeveloper
- \{
- */
-
-#include "Fl_String.H"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-
-
-/** \file src/Fl_String.cxx
- Basic Fl_String class for FLTK.
- */
-
-
-/*
- If buffer_ is NULL, c_str() and buffer() will point here.
- */
-const char Fl_String::NUL = 0;
-
-/**
- Indicate a maximum value or error.
- This value is generally used as end of string indicator or as the error
- indicator by the functions that return a string index.
- */
-const int Fl_String::npos = INT_MAX;
-
-/**
- Initialise the class instance.
- */
-void Fl_String::init_() {
-  buffer_ = NULL;
-  size_ = 0;
-  capacity_ = 0;
-}
-
-/**
- Grow the buffer to a capacity of at least n bytes.
-
- This method will always grow the buffer size, or keep it as is, but never
- shrink it. Use shrink_to_fit() to shrink the buffer as much as possible.
-
- \param[in] n number of bytes needed, not counting the trailing NUL
- */
-void Fl_String::grow_(int n) {
-  if (n <= capacity_)
-    return;
-  int alloc_size_ = n + 1; // trailing NUL
-  // round n up so we can grow in chunks
-  if (alloc_size_ <= 24) { // allocate at least 24 bytes
-    alloc_size_ = 24;
-  } else if (alloc_size_ < 1024 + 8) {
-    alloc_size_ = ((alloc_size_+128-8) & ~127) + 8; // allocate in 128 byte chunks
-  } else {
-    alloc_size_ = ((alloc_size_+2048-8) & ~2047) + 8; // allocate in 2k chunks
-    // adding 8 keeps the buffer 64-bit aligned while generating a space for
-    // the trailing NUL without jumping to the next chunk size for common
-    // allocations like 1024 or 2048 (FL_PATH_MAX).
-  }
-  // allocate now
-  char *new_buffer = (char*)::malloc(alloc_size_);
-  if (buffer_ && (size_ > 0)) {
-    memcpy(new_buffer, buffer_, size_);
-    ::free(buffer_);
-  }
-  if (size_ >= 0)
-    new_buffer[size_] = 0; // trailing NUL
-  buffer_ = new_buffer;
-  capacity_ = alloc_size_-1;  // trailing NUL
-}
-
-/**
- Shrink the buffer to n bytes, or size, if size > n.
-
- Shrink the buffer as much as possible. If \p n is 0 and the string is empty,
- the buffer will be released.
-
- \param[in] n shrink buffer to n bytes, not counting the trailing NUL
- */
-void Fl_String::shrink_(int n) {
-  if (n < size_)
-    n = size_;
-  if (n == capacity_)
-    return;
-  if (n == 0) {
-    if (buffer_)
-      ::free(buffer_);
-    buffer_ = NULL;
-  } else {
-    buffer_ = (char*)::realloc(buffer_, n+1); // NUL
-    buffer_[size_] = 0; // trailing NUL
-  }
-  capacity_ = n;
-}
-
-/**
- Remove \p n_del bytes at \p at and insert \p n_ins bytes from \p src.
-
- String will remain NUL terminated. Data in \p ins may contain NULs.
-
- \param[in] at    remove and insert bytes at this index
- \param[in] n_del number of bytes to remove
- \param[in] ins   insert bytes from here, can be NULL if \p n_ins is also 0
- \param[in] n_ins number of bytes to insert
- \return self
- */
-Fl_String &Fl_String::replace_(int at, int n_del, const char *ins, int n_ins) {
-  if (at > size_) at = size_;
-  if (n_del > size_ - at) n_del = size_ - at;
-  int diff = n_ins - n_del, new_size = size_ + diff;
-  if (diff) {
-    int src = at + n_del, dst = at + n_ins, n = size_ - src;
-    grow_(new_size);
-    if (n > 0) ::memmove(buffer_+dst, buffer_+src, n);
-  }
-  if (n_ins > 0) {
-    ::memmove(buffer_+at, ins, n_ins);
-  }
-  size_ = new_size;
-  if (buffer_)
-    buffer_[size_] = 0;
-  return *this;
-}
-
-
-// ---- Assignment ----------------------------------------------------- MARK: -
-
-/**
- Allocate an empty string.
- */
-Fl_String::Fl_String() {
-  init_();
-}
-
-/**
- Copy constructor.
- \param[in] str copy from another Fl_String
- */
-Fl_String::Fl_String(const Fl_String &str) {
-  init_();
-  assign(str);
-}
-
-/**
- Constructor from a C-style string.
- \param[in] cstr a NUL terminated C-style string
- */
-Fl_String::Fl_String(const char *cstr) {
-  init_();
-  assign(cstr);
-}
-
-/**
- Constructor from data of \p size bytes.
- \param[in] str   a block of data that may contain NUL characters
- \param[in] size  number of bytes to copy
- */
-Fl_String::Fl_String(const char *str, int size) {
-  init_();
-  assign(str, size);
-}
-
-/**
- Destructor.
- */
-Fl_String::~Fl_String() {
-  if (buffer_)
-    ::free(buffer_);
-}
-
-/**
- Copy assignment operator
- \param[in] str copy from another Fl_String
- \return self
- */
-Fl_String &Fl_String::operator=(const Fl_String &str) {
-  return assign(str);
-}
-
-/**
- Assign a C-style string.
- \param[in] cstr a NUL terminated C-style string
- \return self
- */
-Fl_String &Fl_String::operator=(const char *cstr) {
-  return assign(cstr);
-}
-
-/**
- Copy another string.
- \param[in] str copy from another Fl_String
- \return self
- */
-Fl_String &Fl_String::assign(const Fl_String &str) {
-  if (&str == this) return *this;
-  return assign(str.data(), str.size());
-}
-
-/**
- Assign a C-style string.
- \param[in] cstr a NUL terminated C-style string
- \return self
- */
-Fl_String &Fl_String::assign(const char *cstr) {
-  if (cstr && *cstr) {
-    int len = (int)::strlen(cstr);
-    return assign(cstr, len);
-  } else {
-    resize(0);
-  }
-  return *this;
-}
-
-/**
- Assign a data block of \p size bytes.
- \param[in] str a block of data that may contain NUL characters
- \param[in] size number of bytes to copy
- \return self
- */
-Fl_String &Fl_String::assign(const char *str, int size) {
-  if (size > 0) {
-    grow_(size);
-    memcpy(buffer_, str, size);
-    buffer_[size] = 0;
-    size_ = size;
-  } else {
-    resize(0);
-  }
-  return *this;
-}
-
-// ---- Element Access ------------------------------------------------- MARK: -
-
-/**
- Returns the character at specified bounds checked location.
- \param[in] n index of character
- \return character at that index, or NUL if out of bounds
- */
-char Fl_String::at(int n) const {
-  if ((n < 0) || (n >= size_))
-    return 0;
-  return operator[](n);
-}
-
-/**
- Returns the character at specified location.
- \param[in] n index of character
- \return character at that index
- */
-char Fl_String::operator[](int n) const {
-  if (buffer_)
-    return buffer_[n];
-  else
-    return 0;
-}
-
-/**
- Returns a reference to the character at specified location.
- \param[in] n index of character
- \return reference to that character, so it can be used as lvalue
- */
-char &Fl_String::operator[](int n) {
-  if (!buffer_)
-    reserve(1);
-  return buffer_[n];
-}
-
-/**
- Return a pointer to the NUL terminated string.
- \return reference to non-mutable string
- */
-const char *Fl_String::data() const {
-  if (buffer_)
-    return buffer_;
-  else
-    return &NUL;
-}
-
-/**
- Return a pointer to the writable NUL terminated string.
- \return reference to mutable string
- */
-char *Fl_String::data() {
-  if (!buffer_)
-    reserve(1);
-  return buffer_;
-}
-
-/**
- Return a pointer to the NUL terminated string.
-
- \return reference to non-mutable string
-
- \note same as Fl_String::data() const
- */
-const char *Fl_String::c_str() const {
-  return data();
-}
-
-// ---- Capacity ------------------------------------------------------- MARK: -
-
-/**
- Checks if the string is empty.
- \return true if string contains no data
- */
-bool Fl_String::empty() const {
-  return (size_ == 0);
-}
-
-/**
- Returns the number of bytes in the string.
- \return number of bytes in string, not counting trailing NUL
- */
-int Fl_String::size() const {
-  return size_;
-}
-
-/**
- Reserve n bytes for storage.
- If n is less or equal than size, the capacity is set to size.
- \param[in] n requested minimum size, not counting trailing NUL
- */
-void Fl_String::reserve(int n) {
-  grow_(n);
-}
-
-/**
- Return the number of chars that are allocated for storage.
- \return string capacity, not counting trailing NUL
- */
-int Fl_String::capacity() const {
-  return capacity_;
-}
-
-/**
- Shrink the capacity to fit the current size.
- */
-void Fl_String::shrink_to_fit() {
-  shrink_(size_);
-}
-
-// ---- Operations ----------------------------------------------------- MARK: -
-
-/**
- Set an empty string.
- */
-void Fl_String::clear() {
-  resize(0);
-}
-
-/**
- Insert a C-style string or data.
- \param[in] at    insert at this index
- \param[in] src   copy bytes from here
- \param[in] n_ins optional number of bytes to copy - if not set, copy C-style string
- \return self
- */
-Fl_String &Fl_String::insert(int at, const char *src, int n_ins) {
-  if (n_ins == npos) n_ins = src ? (int)::strlen(src) : 0;
-  return replace_(at, 0, src, n_ins);
-}
-
-/**
- Insert another string.
- \param[in] at    insert at this index
- \param[in] src   copy string from here
- \return self
- */
-Fl_String &Fl_String::insert(int at, const Fl_String &src) {
-  return replace_(at, 0, src.buffer_, src.size_);
-}
-
-/**
- Erase some bytes within a string.
- \param[in] at    erase at this index
- \param[in] n_del number of bytes to erase
- \return self
- */
-Fl_String &Fl_String::erase(int at, int n_del) {
-  return replace_(at, n_del, NULL, 0);
-}
-
-/**
- Append a single character.
- \param[in] c append this byte
- */
-void Fl_String::push_back(char c) {
-  replace_(size_, 0, &c, 1);
-}
-
-/**
- Remove the last character.
- */
-void Fl_String::pop_back() {
-  replace_(size_-1, 1, NULL, 0);
-}
-
-/**
- Append a C-style string or data.
- \param[in] src   copy bytes from here
- \param[in] n_ins optional number of bytes to copy - if not set, copy C-style string
- \return self
- */
-Fl_String &Fl_String::append(const char *src, int n_ins) {
-  if (n_ins == npos) n_ins = src ? (int)::strlen(src) : 0;
-  return replace_(size_, 0, src, n_ins);
-}
-
-/**
- Append another string.
- \param[in] src   copy string from here
- \return self
- */
-Fl_String &Fl_String::append(const Fl_String &src) {
-  return replace_(size_, 0, src.buffer_, src.size_);
-}
-
-/**
- Append a single byte.
- \param[in] c single byte character
- \return self
- */
-Fl_String &Fl_String::append(char c) {
-  push_back(c);
-  return *this;
-}
-
-/**
- Append a C-style string or data.
- \param[in] src   copy C-style string from here
- \return self
- */
-Fl_String &Fl_String::operator+=(const char *src) {
-  return append(src);
-}
-
-/**
- Append another string.
- \param[in] src   copy string from here
- \return self
- */
-Fl_String &Fl_String::operator+=(const Fl_String &src) {
-  return append(src);
-}
-
-/**
- Append a single byte.
- \param[in] c single byte character
- \return self
- */
-Fl_String &Fl_String::operator+=(char c) {
-  return append(c);
-}
-
-/**
- Find a string inside this string.
- \param[in] needle    find this string
- \param[in] start_pos start looking at this position
- \return the offset of the text inside this string, if it was found
- \return Fl_String::npos if the needle was not found
- */
-int Fl_String::find(const Fl_String &needle, int start_pos) const {
-  if ((start_pos < 0) || (start_pos >= size_)) return npos;
-  const char *haystack = data() + start_pos;
-  const char *found = strstr(haystack, needle.c_str());
-  if (!found) return npos;
-  return (int)(found - data());
-}
-
-/**
- Replace part of the string with a C-style string or data.
- \param[in] at    erase and insert at this index
- \param[in] n_del number of bytes to erase
- \param[in] src   copy bytes from here
- \param[in] n_ins optional number of bytes to copy - if not set, copy C-style string
- \return self
- */
-Fl_String &Fl_String::replace(int at, int n_del, const char *src, int n_ins) {
-  if (n_ins == npos) n_ins = src ? (int)::strlen(src) : 0;
-  return replace_(at, n_del, src, n_ins);
-}
-
-/**
- Replace part of the string with another string.
- \param[in] at    erase and insert at this index
- \param[in] n_del number of bytes to erase
- \param[in] src   copy string from here
- \return self
- */
-Fl_String &Fl_String::replace(int at, int n_del, const Fl_String &src) {
-  return replace_(at, n_del, src.buffer_, src.size_);
-}
-
-/**
- Return a substring from a string.
- \param[in] pos   copy string from here - if omitted, copy from start
- \param[in] n     number of bytes - if omitted, copy all bytes
- \return a new string
- */
-Fl_String Fl_String::substr(int pos, int n) const {
-  if (n > size_) n = size_;
-  int first = pos, last = pos + n;
-  if ((first < 0) || (first > size_) || (last <= first))
-    return Fl_String();
-  if (last > size_) last = size_;
-  return Fl_String(buffer_+first, last-first);
-}
-
-/**
- Resizes the string to n characters.
-
- If \p n is less than the current size, the string will be cropped. If \p n
- is more than the current size, the new space will be filled with
- NUL characters.
-
- \param[in] n   new size of string
- */
-void Fl_String::resize(int n) {
-  if (n == size_)
-    return;
-  if (n < size_) {
-    size_ = n;
-    if (buffer_) buffer_[size_] = 0;
-  } else {
-    grow_(n);
-    if (buffer_) ::memset(buffer_+size_, 0, n-size_+1);
-  }
-  size_ = n;
-}
-
-// --- Non Standard ---------------------------------------------------- MARK: -
-
-/**
- Returns the number of bytes until the first NUL byte.
- \return number of bytes in C-style string
- */
-int Fl_String::strlen() const {
-  if (!buffer_) return 0;
-  return (int)::strlen(buffer_);
-}
-
-/**
-  Write some details about the string to stdout.
-
-  Nothing at all is written if \p info is NULL, otherwise the short info
-  string and details are written to stdout.
-
-  The \p info string should not be longer than 20 characters to align the
-  debug output of several strings.
-
-  \param[in]  info  short info string or NULL
-*/
-void Fl_String::debug(const char *info) const {
-  if (info) {
-    printf("Fl_String '%-20s': %p, value = %p (%d/%d):\n%s\n",
-           info, this, buffer_, size_, capacity_, buffer_ ? buffer_ : "<NULL>");
-  }
-}
-
-/**
-  Write some details about the string to stdout, followed by a hex dump of
-  the string.
-
-  The first part is the same as written by Fl_String::debug(). The following
-  part is a hexadecimal dump of all bytes of the string. Embedded \p nul bytes
-  are possible and will be dumped as well.
-
-  \param[in]  info  short info string or NULL
-
-  \see Fl_String::debug(const char *info) const
-*/
-void Fl_String::hexdump(const char *info) const {
-  debug(info);
-  if (size_ == 0)
-    return;
-  for (int i = 0; i < size_; i++) {
-    if ((i & 15) == 0) {
-      if (i > 0)
-        printf("\n");
-      printf("  [%04x %4d] ", i, i);  // position
-    } else if ((i & 3) == 0) {        // separator after 4 bytes
-      printf(" ");
-    }
-    printf(" %02x", (unsigned char)buffer_[i]);
-  }
-  printf("\n");
-}
-
-// ---- Non-member functions ------------------------------------------- MARK: -
-
-/**
- Concatenate two strings.
- \param[in] lhs first string
- \param[in] rhs second string
- \return self
- */
-Fl_String operator+(const Fl_String &lhs, const Fl_String &rhs) {
-  Fl_String ret = lhs;
-  return ret += rhs;
-}
-
-/**
- Concatenate two strings.
- \param[in] lhs first string
- \param[in] rhs second C-style string
- \return self
- */
-Fl_String operator+(const Fl_String &lhs, const char *rhs) {
-  Fl_String ret = lhs;
-  return ret += rhs;
-}
-
-/**
- Compare two strings.
- \param[in] lhs first string
- \param[in] rhs second string
- \return true if strings are the same size and have the same content
- */
-bool operator==(const Fl_String &lhs, const Fl_String &rhs) {
-  if (lhs.size() == rhs.size()) {
-    int sz = lhs.size();
-    if (sz == 0) return true;
-    if (memcmp(lhs.data(), rhs.data(), sz) == 0) return true;
-  }
-  return false;
-}
-
-/**
- Compare two strings for inequality.
- \param[in] lhs first string
- \param[in] rhs second string
- \return true if strings differ in size or content
- */
-bool operator!=(const Fl_String &lhs, const Fl_String &rhs) {
-  if (lhs.size() != rhs.size()) return true;
-  int sz = lhs.size();  // same size for both
-  if (memcmp(lhs.data(), rhs.data(), sz) != 0) return true;
-  return false;
-}
-
-/**
-\}
-\endcond
-*/
-
-#endif