+++ /dev/null
-/*
-* Name : astring
-* Author : Chris Koeritz
-**
-* Copyright (c) 1992-$now By Author. This program is free software; you can *
-* redistribute it and/or modify it under the terms of the GNU General Public *
-* License as published by the Free Software Foundation; either version 2 of *
-* the License or (at your option) any later version. This is online at: *
-* http://www.fsf.org/copyleft/gpl.html *
-* Please send any updates to: fred@gruntose.com *
-*/
-
-#include "astring.h"
-#include "definitions.h"
-#include "functions.h"
-#include "guards.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef __WIN32__
- #undef strcasecmp
- #undef strncasecmp
- #define strcasecmp strcmpi
- #define strncasecmp strnicmp
-#endif
-
-//#define DEBUG_STRING
- // uncomment for debugging version.
-
-#define no_increment
- // macro just documents a blank parameter in the code.
-
-namespace basis {
-
-const int LONGEST_SPRINTF = 600; // the longest a simple sprintf can be here.
-
-const char CASE_DIFFERENCE = char('A' - 'a');
- // the measurement of the difference between upper and lower case.
-
-// this factor is used to bias dynamic sprintfs for cases where the length
-// is specified, but the actual string is shorter than that length.
-const int MAX_FIELD_FUDGE_FACTOR = 64;
-
-const abyte empty_char_star[] = { 0 };
- // used to initialize empty strings.
-
-//////////////
-
-bool astring_comparator(const astring &a, const astring &b) { return a.equal_to(b); }
-
-int calculate_proper_length(int repeat) { return negative(repeat)? 1 : repeat + 1; }
-
-//////////////
-
-astring::astring()
-: c_character_manager(1, empty_char_star),
- c_held_string((char * const *)c_character_manager.internal_offset_mem())
-{}
-
-astring::astring(const base_string &initial)
-: c_character_manager(strlen(initial.observe()) + 1, (abyte *)initial.observe()),
- c_held_string((char * const *)c_character_manager.internal_offset_mem())
-{}
-
-astring::astring(char initial, int repeat)
-: c_character_manager(calculate_proper_length(repeat))
-{
- if (!initial) initial = ' '; // for nulls, we use spaces.
- int new_size = c_character_manager.length() - 1;
- memset(c_character_manager.access(), initial, new_size);
- c_character_manager.put(new_size, '\0');
- c_held_string = (char * const *)c_character_manager.internal_offset_mem();
-}
-
-astring::astring(const astring &s1)
-: base_string(),
- c_character_manager(s1.c_character_manager),
- c_held_string((char * const *)c_character_manager.internal_offset_mem())
-{
-}
-
-astring::astring(const char *initial)
-: c_character_manager(calculate_proper_length(initial? int(strlen(initial)) : 0))
-{
- c_character_manager.put(0, '\0');
- if (!initial) return; // bail because there's no string to copy.
- strcpy(access(), initial);
- c_held_string = (char * const *)c_character_manager.internal_offset_mem();
-}
-
-astring::astring(special_flag flag, const char *initial, ...)
-: c_character_manager(1, empty_char_star),
- c_held_string((char * const *)c_character_manager.internal_offset_mem())
-{
- if (!initial) return;
- if ( (flag != UNTERMINATED) && (flag != SPRINTF) ) {
- operator = (astring(astring::SPRINTF, "unknown flag %d", flag));
- return;
- }
-
- va_list args;
- va_start(args, initial);
-
- if (flag == UNTERMINATED) {
- // special process for grabbing a string that has no terminating nil.
- int length = va_arg(args, int); // get the length of the string out.
- c_character_manager.reset(length, (abyte *)initial);
- c_character_manager += abyte(0);
- va_end(args);
- return;
- }
-
- // only other flag currently supported is sprintf, so we do that...
- base_sprintf(initial, args);
- va_end(args);
-}
-
-astring::~astring() { c_held_string = NIL; }
-
-const astring &astring::empty_string() { return bogonic<astring>(); }
-
-void astring::text_form(base_string &state_fill) const { state_fill.assign(*this); }
-
-int astring::length() const { return c_character_manager.length() - 1; }
-
-byte_array &astring::get_implementation() { return c_character_manager; }
-
-char *astring::access() { return (char *)c_character_manager.access(); }
-
-char astring::get(int index) const { return (char)c_character_manager.get(index); }
-
-const char *astring::observe() const
-{ return (const char *)c_character_manager.observe(); }
-
-bool astring::equal_to(const equalizable &s2) const
-{
- const astring *s2_cast = cast_or_throw(s2, *this);
- return comparator(*s2_cast) == 0;
-}
-
-bool astring::less_than(const orderable &s2) const
-{
- const astring *s2_cast = dynamic_cast<const astring *>(&s2);
- if (!s2_cast) throw "error: astring::<: unknown type";
- return comparator(*s2_cast) < 0;
-}
-
-int astring::comparator(const astring &s2) const
-{ return strcmp(observe(), s2.observe()); }
-
-bool astring::equal_to(const char *that) const
-{ return strcmp(observe(), that) == 0; }
-
-bool astring::contains(const astring &to_find) const
-{ return (find(to_find, 0) < 0) ? false : true; }
-
-astring &astring::operator += (const astring &s1)
-{ insert(length(), s1); return *this; }
-
-void astring::shrink()
-{
- astring copy_of_this(observe());
- c_character_manager.swap_contents(copy_of_this.c_character_manager);
-}
-
-astring &astring::sprintf(const char *initial, ...)
-{
- va_list args;
- va_start(args, initial);
- astring &to_return = base_sprintf(initial, args);
- va_end(args);
- return to_return;
-}
-
-astring &astring::base_sprintf(const char *initial, va_list &args)
-{
- reset();
- if (!initial) return *this; // skip null strings.
- if (!initial[0]) return *this; // skip empty strings.
-
- // these accumulate parts of the sprintf format within the loop.
- char flag_chars[23], width_chars[23], precision_chars[23], modifier_chars[23];
-
- // thanks for the inspiration to k&r page 156.
- for (const char *traverser = initial; *traverser; traverser++) {
-#ifdef DEBUG_STRING
- printf("index=%d, char=%c\n", traverser - initial, *traverser);
-#endif
-
- if (*traverser != '%') {
- // not a special character, so just drop it in.
- *this += *traverser;
- continue;
- }
- traverser++; // go to the next character.
-#ifdef DEBUG_STRING
- printf("index=%d, char=%c\n", traverser - initial, *traverser);
-#endif
- if (*traverser == '%') {
- // capture the "%%" style format specifier.
- *this += *traverser;
- continue;
- }
- bool failure = false;
- // becomes set to true if something didn't match in a necessary area.
-
- seek_flag(traverser, flag_chars, failure);
- if (failure) {
- *this += '%';
- *this += flag_chars;
- continue;
- }
- seek_width(traverser, width_chars);
- seek_precision(traverser, precision_chars);
- seek_modifier(traverser, modifier_chars);
- get_type_character(traverser, args, *this, flag_chars,
- width_chars, precision_chars, modifier_chars);
- }
- return *this;
-}
-
-void astring::seek_flag(const char *&traverser, char *flag_chars, bool &failure)
-{
- flag_chars[0] = '\0';
- failure = false;
- bool keep_going = true;
- while (!failure && keep_going) {
- switch (*traverser) {
- case '-': case '+': case ' ': case '\011': case '#':
- flag_chars[strlen(flag_chars) + 1] = '\0';
- flag_chars[strlen(flag_chars)] = *traverser++;
- break;
- default:
- // we found a character that doesn't belong in the flags.
- keep_going = false;
- break;
- }
- }
-#ifdef DEBUG_STRING
- if (strlen(flag_chars)) printf("[flag=%s]\n", flag_chars);
- else printf("no flags\n");
-#endif
-}
-
-void astring::seek_width(const char *&traverser, char *width_chars)
-{
- width_chars[0] = '\0';
- bool no_more_nums = false;
- bool first_num = true;
- while (!no_more_nums) {
- char wideness[2] = { *traverser, '\0' };
- if (first_num && (wideness[0] == '0')) {
- strcpy(width_chars, wideness);
- traverser++;
- } else if (first_num && (wideness[0] == '*') ) {
- strcpy(width_chars, wideness);
- traverser++;
- no_more_nums = true;
- } else if ( (wideness[0] <= '9') && (wideness[0] >= '0') ) {
- // a failure?
- strcat(width_chars, wideness);
- traverser++;
- } else no_more_nums = true;
- first_num = false;
- }
-#ifdef DEBUG_STRING
- if (strlen(width_chars)) printf("[width=%s]\n", width_chars);
- else printf("no widths\n");
-#endif
-}
-
-void astring::seek_precision(const char *&traverser, char *precision_chars)
-{
- precision_chars[0] = '\0';
- if (*traverser != '.') return;
- strcpy(precision_chars, ".");
- traverser++;
- bool no_more_nums = false;
- bool first_num = true;
- while (!no_more_nums) {
- char preciseness[2] = { *traverser, '\0' };
- if (first_num && (preciseness[0] == '0')) {
- strcat(precision_chars, preciseness);
- traverser++;
- no_more_nums = true;
- } else if (first_num && (preciseness[0] == '*') ) {
- strcat(precision_chars, preciseness);
- traverser++;
- no_more_nums = true;
- } else if ( (preciseness[0] <= '9') && (preciseness[0] >= '0') ) {
- strcat(precision_chars, preciseness);
- traverser++;
- } else no_more_nums = true;
- first_num = false;
- }
-#ifdef DEBUG_STRING
- if (strlen(precision_chars)) printf("[precis=%s]\n", precision_chars);
- else printf("no precision\n");
-#endif
-}
-
-void astring::seek_modifier(const char *&traverser, char *modifier_chars)
-{
- modifier_chars[0] = '\0';
- switch (*traverser) {
- case 'F': case 'N': case 'h': case 'l': case 'L': {
- modifier_chars[strlen(modifier_chars) + 1] = '\0';
- modifier_chars[strlen(modifier_chars)] = *traverser++;
- break;
- }
- }
-#ifdef DEBUG_STRING
- if (strlen(modifier_chars)) printf("[mod=%s]\n", modifier_chars);
- else printf("no modifiers\n");
-#endif
-}
-
-void astring::get_type_character(const char * &traverser, va_list &args,
- astring &output_string, const char *flag_chars, const char *width_chars,
- const char *precision_chars, const char *modifier_chars)
-{
- char formatting[120];
- strcpy(formatting, "%");
- strcat(formatting, flag_chars);
- strcat(formatting, width_chars);
- strcat(formatting, precision_chars);
- strcat(formatting, modifier_chars);
- char tmposh[2] = { *traverser, '\0' };
- strcat(formatting, tmposh);
-#ifdef DEBUG_STRING
- printf("format: %s\n", formatting);
-#endif
-
- enum argument_size { bits_8, bits_16, bits_32, bits_64, bits_80 };
- bool ints_are_32_bits;
-#ifdef __WIN32__
- ints_are_32_bits = true;
-#elif defined(__OS2__)
- ints_are_32_bits = true;
-#elif defined(__MSDOS__)
- ints_are_32_bits = false;
-#elif defined(__WIN32__)
- ints_are_32_bits = false;
-#else
- ints_are_32_bits = true;
-#endif
- argument_size next_argument;
- bool use_dynamic_sprintf = false; // for dynamic printing of strings only.
- // get the type character first and ensure it's valid.
- switch (*traverser) {
- case 'd': case 'i': case 'o': case 'u': case 'x': case 'X':
- next_argument = bits_16;
- if (ints_are_32_bits) next_argument = bits_32;
- break;
- case 'f': case 'e': case 'g': case 'E': case 'G':
- next_argument = bits_64;
- break;
- case 'c':
- next_argument = bits_8;
- break;
- case 's':
- next_argument = bits_32;
- use_dynamic_sprintf = true;
- break;
- case 'n':
- next_argument = bits_32; //?????
- break;
- case 'p':
- next_argument = bits_32; //????
- break;
- default:
- // this is an error; the character is not recognized, so spew out
- // any characters accumulated so far as just themselves.
-#ifdef DEBUG_STRING
- printf("failure in type char: %c\n", *traverser);
-#endif
- output_string += formatting;
- return;
- }
-/* hmmm: not supported yet.
- if (width_chars && (width_chars[0] == '*')) {
- }
- if (precision_chars && (precision_chars[0] == '*')) {
- }
-*/
- if (strlen(modifier_chars)) {
- switch (modifier_chars[0]) {
- case 'N': // near pointer.
- next_argument = bits_16;
- if (ints_are_32_bits) next_argument = bits_32;
- break;
- case 'F': // far pointer.
- next_argument = bits_32;
- break;
- case 'h': // short int.
- next_argument = bits_16;
- break;
- case 'l': // long.
- next_argument = bits_32;
- break;
- case 'L': // long double;
- next_argument = bits_80;
- break;
- default:
- // a failure has occurred because the modifier character is not
- // one of the recognized values. everything is just spewed out.
-#ifdef DEBUG_STRING
- printf("failure in modifier: %s\n", modifier_chars);
-#endif
- output_string += formatting;
- return;
- }
- }
- // action time: the output string is given a tasty value.
- char temp[LONGEST_SPRINTF];
- char *temp2 = NIL; // for dynamic only.
- switch (next_argument) {
-//hmmm: this switch is where support would need to be added for having two
-// arguments (for the '*' case).
- case bits_8: case bits_16:
- if (ints_are_32_bits) ::sprintf(temp, formatting, va_arg(args, long));
- else ::sprintf(temp, formatting, va_arg(args, int));
- break;
- case bits_32:
- if (use_dynamic_sprintf) {
- // currently we only do dynamic sprintf for strings.
- char *to_print = va_arg(args, char *);
- // check if it's valid and if we really need to do it dynamically.
- if (!to_print) {
- // bogus string; put in a complaint.
- use_dynamic_sprintf = false;
- ::sprintf(temp, "{error:parm=NIL}");
- } else if (strlen(to_print) < LONGEST_SPRINTF - 2) {
- // we're within our bounds, plus some safety room, so just do a
- // regular sprintf.
- use_dynamic_sprintf = false;
- ::sprintf(temp, formatting, to_print);
- } else {
- // it's too long, so we definitely need to do it dynamically.
- temp2 = new char[strlen(to_print) + MAX_FIELD_FUDGE_FACTOR];
- ::sprintf(temp2, formatting, to_print);
- }
- } else ::sprintf(temp, formatting, va_arg(args, void *));
- break;
- case bits_64:
- ::sprintf(temp, formatting, va_arg(args, double));
- break;
- case bits_80:
- ::sprintf(temp, formatting, va_arg(args, long double));
- break;
- }
- if (use_dynamic_sprintf) {
- output_string += temp2;
- delete [] temp2;
- } else output_string += temp;
-}
-
-//hmmm: de-redundify this function, which is identical to the constructor.
-void astring::reset(special_flag flag, const char *initial, ...)
-{
- reset(); // clear the string out.
- if (!initial) return;
- if ( (flag != UNTERMINATED) && (flag != SPRINTF) ) {
- operator = (astring(astring::SPRINTF, "unknown flag %d", flag));
- return;
- }
-
- va_list args;
- va_start(args, initial);
-
- if (flag == UNTERMINATED) {
- // special process for grabbing a string that has no terminating nil.
- int length = va_arg(args, int); // get the length of the string out.
- c_character_manager.reset(length, (abyte *)initial);
- c_character_manager += abyte(0);
- va_end(args);
- return;
- }
-
- // only other flag currently supported is sprintf, so we do that...
- base_sprintf(initial, args);
- va_end(args);
-}
-
-void astring::pad(int len, char padding)
-{
- if (length() >= len) return;
- byte_array pad(len - length());
- memset(pad.access(), padding, pad.length());
- operator += (astring(UNTERMINATED, (char *)pad.observe(), pad.length()));
-}
-
-void astring::trim(int len)
-{
- if (length() <= len) return;
- zap(len, end());
-}
-
-astring &astring::operator = (const astring &s1)
-{
- if (this != &s1)
- c_character_manager = s1.c_character_manager;
- return *this;
-}
-
-astring &astring::operator = (const char *s1)
-{
- reset();
- *this += s1;
- return *this;
-}
-
-void astring::zap(int position1, int position2)
-{
- bounds_return(position1, 0, end(), );
- bounds_return(position2, 0, end(), );
- c_character_manager.zap(position1, position2);
-}
-
-void astring::to_lower()
-{
- for (int i = 0; i < length(); i++)
- if ( (get(i) >= 'A') && (get(i) <= 'Z') )
- c_character_manager.put(i, char(get(i) - CASE_DIFFERENCE));
-}
-
-void astring::to_upper()
-{
- for (int i = 0; i < length(); i++)
- if ( (get(i) >= 'a') && (get(i) <= 'z') )
- c_character_manager.put(i, char(get(i) + CASE_DIFFERENCE));
-}
-
-astring astring::lower() const
-{
- astring to_return(*this);
- to_return.to_lower();
- return to_return;
-}
-
-astring astring::upper() const
-{
- astring to_return(*this);
- to_return.to_upper();
- return to_return;
-}
-
-void astring::copy(char *array_to_stuff, int how_many) const
-{
- if (!array_to_stuff) return;
- array_to_stuff[0] = '\0';
- if ( (how_many <= 0) || (length() <= 0) ) return;
- strncpy(array_to_stuff, observe(), minimum(how_many, int(length())));
- array_to_stuff[minimum(how_many, int(length()))] = '\0';
-}
-
-bool astring::iequals(const astring &that) const
-{ return strcasecmp(observe(), that.observe()) == 0; }
-
-bool astring::iequals(const char *that) const
-{ return strcasecmp(observe(), that) == 0; }
-
-int astring::ifind(char to_find, int position, bool reverse) const
-{ return char_find(to_find, position, reverse, false); }
-
-int astring::find(char to_find, int position, bool reverse) const
-{ return char_find(to_find, position, reverse, true); }
-
-int astring::find_any(const char *to_find, int position, bool reverse) const
-{ return char_find_any(to_find, position, reverse, true); }
-
-int astring::ifind_any(const char *to_find, int position, bool reverse) const
-{ return char_find_any(to_find, position, reverse, false); }
-
-int astring::find_non_match(const char *to_find, int position,
- bool reverse) const
-{ return char_find_any(to_find, position, reverse, false, true); }
-
-char simple_lower(char input)
-{
- if ( (input <= 'Z') && (input >= 'A') ) return input - CASE_DIFFERENCE;
- return input;
-}
-
-int astring::char_find(char to_find, int position, bool reverse,
- bool case_sense) const
-{
- if (position < 0) return common::OUT_OF_RANGE;
- if (position > end()) return common::OUT_OF_RANGE;
- if (reverse) {
- for (int i = position; i >= 0; i--) {
- if (case_sense && (get(i) == to_find)) return i;
- else if (simple_lower(get(i)) == simple_lower(to_find)) return i;
- }
- } else {
- if (case_sense) {
- const char *const pos = strchr(observe() + position, to_find);
- if (pos) return int(pos - observe());
- } else {
- for (int i = position; i < length(); i++)
- if (simple_lower(get(i)) == simple_lower(to_find)) return i;
- }
- }
- return common::NOT_FOUND;
-}
-
-bool imatches_any(char to_check, const astring &list)
-{
- for (int i = 0; i < list.length(); i++)
- if (simple_lower(to_check) == simple_lower(list[i])) return true;
- return false;
-}
-
-bool matches_any(char to_check, const astring &list)
-{
- for (int i = 0; i < list.length(); i++)
- if (to_check == list[i]) return true;
- return false;
-}
-
-bool matches_none(char to_check, const astring &list)
-{
- bool saw_match = false;
- for (int i = 0; i < list.length(); i++)
- if (to_check == list[i]) {
- saw_match = true;
- break;
- }
- return !saw_match;
-}
-
-int astring::char_find_any(const astring &to_find, int position, bool reverse,
- bool case_sense, bool invert_find) const
-{
- if (position < 0) return common::OUT_OF_RANGE;
- if (position > end()) return common::OUT_OF_RANGE;
- if (reverse) {
- for (int i = position; i >= 0; i--) {
- if (!invert_find) {
- if (case_sense && matches_any(get(i), to_find)) return i;
- else if (imatches_any(get(i), to_find)) return i;
- } else {
-//printf("rev posn=%d char=%c", i, get(i));
- // case-sensitivity is not used for inverted finds.
- if (matches_none(get(i), to_find)) return i;
- }
- }
- } else {
- for (int i = position; i < length(); i++) {
- if (!invert_find) {
- if (case_sense && matches_any(get(i), to_find)) return i;
- else if (imatches_any(get(i), to_find)) return i;
- } else {
- // case-sensitivity is not used for inverted finds.
-//printf("fwd posn=%d char=%c", i, get(i));
- if (matches_none(get(i), to_find)) return i;
- }
- }
- }
- return common::NOT_FOUND;
-}
-
-int astring::find(const astring &to_find, int posn, bool reverse) const
-{ return str_find(to_find, posn, reverse, true); }
-
-int astring::ifind(const astring &to_find, int posn, bool reverse) const
-{ return str_find(to_find, posn, reverse, false); }
-
-int astring::str_find(const astring &to_find, int posn, bool reverse,
- bool case_sense) const
-{
- bounds_return(posn, 0, end(), common::OUT_OF_RANGE);
- if (!to_find.length()) return common::BAD_INPUT;
-
- // skip some steps by finding the first place that the first character of
- // the string resides in our string.
- if (case_sense)
- posn = find(to_find[0], posn, reverse);
- else posn = ifind(to_find[0], posn, reverse);
- if (posn < 0) return common::NOT_FOUND;
-
-//hmmm: there is a better way to do this loop in terms of the number of
-// comparisons performed. knuth morris pratt algorithm?
- if (case_sense) {
-//hmmm: this could use strncmp too?
- if (reverse) {
- if (posn > length() - to_find.length())
- posn = length() - to_find.length();
- for (int i = posn; i >= 0; i--)
- if (!memcmp((void *)&observe()[i], (void *)to_find.observe(),
- to_find.length()))
- return i;
- } else {
- const int find_len = to_find.length();
- const int str_len = length();
- const char first_char = to_find[0];
- bounds_return(posn, 0, str_len - find_len, common::OUT_OF_RANGE);
- for (int i = posn - 1;
- ( ( (i = find(first_char, i + 1)) >= 0)
- && (str_len - i >= find_len) ); no_increment) {
- if (!memcmp((void *)&observe()[i], (void *)to_find.observe(),
- to_find.length()))
- return i;
- }
- }
- } else {
- // not case-sensitive.
- if (reverse) {
- if (posn > length() - to_find.length())
- posn = length() - to_find.length();
- for (int i = posn; i >= 0; i--)
- if (!strncasecmp(&observe()[i], to_find.observe(), to_find.length()))
- return i;
- } else {
- bounds_return(posn, 0, length() - to_find.length(), common::OUT_OF_RANGE);
- for (int i = posn; i < length() - to_find.length() + 1; i++)
- if (!strncasecmp(&observe()[i], to_find.observe(), to_find.length()))
- return i;
- }
- }
- return common::NOT_FOUND;
-}
-
-astring astring::operator + (const astring &s1) const
-{
- astring to_return(*this);
- to_return += s1;
- return to_return;
-}
-
-char &astring::operator [] (int position)
-{
- if (position < 0) position = 0;
- if (position > end()) position = 0;
- abyte &found = c_character_manager.use(position);
- char &to_return = *((char *)(&found));
- return to_return;
-}
-
-const char &astring::operator [] (int position) const
-{
- if (position < 0) position = 0;
- if (position > end()) position = 0;
- const abyte &found = c_character_manager.get(position);
- const char &to_return = *((const char *)(&found));
- return to_return;
-}
-
-int astring::convert(int default_value) const
-{
- if (!length()) return default_value;
- int to_return;
- int fields = sscanf(observe(), "%d", &to_return);
- if (fields < 1) return default_value;
- return to_return;
-}
-
-long astring::convert(long default_value) const
-{
- if (!length()) return default_value;
- long to_return;
- int fields = sscanf(observe(), "%ld", &to_return);
- if (fields < 1) return default_value;
- return to_return;
-}
-
-float astring::convert(float default_value) const
-{
- if (!length()) return default_value;
- float to_return;
- int fields = sscanf(observe(), "%f", &to_return);
- if (fields < 1) return default_value;
- return to_return;
-}
-
-double astring::convert(double default_value) const
-{
- if (!length()) return default_value;
- double to_return;
- int fields = sscanf(observe(), "%lf", &to_return);
- if (fields < 1) return default_value;
- return to_return;
-}
-
-astring &astring::operator += (const char *s1)
-{
- if (!s1) return *this;
- int len = length();
- c_character_manager.insert(len, int(strlen(s1)));
- memmove((char *)&c_character_manager[len], s1, int(strlen(s1)));
- return *this;
-}
-
-astring &astring::operator += (char s1)
-{
- int len = length();
- c_character_manager.insert(len, 1);
- c_character_manager.put(len, s1);
- return *this;
-}
-
-bool astring::compare(const astring &to_compare, int start_first,
- int start_second, int count, bool case_sensitive) const
-{
- bounds_return(start_first, 0, end(), false);
- bounds_return(start_second, 0, to_compare.end(), false);
- bounds_return(start_first + count, start_first, length(), false);
- bounds_return(start_second + count, start_second, to_compare.length(), false);
-
- if (!case_sensitive) {
- return !strncasecmp(&observe()[start_first],
- &to_compare.observe()[start_second], count);
- } else {
- return !memcmp((void *)&observe()[start_first],
- (void *)&to_compare.observe()[start_second], count);
- }
-}
-
-/*
-int astring::icompare(const char *to_compare, int length_in) const
-{
- if (!length_in) return 0; // nothing is equal to nothing.
- int real_len = length_in;
- // if they're passing a negative length, we use the full length.
- if (negative(length_in))
- real_len = length();
- // if we have no length, make the obvious returns now.
- int to_compare_len = int(strlen(to_compare));
- if (!real_len) return to_compare_len? -1 : 0;
- // if the second string is empty, it's always less than the non-empty.
- if (!to_compare_len) return 1;
- int to_return = strncasecmp(observe(), to_compare, real_len);
- if (negative(length_in) && !to_return && (to_compare_len > length()) ) {
- // catch special case for default length when the two are equal except
- // that the second string is longer--this means the first is less than
- // second, not equal.
- return -1;
- } else
- return to_return;
-}
-*/
-
-/*
-bool astring::oy_icompare(const astring &to_compare, int start_first,
- int start_second, int count) const
-{
- bounds_return(start_first, 0, end(), false);
- bounds_return(start_second, 0, to_compare.end(), false);
- bounds_return(start_first + count, start_first, length(), false);
- bounds_return(start_second + count, start_second, to_compare.length(), false);
- const char *actual_first = this->observe() + start_first;
- const char *actual_second = to_compare.observe() + start_second;
- return !strncasecmp(actual_first, actual_second, count);
-}
-*/
-
-bool astring::substring(astring &target, int start, int bender) const
-{
- target.reset();
- if (bender < start) return false;
- const int last = end(); // final position that's valid in the string.
- bounds_return(start, 0, last, false);
- bounds_return(bender, 0, last, false);
- target.reset(UNTERMINATED, observe() + start, bender - start + 1);
- return true;
-}
-
-astring astring::substring(int start, int end) const
-{
- astring to_return;
- substring(to_return, start, end);
- return to_return;
-}
-
-astring astring::middle(int start, int count)
-{ return substring(start, start + count - 1); }
-
-astring astring::left(int count)
-{ return substring(0, count - 1); }
-
-astring astring::right(int count)
-{ return substring(end() - count + 1, end()); }
-
-void astring::insert(int position, const astring &to_insert)
-{
- bounds_return(position, 0, length(), );
- if (this == &to_insert) {
- astring copy_of_me(to_insert);
- insert(position, copy_of_me); // not recursive because no longer == me.
- } else {
- c_character_manager.insert(position, to_insert.length());
- c_character_manager.overwrite(position, to_insert.c_character_manager,
- to_insert.length());
- }
-}
-
-bool astring::replace(const astring &tag, const astring &replacement)
-{
- int where = find(tag);
- if (negative(where)) return false;
- zap(where, where + tag.end());
- insert(where, replacement);
- return true;
-}
-
-bool astring::replace_all(const astring &to_replace, const astring &new_string)
-{
- bool did_any = false;
- for (int i = 0; i < length(); i++) {
- int indy = find(to_replace, i);
- if (negative(indy)) break; // get out since there are no more matches.
- i = indy; // update our position to where we found the string.
- zap(i, i + to_replace.length() - 1); // remove old string.
- insert(i, new_string); // plug the new string into the old position.
- i += new_string.length() - 1; // jump past what we replaced.
- did_any = true;
- }
- return did_any;
-}
-
-bool astring::replace_all(char to_replace, char new_char)
-{
- bool did_any = false;
- for (int i = 0; i < length(); i++) {
- if (get(i) == to_replace) {
- put(i, new_char);
- did_any = true;
- }
- }
- return did_any;
-}
-
-bool astring::matches(const astring &match_list, char to_match)
-{
- for (int i = 0; i < match_list.length(); i++)
- if (to_match == match_list.get(i)) return true;
- return false;
-}
-
-void astring::strip(const astring &strip_list, how_to_strip way)
-{
- if (way & FROM_FRONT)
- while (length() && matches(strip_list, get(0)))
- zap(0, 0);
-
- if (way & FROM_END)
- while (length() && matches(strip_list, get(end())))
- zap(end(), end());
-}
-
-int astring::packed_size() const { return length() + 1; }
-
-void astring::pack(byte_array &target) const
-{ attach(target, (char *)c_character_manager.observe()); }
-
-bool astring::unpack(byte_array &source)
-{ return detach(source, *this); }
-
-///int astring::icompare(const astring &to_compare, int length_in) const
-///{ return icompare(to_compare.observe(), length_in); }
-
-/*
-int astring::slow_strncasecmp(const char *first, const char *second, int length)
-{
- int len1 = int(strlen(first));
- int len2 = int(strlen(second));
- if (!length) return 0; // no characters are equal to none.
- if (!len1 && !len2) return 0; // equal as empty.
- if (!len1 && len2) return -1; // first < second.
- if (len1 && !len2) return 1; // first > second.
- if (positive(length)) {
- len1 = minimum(length, len1);
- len2 = minimum(length, len2);
- }
- for (int i = 0; i < len1; i++) {
- if (i > len2 - 1) return 1; // first > second, had more length.
- if (simple_lower(first[i]) < simple_lower(second[i]))
- return -1; // first < second.
- if (simple_lower(first[i]) > simple_lower(second[i]))
- return 1; // first > second.
- }
- // at this point we know second is equal to first up to the length of
- // first.
- if (len2 > len1) return -1; // second was longer and therefore greater.
- return 0; // equal.
-}
-*/
-
-//////////////
-
-a_sprintf::a_sprintf() : astring() {}
-
-a_sprintf::a_sprintf(const astring &s) : astring(s) {}
-
-a_sprintf::a_sprintf(const char *initial, ...)
-: astring()
-{
- if (!initial) return;
- va_list args;
- va_start(args, initial);
- base_sprintf(initial, args);
- va_end(args);
-}
-
-//////////////
-
-void attach(byte_array &packed_form, const char *to_attach)
-{
- const int len = int(strlen(to_attach));
- const int old_pos = packed_form.last();
- packed_form.insert(old_pos + 1, len + 1);
- memmove((char *)packed_form.observe() + old_pos + 1, to_attach, len + 1);
-}
-
-bool detach(byte_array &packed_form, astring &to_detach)
-{
- if (!packed_form.length()) return false;
- // locate the zero termination if possible.
- const void *zero_posn = memchr(packed_form.observe(), '\0',
- packed_form.length());
- // make sure we could find the zero termination.
- if (!zero_posn) {
- // nope, never saw a zero. good thing we checked.
- to_detach.reset();
- return false;
- }
- // set the string up using a standard constructor since we found the zero
- // position; we know the string constructor will be happy.
- to_detach = (char *)packed_form.observe();
- // compute the length of the string we found based on the position of the
- // zero character.
- int find_len = int((abyte *)zero_posn - packed_form.observe());
- // whack the portion of the array that we consumed.
- packed_form.zap(0, find_len);
- return true;
-}
-
-//////////////
-
-// contract fulfillment area.
-
-base_string &astring::concatenate_string(const base_string &s)
-{
- const astring *cast = dynamic_cast<const astring *>(&s);
- if (cast) *this += *cast;
- else *this += astring(s.observe());
- return *this;
-}
-
-base_string &astring::concatenate_char(char c)
-{
- *this += c;
- return *this;
-}
-
-base_string &astring::assign(const base_string &s)
-{
- const astring *cast = dynamic_cast<const astring *>(&s);
- if (cast) *this = *cast;
- else *this = astring(s.observe());
- return *this;
-}
-
-base_string &astring::upgrade(const char *s)
-{
- *this = s;
- return *this;
-}
-
-bool astring::sub_string(base_string &target, int start, int end) const
-{
- astring *cast = dynamic_cast<astring *>(&target);
- if (!cast) throw "error: astring::sub_string: unknown type";
- return substring(*cast, start, end);
-}
-
-bool astring::sub_compare(const base_string &to_compare, int start_first,
- int start_second, int count, bool case_sensitive) const
-{
- const astring *cast = dynamic_cast<const astring *>(&to_compare);
- if (cast) return compare(*cast, start_first, start_second, count, case_sensitive);
- else return compare(astring(to_compare.observe()), start_first, start_second,
- count, case_sensitive);
-}
-
-void astring::insert(int position, const base_string &to_insert)
-{
- const astring *cast = dynamic_cast<const astring *>(&to_insert);
- if (cast) this->insert(position, *cast);
- else this->insert(position, astring(to_insert.observe()));
-}
-
-} //namespace.
-
projects / feisty_meow.git / blobdiff