Stars of Shareware: Programmierung/SOURCE.mdf/programm/msdos/pascal/rehack/contain/strings.cpp

C/C++ Source or Header | 1993-06-21 | 6.2 KB | 301 lines

// ╔════════════════════════════════════════════════╗
// ║ Strings.Cpp                                    ║
// ╟────────────────────────────────────────────────╢
// ║ String unit for C++                            ║
// ╟────────────────────────────────────────────────╢
// ║ Written 11/06/90 by Gus Smedstad               ║
// ║   based on examples for Borland                ║
// ╟────────────────────────────────────────────────╢
// ║ Revised 11/18/90 by Gus Smedstad               ║
// ║   Added str, str_long, system_date/time        ║
// ╟────────────────────────────────────────────────╢
// ║ Copyright 1990 NoGate Consulting               ║
// ╚════════════════════════════════════════════════╝

#include <dos.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>

#include "strings.h"

string::string()
 {
  length = 0;
  char_ptr = new char;
  assert(FP_SEG(char_ptr) > 100);
  assert(FP_SEG(char_ptr) < 0xA000);
  *char_ptr = 0;
 };

string::string(char text)
 {
  length = 1;
  char_ptr = new char[2];
  assert(FP_SEG(char_ptr) > 100);
  assert(FP_SEG(char_ptr) < 0xA000);
  char_ptr[0] = text;
  char_ptr[1] = 0;
 };

string::string (char *text)
 {
   length = strlen(text);  // get length of text
   char_ptr = new char[length + 1];
   assert(FP_SEG(char_ptr) > 100);
   assert(FP_SEG(char_ptr) < 0xA000);
   strcpy(char_ptr, text);
};

string::string (int size)
{
   length = size;
   char_ptr = new char[length+1];
   assert(FP_SEG(char_ptr) > 100);
   assert(FP_SEG(char_ptr) < 0xA000);
   *char_ptr = '\0';
};

string::~string()
 {
  assert(FP_SEG(char_ptr) > 100);
  assert(FP_SEG(char_ptr) < 0xA000);
  delete char_ptr;
 }

string::string (string& source)
{
   length = source.length;       // length of other string
   char_ptr = new char [length + 1];   // allocate the memory
   assert(FP_SEG(char_ptr) > 100);
   assert(FP_SEG(char_ptr) < 0xA000);
   strcpy (char_ptr, source.char_ptr); // copy the text
};

string string::operator+ (string& arg)
{
  string temp( length + arg.length );
  strcpy(temp.char_ptr, char_ptr);
  strcat(temp.char_ptr, arg.char_ptr);
  return temp;
}

string string::operator+ (char *text)
{
  return (*this + str(text));
}


string string::operator+ (char text)
 {
  return (*this + str(text));
 }

string& string::operator= (string& arg)
 {
  if (length < arg.length) {
    assert(FP_SEG(char_ptr) > 10);
    assert(FP_SEG(char_ptr) < 0xA000);
    delete char_ptr;
    length = arg.length;
    char_ptr = new char[length + 1];
    assert(FP_SEG(char_ptr) > 100);
    assert(FP_SEG(char_ptr) < 0xA000);
   }
  strcpy(char_ptr, arg.char_ptr);
  return *this;
 }

string& string::operator= (char *text)
 {
  return (*this = str(text));
 }

string& string::operator= (char text)
 {
  return (*this = str(text));
 }

string& string::operator+= (string& arg)
 {
  if (strlen(char_ptr) + arg.length > length) {
    string temp(*this);
    return (*this = temp + arg);
   } else {
    strcat(char_ptr, arg.char_ptr);
    return (*this);
   }
 }

string& string::operator+= (char *text)
 {
  return (*this += str(text));
 }

string& string::operator+= (char text)
 {
  return (*this += str(text));
 }

string string::copy(int start, int chars)
 {
  if (chars < 0)
    chars = 0;
  string result(chars);
  if (start > strlen(char_ptr))
    *result.char_ptr = 0;
   else {
    memcpy(result.char_ptr, char_ptr + start, chars);
    result.char_ptr[chars] = 0;
   }
  return result;
 }

void string::insert(int x, char *arg)
 {
  *this = copy(0, x) + arg + copy(x, length - x);
 }

void string::insert(int x, char arg)
 {
  *this = copy(0, x) + arg + copy(x, length - x);
 }

void string::remove(int start, int chars)
 {
  *this = copy(0, start) + copy(start + chars, length - start - chars);
 }

//int string::operator== (const string& arg) const
// {
//  return strcmp(char_ptr, arg.char_ptr) == 0;
// };

//int string::operator== (const char *arg) const
// {
//  string temp = arg;
//  return *this == temp;
// }

string chop(char *text, int length)
 {
  string temp(length + 1);
  memcpy(temp.value(), text, length);
  temp.value()[length] = 0;
  return temp;
 }

string str(char arg)
 {
  string temp(arg);
  return temp;
 }

string str(char *arg)
 {
  string temp(arg);
  return temp;
 }

string str_long(long arg, int width, int leading_zeroes)
 {
  string temp;
  char   buffer[30];

  if (width) {
    if (width > sizeof(buffer) - 1)
      width = sizeof(buffer) - 1;
    if (leading_zeroes)
      sprintf(buffer, "%0*li", width, arg);
     else
      sprintf(buffer, "%*li",width, arg);
   } else {
    sprintf(buffer, "%li", arg);
   }
  return temp = buffer;
 }

string system_date()
 {
  date sys_date;

  getdate(&sys_date);
  return str_long(sys_date.da_mon,2)+'-'+
         str_long(sys_date.da_day,2,1)+'-'+
         str_long(sys_date.da_year % 100,2,1);
 }

string system_time()
 {
  struct time sys_time;
  gettime(&sys_time);
  return str_long(sys_time.ti_hour,2)+':'+
         str_long(sys_time.ti_min,2,1);
 }

void delete_trailing_spaces(char *line)
 {
  int  i;

  i = strlen(line) - 1;
  while (i >= 0 && line[i] == ' ') i--;
  line[i+1] = 0;
 }

void delete_chars(char *line, int n)
 {
  char *pt;
  int  i;

  if ((i = strlen(line)) < n)
    n = i;
  pt = line + n;
  while ((*line++ = *pt++) > 0) ;
 }

void delete_leading_spaces(char *line)
 {
  char *pt;

  pt = line;
  while (*pt == ' ') pt++;
  while ((*line++ = *pt++) > 0) ;
 }

string rep_str(int width, char c)
 {
  string temp(width);
  memset(temp.value(), c, width);
  temp.value()[width] = 0;
  return temp;
 }

string ljust(char *arg, int width, char c)
 {
  int change;
  string temp;

  if ((change = width - strlen(arg)) <= 0) {
    temp = arg;
    temp.value()[width] = 0;
   } else {
    temp = str(arg) + rep_str(change, c);
   }
  return temp;
 }

string rjust(char *arg, int width, char c)
 {
  int change;
  string temp;

  if ((change = width - strlen(arg)) <= 0) {
    temp = arg;
    temp.value()[width] = 0;
   } else {
    temp = rep_str(change, c) + arg;
   }
  return temp;
 }