new fortune
[feisty_meow.git] / nucleus / library / textual / string_manipulation.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : string_manipulation                                               *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 2000-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "parser_bits.h"
16 #include "string_manipulation.h"
17
18 #include <basis/byte_array.h>
19 #include <basis/functions.h>
20 #include <basis/mutex.h>
21 #include <mathematics/chaos.h>
22
23 using namespace basis;
24 using namespace mathematics;
25
26 namespace textual {
27
28 //SAFE_STATIC_CONST(astring_object, string_manipulation::splitter_finding_set,
29 //    ("\t\r\n -,;?!.:"))
30 const char *splitter_finding_set = "\t\r\n -,;?!.:";
31   // any of these characters make a valid place to break a line.
32
33 astring string_manipulation::make_random_name(int min, int max)
34 {
35   chaos rando;
36   int length = rando.inclusive(min, max);
37     // pick a size for the string.
38   astring to_return;
39   for (int i = 0; i < length; i++) {
40     int chah = rando.inclusive(0, 26);
41       // use a range one larger than alphabet size.
42     char to_add = 'a' + chah;
43     if (chah == 26) to_add = '_';
44       // patch the extra value to be a separator.
45     to_return += to_add;
46   }
47   return to_return;
48 }
49
50 astring string_manipulation::long_line(char line_item, int repeat)
51 { return astring(line_item, repeat); }
52
53 astring string_manipulation::indentation(int spaces)
54 {
55   astring s;
56   for (int i = 0; i < spaces; i++) s += ' ';
57   return s;
58 }
59
60 void string_manipulation::carriage_returns_to_spaces(astring &to_strip)
61 {
62   for (int j = 0; j < to_strip.length(); j++) {
63     int original_j = j;  // track where we started looking.
64     if (!parser_bits::is_eol(to_strip[j])) continue;
65     // we have found at least one CR.  let's see what else there is.
66     if ( (to_strip[j] == '\r') && (to_strip[j + 1] == '\n') ) {
67       // this is looking like a DOS CR.  let's skip that now.
68       j++;
69     }
70     j++;  // skip the one we know is a CR.
71     if (parser_bits::is_eol(to_strip[j])) {
72       // we are seeing more than one carriage return in a row.  let's
73       // truncate that down to just one.
74       j++;
75       while (parser_bits::is_eol(to_strip[j]) && (j < to_strip.length()))
76         j++;  // skip to next one that might not be CR.
77       // now we think we know where there's this huge line of CRs.  we will
78       // turn them all into spaces except the first.
79       to_strip[original_j] = '\n';
80       for (int k = original_j + 1; k < j; k++) to_strip[k] = ' ';
81       // put the index back so we'll start looking at the non-CR char.
82       j--;
83       continue;  // now skip back out to the main loop.
84     } else {
85       // we see only one carriage return, which we will drop in favor of
86       // joining those lines together.  we iterate here since we might have
87       // seen a DOS CR taking up two spaces.
88       for (int k = original_j; k < j; k++) to_strip[k] = ' ';
89     }
90   }
91
92 }
93
94 void string_manipulation::split_lines(const astring &input_in, astring &output,
95     int min_column, int max_column)
96 {
97   output = "";
98   if (max_column - min_column + 1 < 2) return;  // what's the point?
99
100   astring input = input_in;  // make a copy to work on.
101   carriage_returns_to_spaces(input);
102
103   int col = min_column;
104   astring indent_add = indentation(min_column);
105   output = indent_add;  // start with the extra space.
106
107   bool just_had_break = false;
108     // set true if we just handled a line break in the previous loop.
109   bool put_accum_before_break = false;  // true if we must postpone CR.
110   astring accumulated;
111     // holds stuff to print on next go-round.
112
113   // now we parse across the list counting up our line size and making sure
114   // we don't go over it.
115   for (int j = 0; j < input.length(); j++) {
116
117 //char to_print = input[j];
118 //if (parser_bits::is_eol(to_print)) to_print = '_';
119 //printf("[%d: val=%d, '%c', col=%d]\n", j, to_print, to_print, col);
120 //fflush(0);
121
122     // handle the carriage return if it was ordered.
123     if (just_had_break) {
124       if (put_accum_before_break) {
125         output += accumulated;
126         // strip off any spaces from the end of the line.
127         output.strip_spaces(astring::FROM_END);
128         output += parser_bits::platform_eol_to_chars();
129         accumulated = "";
130         j++;  // skip the CR that we think is there.
131       }
132       // strip off any spaces from the end of the line.
133       output.strip_spaces(astring::FROM_END);
134       output += parser_bits::platform_eol_to_chars();
135       col = min_column;
136       output += indent_add;
137       just_had_break = false;
138       if (accumulated.length()) {
139         output += accumulated;
140         col += accumulated.length();
141         accumulated = "";
142       }
143       j--;
144       continue;
145     }
146
147     put_accum_before_break = false;
148
149     // skip any spaces we've got at the current position.
150     while ( (input[j] == ' ') || (input[j] == '\t') ) {
151       j++;
152       if (j >= input.length()) break;  // break out of subloop if past it.
153     }
154
155     if (j >= input.length()) break;  // we're past the end.
156
157     // handle carriage returns when they're at the current position.
158     char current_char = input[j];
159     if (parser_bits::is_eol(current_char)) {
160       just_had_break = true;  // set the state.
161       put_accum_before_break = true;
162       continue;
163     }
164
165 //hmmm: the portion below could be called a find word break function.
166
167     bool add_dash = false;  // true if we need to break a word and add hyphen.
168     bool break_line = false;  // true if we need to go to the next line.
169     bool invisible = false;  // true if invisible characters were seen.
170     bool end_sentence = false;  // true if there was a sentence terminator.
171     bool punctuate = false;  // true if there was normal punctuation.
172     bool keep_on_line = false;  // true if we want add current then break line.
173     char prior_break = '\0';  // set for real below.
174     char prior_break_plus_1 = '\0';  // ditto.
175
176     // find where our next normal word break is, if possible.
177     int next_break = input.find_any(splitter_finding_set, j);
178     // if we didn't find a separator, just use the end of the string.
179     if (negative(next_break))
180       next_break = input.length() - 1;
181
182     // now we know where we're supposed to break, but we don't know if it
183     // will all fit.
184     prior_break = input[next_break];
185       // hang onto the value before we change next_break.
186     prior_break_plus_1 = input[next_break + 1];
187       // should still be safe since we're stopping before the last zero.
188     switch (prior_break) {
189       case '\r': case '\n':
190         break_line = true;
191         just_had_break = true;
192         put_accum_before_break = true;
193         // intentional fall-through, so no break.
194       case '\t': case ' ':
195         invisible = true;
196         next_break--;  // don't include it in what's printed.
197         break;
198       case '?': case '!': case '.':
199         end_sentence = true;
200         // if we see multiples of these, we count them as just one.
201         while ( (input[next_break + 1] == '?')
202             || (input[next_break + 1] == '!')
203             || (input[next_break + 1] == '.') ) {
204           next_break++;
205         }
206         // make sure that there's a blank area after the supposed punctuation.
207         if (!parser_bits::white_space(input[next_break + 1]))
208           end_sentence = false;
209         break;
210       case ',': case ';': case ':':
211         punctuate = true;
212         // make sure that there's a blank area after the supposed punctuation.
213         if (!parser_bits::white_space(input[next_break + 1]))
214           punctuate = false;
215         break;
216     }
217
218     // we'll need to add some spaces for certain punctuation.
219     int punct_adder = 0;
220     if (punctuate || invisible) punct_adder = 1;
221     if (end_sentence) punct_adder = 2;
222
223     // check that we're still in bounds.
224     int chars_added = next_break - j + 1;
225     if (col + chars_added + punct_adder > max_column) {
226       // we need to break before the next breakable character.
227       break_line = true;
228       just_had_break = true;
229       if (col + chars_added <= max_column) {
230         // it will fit without the punctuation spaces, which is fine since
231         // it should be the end of the line.
232         invisible = false;
233         punctuate = false;
234         end_sentence = false;
235         punct_adder = 0;
236         keep_on_line = true;
237       } else if (min_column + chars_added > max_column) {
238         // this word won't ever fit unless we break it.
239         int chars_left = max_column - col + 1;
240           // remember to take out room for the dash also.
241         if (chars_left < 2) {
242           j--;  // stay where we are.
243           continue;
244         } else {
245           next_break = j + chars_left - 2;
246           chars_added = next_break - j + 1;
247           if (next_break >= input.length())
248             next_break = input.length() - 1;
249           else if (next_break < j)
250             next_break = j;
251           add_dash = true;
252         }
253       }
254     }
255
256     astring adding_chunk = input.substring(j, next_break);
257       // this is what we've decided the next word chunk to be added will be.
258       // we still haven't completely decided where it goes.
259
260     if (break_line) {
261       col = min_column;
262       if (add_dash || keep_on_line) {
263         // include the previous stuff on the same line.
264         output += adding_chunk;
265         if (add_dash) output += "-";
266         j = next_break;
267         continue;  // done with this case.
268       }
269
270       // don't include the previous stuff; make it go to the next line.
271       accumulated = adding_chunk;
272       if (punctuate || invisible) {
273         accumulated += " ";
274       } else if (end_sentence) {
275         accumulated += "  ";
276       }
277       j = next_break;
278       continue;
279     }
280
281     // add the line normally since it should fit.
282     output += adding_chunk;
283     col += chars_added + punct_adder;  // add the characters added.
284     j = next_break;
285     just_had_break = false;  // reset the state.
286
287     // handle when we processed an invisible or punctuation character.
288     if (punctuate || invisible) {
289       output += " ";
290     } else if (end_sentence) {
291       output += "  ";
292     }
293   }
294   // make sure we handle any leftovers.
295   if (accumulated.length()) {
296     output.strip_spaces(astring::FROM_END);
297     output += parser_bits::platform_eol_to_chars();
298     output += indent_add;
299     output += accumulated;
300   }
301   output.strip_spaces(astring::FROM_END);
302   output += parser_bits::platform_eol_to_chars();
303 }
304
305 char string_manipulation::hex_to_char(abyte to_convert)
306 {
307   if (to_convert <= 9) return char('0' + to_convert);
308   else if ( (to_convert >= 10) && (to_convert <= 15) )
309     return char('A' - 10 + to_convert);
310   else return '?';
311 }
312
313 abyte string_manipulation::char_to_hex(char to_convert)
314 {
315   if ( (to_convert >= '0') && (to_convert <= '9') )
316     return char(to_convert - '0');
317   else if ( (to_convert >= 'a') && (to_convert <= 'f') )
318     return char(to_convert - 'a' + 10);
319   else if ( (to_convert >= 'A') && (to_convert <= 'F') )
320     return char(to_convert - 'A' + 10);
321   else return 0;
322 }
323
324 byte_array string_manipulation::string_to_hex(const astring &to_convert)
325 {
326   byte_array to_return(0, NULL_POINTER);
327   for (int i = 0; i < to_convert.length() / 2; i++) {
328     int str_index = i * 2;
329     abyte first_byte = char_to_hex(to_convert.get(str_index));
330     abyte second_byte = char_to_hex(to_convert.get(str_index + 1));
331     abyte to_stuff = abyte(first_byte * 16 + second_byte);
332     to_return.concatenate(to_stuff);
333   }
334   return to_return;
335 }
336
337 astring string_manipulation::hex_to_string(const byte_array &to_convert)
338 {
339   astring to_return;
340   for (int i = 0; i < to_convert.length() * 2; i += 2) {
341     int str_index = i / 2;
342     char first_char = hex_to_char(char(to_convert.get(str_index) / 16));
343     char second_char = hex_to_char(char(to_convert.get(str_index) % 16));
344     to_return += astring(first_char, 1);
345     to_return += astring(second_char, 1);
346   }
347   return to_return;
348 }
349
350 } //namespace.
351