More work on bidi and contextual forms.
[WebKit-https.git] / WebCore / kwq / KWQString.h
1 /*
2  * Copyright (C) 2001, 2002 Apple Computer, Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef QSTRING_H_
27 #define QSTRING_H_
28
29 #include <CoreFoundation/CoreFoundation.h>
30
31 #include "KWQCString.h"
32
33 // Make htmltokenizer.cpp happy
34 #define QT_VERSION 300
35
36 class QRegExp;
37
38 #ifdef __OBJC__
39 @class NSString;
40 #else
41 class NSString;
42 #endif
43
44 class QChar {
45 public:
46
47     enum Direction {
48         // NOTE: alphabetical order
49         //DirAL, DirAN, DirB, DirBN, DirCS, DirEN, DirES, DirET, DirL, DirLRE,
50         //DirLRO, DirNSM, DirON, DirPDF, DirR, DirRLE, DirRLO, DirS, DirWS
51         //
52         // Until we understand the implications better, I say we go with the qt
53         // ordering here
54         DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
55         DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
56     };
57
58     static const QChar null;
59
60     QChar();
61     QChar(char);
62     QChar(uchar);
63     QChar(short);
64     QChar(ushort);
65     QChar(int);
66     QChar(uint);
67
68     ushort unicode() const;
69     uchar cell() const;
70     uchar row() const;
71     char latin1() const;
72     bool isNull() const;
73     bool isSpace() const;
74     bool isDigit() const;
75     bool isLetter() const;
76     bool isNumber() const;
77     bool isLetterOrNumber() const;
78     bool isPunct() const;
79     int digitValue() const;
80     QChar lower() const;
81     QChar upper() const;
82     Direction direction() const;
83     bool mirrored() const;
84     QChar mirroredChar() const;
85
86     operator char() const;
87
88     friend bool operator==(QChar, QChar);
89     friend bool operator==(QChar, char);
90     friend bool operator==(char, QChar);
91
92     friend bool operator!=(QChar, QChar);
93     friend bool operator!=(QChar, char);
94     friend bool operator!=(char, QChar);
95
96     friend bool operator>(QChar, QChar);
97     friend bool operator>(QChar, char);
98     friend bool operator>(char, QChar);
99
100     friend bool operator>=(QChar, QChar);
101     friend bool operator>=(QChar, char);
102     friend bool operator>=(char, QChar);
103
104     friend bool operator<(QChar, QChar);
105     friend bool operator<(QChar, char);
106     friend bool operator<(char, QChar);
107
108     friend bool operator<=(QChar, QChar);
109     friend bool operator<=(QChar, char);
110     friend bool operator<=(char, QChar);
111
112 private:
113     UniChar c;
114
115     friend class QString;
116     friend class QConstString;
117
118 };
119
120 inline QChar::QChar() : c(0)
121 {
122 }
123
124 inline QChar::QChar(char ch) : c((uchar) ch)
125 {
126 }
127
128 inline QChar::QChar(uchar uch) : c(uch)
129 {
130 }
131
132 inline QChar::QChar(short n) : c(n)
133 {
134 }
135
136 inline QChar::QChar(ushort n) : c(n)
137 {
138 }
139
140 inline QChar::QChar(uint n) : c(n)
141 {
142 }
143
144 inline QChar::QChar(int n) : c(n)
145 {
146 }
147
148 inline ushort QChar::unicode() const
149 {
150     return c;
151 }
152
153 inline uchar QChar::cell() const
154 {
155     return c;
156 }
157
158 inline bool QChar::isNull() const
159 {
160     return c == 0;
161 }
162
163 inline uchar QChar::row() const
164 {
165     return c >> 8;
166 }
167
168 inline char QChar::latin1() const
169 {
170     return c > 0xff ? 0 : c;
171 }
172
173 inline QChar::operator char() const
174 {
175     return c > 0xff ? 0 : c;
176 }
177
178 inline bool operator==(QChar qc1, QChar qc2)
179 {
180     return qc1.c == qc2.c;
181 }
182
183 inline bool operator==(QChar qc, char ch)
184 {
185     return qc.c == (uchar) ch;
186 }
187
188 inline bool operator==(char ch, QChar qc)
189 {
190     return (uchar) ch == qc.c;
191 }
192
193 inline bool operator!=(QChar qc1, QChar qc2)
194 {
195     return qc1.c != qc2.c;
196 }
197
198 inline bool operator!=(QChar qc, char ch)
199 {
200     return qc.c != (uchar) ch;
201 }
202
203 inline bool operator!=(char ch, QChar qc)
204 {
205     return (uchar) ch != qc.c;
206 }
207
208 inline bool operator>=(QChar qc1, QChar qc2)
209 {
210     return qc1.c >= qc2.c;
211 }
212
213 inline bool operator>=(QChar qc, char ch)
214 {
215     return qc.c >= (uchar) ch;
216 }
217
218 inline bool operator>=(char ch, QChar qc)
219 {
220     return (uchar) ch >= qc.c;
221 }
222
223 inline bool operator>(QChar qc1, QChar qc2)
224 {
225     return qc1.c > qc2.c;
226 }
227
228 inline bool operator>(QChar qc, char ch)
229 {
230     return qc.c > (uchar) ch;
231 }
232
233 inline bool operator>(char ch, QChar qc)
234 {
235     return (uchar) ch > qc.c;
236 }
237
238 inline bool operator<=(QChar qc1, QChar qc2)
239 {
240     return qc1.c <= qc2.c;
241 }
242
243 inline bool operator<=(QChar qc, char ch)
244 {
245     return qc.c <= (uchar) ch;
246 }
247
248 inline bool operator<=(char ch, QChar qc)
249 {
250     return (uchar) ch <= qc.c;
251 }
252
253 inline bool operator<(QChar qc1, QChar qc2)
254 {
255     return qc1.c < qc2.c;
256 }
257
258 inline bool operator<(QChar qc, char ch)
259 {
260     return qc.c < (uchar) ch;
261 }
262
263 inline bool operator<(char ch, QChar qc)
264 {
265     return (uchar) ch < qc.c;
266 }
267
268 // Keep this struct to <= 46 bytes, that's what the system will allocate.
269 // Will be rounded up to a multiple of 4, so we're stuck at 44.
270
271 #define QS_INTERNAL_BUFFER_SIZE 20
272 #define QS_INTERNAL_BUFFER_CHARS QS_INTERNAL_BUFFER_SIZE-1
273 #define QS_INTERNAL_BUFFER_UCHARS QS_INTERNAL_BUFFER_SIZE/2
274
275 struct QStringData {
276     // Uses shared null data.
277     QStringData();
278     void initialize();
279     
280     // No copy.
281     QStringData(QChar *u, uint l, uint m);
282     void initialize(QChar *u, uint l, uint m);
283     
284     // Copy bytes;
285     QStringData(const QChar *u, uint l);
286     void initialize(const QChar *u, uint l);
287
288     // Copy bytes;
289     QStringData(const char *u, uint l);
290     void initialize(const char *u, uint l);
291
292     ~QStringData();
293
294 #ifdef QSTRING_DEBUG_ALLOCATIONS
295     void* operator new(size_t s);
296     void operator delete(void*p);
297 #endif
298
299     inline void ref() { refCount++; }
300     inline void deref() { if (--refCount == 0 && _isHeapAllocated) delete this; }
301         
302     char *ascii();
303     char *makeAscii();
304     void increaseAsciiSize(uint size);
305
306     QChar *unicode();
307     QChar *makeUnicode();    
308     void increaseUnicodeSize(uint size);
309         
310     uint refCount;
311     uint _length;
312     mutable QChar *_unicode;
313     mutable char *_ascii;
314     uint _maxUnicode:29;
315     uint _isUnicodeInternal:1;
316     uint _isUnicodeValid:1;
317     uint _isHeapAllocated:1;    // Fragile, but the only way we can be sure the instance was
318                                 // created with 'new'.
319     uint _maxAscii:30;
320     uint _isAsciiInternal:1;
321     uint _isAsciiValid:1;
322     char _internalBuffer[QS_INTERNAL_BUFFER_SIZE]; // Pad out to a (((size + 1) & ~15) + 14) size
323 };
324
325 class QString {
326 public:
327     static const QString null;
328
329     QString();
330     QString(QChar);
331     QString(const QByteArray &);
332     QString(const QChar *, uint);
333     QString(const char *);
334     QString(const char *, int len);
335     
336     QString(const QString &);
337     QString &operator=(const QString &);
338
339     ~QString();
340
341     static QString fromLatin1(const char *);
342     static QString fromLatin1(const char *, int len);
343     static QString fromStringWithEncoding(const char *, int, CFStringEncoding);
344     static QString fromCFString(CFStringRef);
345     static QString fromNSString(NSString *);
346     
347     QString &operator=(char);
348     QString &operator=(QChar);
349     QString &operator=(const char *);
350     QString &operator=(const QCString &);
351
352     uint length() const;
353
354     const QChar *unicode() const;
355     const char *latin1() const;
356     const char *ascii() const;
357     QCString utf8() const;
358     QCString local8Bit() const;
359
360     bool isNull() const;
361     bool isEmpty() const;
362
363     QChar at(uint) const;
364
365     int compare(const QString &) const;
366     int compare(const char *) const;
367
368     bool startsWith(const QString &) const;
369
370     int find(char, int index = 0) const;
371     int find(QChar, int index = 0) const;
372     int find(const char *, int index = 0, bool cs = true) const;
373     int find(const QString &, int index = 0, bool cs = true) const;
374     int find(const QRegExp &, int index = 0) const;
375
376     int findRev(char, int index = -1) const;
377     int findRev(const QString& str, int index, bool cs = true) const;
378     int findRev(const char *, int index = -1) const;
379
380     int contains(char) const;
381     int contains(const char *, bool cs = true) const;
382     int contains(const QString &, bool cs = true) const;
383     int contains(QChar c, bool cs = true) const;
384
385     bool endsWith(const QString &) const;
386
387     // NOTE: toXXXXX integer functions only support base 10 and base 16
388     // NOTE: toShort, toUShort, toULong, and toDouble are NOT used but are kept
389     // for completeness
390     short toShort(bool *ok=NULL, int base=10) const;
391     // NOTE: ok and base NOT used for toUShort
392     ushort toUShort(bool *ok=NULL, int base=10) const;
393     int toInt(bool *ok=NULL, int base=10) const;
394     // NOTE: base NOT used for toUInt
395     uint toUInt(bool *ok=NULL, int base=10) const;
396     long toLong(bool *ok=NULL, int base=10) const;
397     ulong toULong(bool *ok=NULL, int base=10) const;
398     float toFloat(bool *ok=NULL) const;
399     double toDouble(bool *ok=NULL) const;
400
401     static QString number(int);
402     static QString number(uint);
403     static QString number(long);
404     static QString number(ulong);
405     static QString number(double);
406
407     bool findArg(int& pos, int& len) const;
408     
409     QString arg(const QString &, int width=0) const;
410     QString arg(short, int width=0) const;
411     QString arg(ushort, int width=0) const;
412     QString arg(int, int width=0) const;
413     QString arg(uint, int width=0) const;
414     QString arg(long, int width=0) const;
415     QString arg(ulong, int width=0) const;
416     QString arg(double, int width=0) const;
417
418     QString left(uint) const;
419     QString right(uint) const;
420     QString mid(uint, uint len=0xffffffff) const;
421
422     QString copy() const;
423
424     QString lower() const;
425     QString stripWhiteSpace() const;
426     QString simplifyWhiteSpace() const;
427
428     QString &setUnicode(const QChar *, uint);
429     QString &setLatin1(const char *, int len=-1);
430
431     QString &setNum(short);
432     QString &setNum(ushort);
433     QString &setNum(int);
434     QString &setNum(uint);
435     QString &setNum(long);
436     QString &setNum(ulong);
437     QString &setNum(double);
438
439     QString &sprintf(const char *, ...) __attribute__ ((format (printf, 2, 3)));
440
441     QString &prepend(const QString &);
442     QString &append(const QString &);
443     QString &insert(uint, const QString &);
444     QString &insert(uint, QChar);
445     QString &insert(uint, char);
446     QString &insert(uint index, const char *insertChars, uint insertLength);
447     QString &remove(uint, uint);
448     QString &replace( uint index, uint len, const QString &s );
449     //QString &replace( uint index, uint len, const QChar* s, uint slen );
450     QString &replace(const QRegExp &, const QString &);
451
452     void truncate(uint);
453     void fill(QChar, int len=-1);
454
455     void compose();
456     QString visual();
457
458     CFStringRef getCFString() const;
459     NSString *getNSString() const;
460
461     bool operator!() const;
462
463     const QChar operator[](int) const;
464
465     QString &operator+=(const QString &);
466     QString &operator+=(QChar);
467     QString &operator+=(char);
468
469     void setBufferFromCFString(CFStringRef);
470     
471 private:
472     // Used by QConstString.
473     QString(QStringData *constData, bool /*dummy*/);
474     void detach();
475     void detachInternal();
476     void deref();
477     QChar *forceUnicode();
478     void setLength(uint);
479
480     QStringData *data() const;
481     
482     QCString convertToQCString(CFStringEncoding) const;
483
484     QStringData **dataHandle;
485     QStringData internalData;
486     
487     static QStringData* shared_null;
488     static QStringData* makeSharedNull();
489     static QStringData**shared_null_handle;
490     static QStringData**makeSharedNullHandle();
491
492     friend bool operator==(const QString &, const QString &);
493     friend bool operator==(const QString &, const char *);
494
495     friend class QConstString;
496     friend class QGDict;
497     friend struct QStringData;
498 };
499
500 QString operator+(const QString &, const QString &);
501 QString operator+(const QString &, const char *);
502 QString operator+(const QString &, QChar);
503 QString operator+(const QString &, char);
504 QString operator+(const char *, const QString &);
505 QString operator+(QChar, const QString &);
506 QString operator+(char, const QString &);
507
508 inline QStringData *QString::data() const { return *dataHandle; }
509
510 inline uint QString::length() const
511 {
512     return data()->_length;
513 }
514
515 inline bool QString::isEmpty() const
516 {
517     return length() == 0;
518 }
519
520 inline QString QString::fromLatin1(const char *chs)
521 {
522     return chs;
523 }
524
525 inline QString QString::fromLatin1(const char *chs, int length)
526 {
527     return QString(chs, length);
528 }
529
530 inline const char *QString::ascii() const
531 {
532     return latin1();
533 }
534
535 inline float QString::toFloat(bool *ok) const
536 {
537     return toDouble(ok);
538 }
539
540 inline bool QString::operator!() const
541 {
542     return isNull();
543 }
544
545 inline const QChar QString::operator[](int index) const
546 {
547     return at(index);
548 }
549
550 inline bool operator==(const char *chs, const QString &qs)
551 {
552     return qs == chs;
553 }
554
555 inline bool operator!=(const QString &qs1, const QString &qs2)
556 {
557     return !(qs1 == qs2);
558 }
559
560 inline bool operator!=(const QString &qs, const char *chs)
561 {
562     return !(qs == chs);
563 }
564
565 inline bool operator!=(const char *chs, const QString &qs)
566 {
567     return !(qs == chs);
568 }
569
570 inline bool operator<(const QString &qs1, const QString &qs2)
571 {
572     return qs1.compare(qs2) < 0;
573 }
574
575 inline bool operator<(const QString &qs, const char *chs)
576 {
577     return qs.compare(chs) < 0;
578 }
579
580 inline bool operator<(const char *chs, const QString &qs)
581 {
582     return qs.compare(chs) > 0;
583 }
584
585 inline bool operator<=(const QString &qs1, const QString &qs2)
586 {
587     return qs1.compare(qs2) <= 0;
588 }
589
590 inline bool operator<=(const QString &qs, const char *chs)
591 {
592     return qs.compare(chs) <= 0;
593 }
594
595 inline bool operator<=(const char *chs, const QString &qs)
596 {
597     return qs.compare(chs) >= 0;
598 }
599
600 inline bool operator>(const QString &qs1, const QString &qs2)
601 {
602     return qs1.compare(qs2) > 0;
603 }
604
605 inline bool operator>(const QString &qs, const char *chs)
606 {
607     return qs.compare(chs) > 0;
608 }
609
610 inline bool operator>(const char *chs, const QString &qs)
611 {
612     return qs.compare(chs) < 0;
613 }
614
615 inline bool operator>=(const QString &qs1, const QString &qs2)
616 {
617     return qs1.compare(qs2) >= 0;
618 }
619
620 inline bool operator>=(const QString &qs, const char *chs)
621 {
622     return qs.compare(chs) >= 0;
623 }
624
625 inline bool operator>=(const char *chs, const QString &qs)
626 {
627     return qs.compare(chs) <= 0;
628 }
629
630 class QConstString : private QString {
631 public:
632     QConstString(const QChar *, uint);
633     ~QConstString();
634     const QString &string() const { return *this; }
635 };
636
637 #endif