1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
//========================================================================
//
// GString.h
//
// Simple variable-length string type.
//
// Copyright 1996-2003 Glyph & Cog, LLC
//
//========================================================================
#ifndef GSTRING_H
#define GSTRING_H
#include <aconf.h>
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include <stdarg.h>
#include "gtypes.h"
class GString {
public:
// Create an empty string.
GString();
// Create a string from a C string.
GString(const char *sA);
// Create a string from <lengthA> chars at <sA>. This string
// can contain null characters.
GString(const char *sA, int lengthA);
// Create a string from <lengthA> chars at <idx> in <str>.
GString(GString *str, int idx, int lengthA);
// Copy a string.
GString(GString *str);
GString *copy() { return new GString(this); }
// Concatenate two strings.
GString(GString *str1, GString *str2);
// Convert an integer to a string.
static GString *fromInt(int x);
// Create a formatted string. Similar to printf, but without the
// string overflow issues. Formatting elements consist of:
// {<arg>:[<width>][.<precision>]<type>}
// where:
// - <arg> is the argument number (arg 0 is the first argument
// following the format string) -- NB: args must be first used in
// order; they can be reused in any order
// - <width> is the field width -- negative to reverse the alignment;
// starting with a leading zero to zero-fill (for integers)
// - <precision> is the number of digits to the right of the decimal
// point (for floating point numbers)
// - <type> is one of:
// d, x, o, b -- int in decimal, hex, octal, binary
// ud, ux, uo, ub -- unsigned int
// ld, lx, lo, lb, uld, ulx, ulo, ulb -- long, unsigned long
// f, g -- double
// c -- char
// s -- string (char *)
// t -- GString *
// w -- blank space; arg determines width
// To get literal curly braces, use {{ or }}.
static GString *format(char *fmt, ...);
static GString *formatv(char *fmt, va_list argList);
// Destructor.
~GString();
// Get length.
int getLength() { return length; }
// Get C string.
char *getCString() { return s; }
// Get <i>th character.
char getChar(int i) { return s[i]; }
// Change <i>th character.
void setChar(int i, char c) { s[i] = c; }
// Clear string to zero length.
GString *clear();
// Append a character or string.
GString *append(char c);
GString *append(GString *str);
GString *append(const char *str);
GString *append(const char *str, int lengthA);
// Append a formatted string.
GString *appendf(char *fmt, ...);
GString *appendfv(char *fmt, va_list argList);
// Insert a character or string.
GString *insert(int i, char c);
GString *insert(int i, GString *str);
GString *insert(int i, const char *str);
GString *insert(int i, const char *str, int lengthA);
// Delete a character or range of characters.
GString *del(int i, int n = 1);
// Convert string to all-upper/all-lower case.
GString *upperCase();
GString *lowerCase();
// Compare two strings: -1:< 0:= +1:>
int cmp(GString *str);
int cmpN(GString *str, int n);
int cmp(const char *sA);
int cmpN(const char *sA, int n);
private:
int length;
char *s;
void resize(int length1);
static void formatInt(long x, char *buf, int bufSize,
GBool zeroFill, int width, int base,
char **p, int *len);
static void formatUInt(Gulong x, char *buf, int bufSize,
GBool zeroFill, int width, int base,
char **p, int *len);
static void formatDouble(double x, char *buf, int bufSize, int prec,
GBool trim, char **p, int *len);
};
#endif
|
