+++ /dev/null
-/*****************************************************************************\
-* *
-* Name : string_manipulation *
-* Author : Chris Koeritz *
-* *
-*******************************************************************************
-* Copyright (c) 2000-$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 "parser_bits.h"
-#include "string_manipulation.h"
-
-#include <basis/byte_array.h>
-#include <basis/functions.h>
-#include <basis/mutex.h>
-#include <mathematics/chaos.h>
-
-using namespace basis;
-using namespace mathematics;
-
-namespace textual {
-
-//SAFE_STATIC_CONST(astring_object, string_manipulation::splitter_finding_set,
-// ("\t\r\n -,;?!.:"))
-const char *splitter_finding_set = "\t\r\n -,;?!.:";
- // any of these characters make a valid place to break a line.
-
-astring string_manipulation::make_random_name(int min, int max)
-{
- chaos rando;
- int length = rando.inclusive(min, max);
- // pick a size for the string.
- astring to_return;
- for (int i = 0; i < length; i++) {
- int chah = rando.inclusive(0, 26);
- // use a range one larger than alphabet size.
- char to_add = 'a' + chah;
- if (chah == 26) to_add = '_';
- // patch the extra value to be a separator.
- to_return += to_add;
- }
- return to_return;
-}
-
-astring string_manipulation::long_line(char line_item, int repeat)
-{ return astring(line_item, repeat); }
-
-astring string_manipulation::indentation(int spaces)
-{
- astring s;
- for (int i = 0; i < spaces; i++) s += ' ';
- return s;
-}
-
-void string_manipulation::carriage_returns_to_spaces(astring &to_strip)
-{
- for (int j = 0; j < to_strip.length(); j++) {
- int original_j = j; // track where we started looking.
- if (!parser_bits::is_eol(to_strip[j])) continue;
- // we have found at least one CR. let's see what else there is.
- if ( (to_strip[j] == '\r') && (to_strip[j + 1] == '\n') ) {
- // this is looking like a DOS CR. let's skip that now.
- j++;
- }
- j++; // skip the one we know is a CR.
- if (parser_bits::is_eol(to_strip[j])) {
- // we are seeing more than one carriage return in a row. let's
- // truncate that down to just one.
- j++;
- while (parser_bits::is_eol(to_strip[j]) && (j < to_strip.length()))
- j++; // skip to next one that might not be CR.
- // now we think we know where there's this huge line of CRs. we will
- // turn them all into spaces except the first.
- to_strip[original_j] = '\n';
- for (int k = original_j + 1; k < j; k++) to_strip[k] = ' ';
- // put the index back so we'll start looking at the non-CR char.
- j--;
- continue; // now skip back out to the main loop.
- } else {
- // we see only one carriage return, which we will drop in favor of
- // joining those lines together. we iterate here since we might have
- // seen a DOS CR taking up two spaces.
- for (int k = original_j; k < j; k++) to_strip[k] = ' ';
- }
- }
-
-}
-
-void string_manipulation::split_lines(const astring &input_in, astring &output,
- int min_column, int max_column)
-{
- output = "";
- if (max_column - min_column + 1 < 2) return; // what's the point?
-
- astring input = input_in; // make a copy to work on.
- carriage_returns_to_spaces(input);
-
- int col = min_column;
- astring indent_add = indentation(min_column);
- output = indent_add; // start with the extra space.
-
- bool just_had_break = false;
- // set true if we just handled a line break in the previous loop.
- bool put_accum_before_break = false; // true if we must postpone CR.
- astring accumulated;
- // holds stuff to print on next go-round.
-
- // now we parse across the list counting up our line size and making sure
- // we don't go over it.
- for (int j = 0; j < input.length(); j++) {
-
-//char to_print = input[j];
-//if (parser_bits::is_eol(to_print)) to_print = '_';
-//printf("[%d: val=%d, '%c', col=%d]\n", j, to_print, to_print, col);
-//fflush(0);
-
- // handle the carriage return if it was ordered.
- if (just_had_break) {
- if (put_accum_before_break) {
- output += accumulated;
- // strip off any spaces from the end of the line.
- output.strip_spaces(astring::FROM_END);
- output += parser_bits::platform_eol_to_chars();
- accumulated = "";
- j++; // skip the CR that we think is there.
- }
- // strip off any spaces from the end of the line.
- output.strip_spaces(astring::FROM_END);
- output += parser_bits::platform_eol_to_chars();
- col = min_column;
- output += indent_add;
- just_had_break = false;
- if (accumulated.length()) {
- output += accumulated;
- col += accumulated.length();
- accumulated = "";
- }
- j--;
- continue;
- }
-
- put_accum_before_break = false;
-
- // skip any spaces we've got at the current position.
- while ( (input[j] == ' ') || (input[j] == '\t') ) {
- j++;
- if (j >= input.length()) break; // break out of subloop if past it.
- }
-
- if (j >= input.length()) break; // we're past the end.
-
- // handle carriage returns when they're at the current position.
- char current_char = input[j];
- if (parser_bits::is_eol(current_char)) {
- just_had_break = true; // set the state.
- put_accum_before_break = true;
- continue;
- }
-
-//hmmm: the portion below could be called a find word break function.
-
- bool add_dash = false; // true if we need to break a word and add hyphen.
- bool break_line = false; // true if we need to go to the next line.
- bool invisible = false; // true if invisible characters were seen.
- bool end_sentence = false; // true if there was a sentence terminator.
- bool punctuate = false; // true if there was normal punctuation.
- bool keep_on_line = false; // true if we want add current then break line.
- char prior_break = '\0'; // set for real below.
- char prior_break_plus_1 = '\0'; // ditto.
-
- // find where our next normal word break is, if possible.
- int next_break = input.find_any(splitter_finding_set, j);
- // if we didn't find a separator, just use the end of the string.
- if (negative(next_break))
- next_break = input.length() - 1;
-
- // now we know where we're supposed to break, but we don't know if it
- // will all fit.
- prior_break = input[next_break];
- // hang onto the value before we change next_break.
- prior_break_plus_1 = input[next_break + 1];
- // should still be safe since we're stopping before the last zero.
- switch (prior_break) {
- case '\r': case '\n':
- break_line = true;
- just_had_break = true;
- put_accum_before_break = true;
- // intentional fall-through.
- case '\t': case ' ':
- invisible = true;
- next_break--; // don't include it in what's printed.
- break;
- case '?': case '!': case '.':
- end_sentence = true;
- // if we see multiples of these, we count them as just one.
- while ( (input[next_break + 1] == '?')
- || (input[next_break + 1] == '!')
- || (input[next_break + 1] == '.') ) {
- next_break++;
- }
- // make sure that there's a blank area after the supposed punctuation.
- if (!parser_bits::white_space(input[next_break + 1]))
- end_sentence = false;
- break;
- case ',': case ';': case ':':
- punctuate = true;
- // make sure that there's a blank area after the supposed punctuation.
- if (!parser_bits::white_space(input[next_break + 1]))
- punctuate = false;
- break;
- }
-
- // we'll need to add some spaces for certain punctuation.
- int punct_adder = 0;
- if (punctuate || invisible) punct_adder = 1;
- if (end_sentence) punct_adder = 2;
-
- // check that we're still in bounds.
- int chars_added = next_break - j + 1;
- if (col + chars_added + punct_adder > max_column + 1) {
- // we need to break before the next breakable character.
- break_line = true;
- just_had_break = true;
- if (col + chars_added <= max_column + 1) {
- // it will fit without the punctuation spaces, which is fine since
- // it should be the end of the line.
- invisible = false;
- punctuate = false;
- end_sentence = false;
- punct_adder = 0;
- keep_on_line = true;
- } else if (min_column + chars_added > max_column + 1) {
- // this word won't ever fit unless we break it.
- int chars_left = max_column - col + 1;
- // remember to take out room for the dash also.
- if (chars_left < 2) {
- j--; // stay where we are.
- continue;
- } else {
- next_break = j + chars_left - 2;
- chars_added = next_break - j + 1;
- if (next_break >= input.length())
- next_break = input.length() - 1;
- else if (next_break < j)
- next_break = j;
- add_dash = true;
- }
- }
- }
-
- astring adding_chunk = input.substring(j, next_break);
- // this is what we've decided the next word chunk to be added will be.
- // we still haven't completely decided where it goes.
-
- if (break_line) {
- col = min_column;
- if (add_dash || keep_on_line) {
- // include the previous stuff on the same line.
- output += adding_chunk;
- if (add_dash) output += "-";
- j = next_break;
- continue; // done with this case.
- }
-
- // don't include the previous stuff; make it go to the next line.
- accumulated = adding_chunk;
- if (punctuate || invisible) {
- accumulated += " ";
- } else if (end_sentence) {
- accumulated += " ";
- }
- j = next_break;
- continue;
- }
-
- // add the line normally since it should fit.
- output += adding_chunk;
- col += chars_added + punct_adder; // add the characters added.
- j = next_break;
- just_had_break = false; // reset the state.
-
- // handle when we processed an invisible or punctuation character.
- if (punctuate || invisible) {
- output += " ";
- } else if (end_sentence) {
- output += " ";
- }
- }
- // make sure we handle any leftovers.
- if (accumulated.length()) {
- output.strip_spaces(astring::FROM_END);
- output += parser_bits::platform_eol_to_chars();
- output += indent_add;
- output += accumulated;
- }
- output.strip_spaces(astring::FROM_END);
- output += parser_bits::platform_eol_to_chars();
-}
-
-char string_manipulation::hex_to_char(abyte to_convert)
-{
- if (to_convert <= 9) return char('0' + to_convert);
- else if ( (to_convert >= 10) && (to_convert <= 15) )
- return char('A' - 10 + to_convert);
- else return '?';
-}
-
-abyte string_manipulation::char_to_hex(char to_convert)
-{
- if ( (to_convert >= '0') && (to_convert <= '9') )
- return char(to_convert - '0');
- else if ( (to_convert >= 'a') && (to_convert <= 'f') )
- return char(to_convert - 'a' + 10);
- else if ( (to_convert >= 'A') && (to_convert <= 'F') )
- return char(to_convert - 'A' + 10);
- else return 0;
-}
-
-byte_array string_manipulation::string_to_hex(const astring &to_convert)
-{
- byte_array to_return(0, NIL);
- for (int i = 0; i < to_convert.length() / 2; i++) {
- int str_index = i * 2;
- abyte first_byte = char_to_hex(to_convert.get(str_index));
- abyte second_byte = char_to_hex(to_convert.get(str_index + 1));
- abyte to_stuff = abyte(first_byte * 16 + second_byte);
- to_return.concatenate(to_stuff);
- }
- return to_return;
-}
-
-astring string_manipulation::hex_to_string(const byte_array &to_convert)
-{
- astring to_return;
- for (int i = 0; i < to_convert.length() * 2; i += 2) {
- int str_index = i / 2;
- char first_char = hex_to_char(char(to_convert.get(str_index) / 16));
- char second_char = hex_to_char(char(to_convert.get(str_index) % 16));
- to_return += astring(first_char, 1);
- to_return += astring(second_char, 1);
- }
- return to_return;
-}
-
-} //namespace.
-
projects / feisty_meow.git / blobdiff