initial import
[ICEs.git] / 137054 / ice.ii.3
1 extern "C++" {
2 namespace std {
3 class exception { public: exception() throw() { } virtual ~exception() throw(); virtual const char* what() const throw(); };
4 }
5 }
6 typedef unsigned int size_t;
7 extern "C" {
8 extern void *memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
9 }
10 typedef unsigned char UCHAR;
11 typedef unsigned short USHORT;
12 typedef char TEXT;
13 namespace Firebird {
14 class status_exception : public std::exception {
15 };
16 class fatal_exception : public status_exception {
17 public: explicit fatal_exception(const char* message);
18 static void raiseFmt(const char* format, ...);
19 };
20 typedef struct _IO_FILE FILE;
21 typedef unsigned int wint_t;
22 typedef struct {
23 union { wint_t __wch; char __wchb[4]; }
24 __value;
25 }
26 __mbstate_t;
27 typedef struct {
28 }
29 _IO_cookie_io_functions_t;
30 extern struct _IO_FILE *stderr;
31 extern int fprintf (FILE *__restrict __stream, __const char *__restrict __format, ...);
32 extern void abort (void) throw () __attribute__ ((__noreturn__));
33 void gds__log(const TEXT*, ...);
34 struct FreeMemoryBlock {
35 };
36 struct MemoryBlock {
37 union { class MemoryPool* mbk_pool; FreeMemoryBlock* mbk_prev_fragment; };
38 };
39 }
40 namespace Firebird {
41 class PermanentStorage {
42 private: MemoryPool& pool;
43 protected: explicit PermanentStorage(MemoryPool& p) : pool(p) { }
44 };
45 class AutoStorage : public PermanentStorage {
46 private: void ProbeStack() const;
47 public: static MemoryPool& getAutoMemoryPool();
48 protected: AutoStorage() : PermanentStorage(getAutoMemoryPool()) { ProbeStack(); }
49 };
50 class AbstractString : private AutoStorage {
51 public: typedef char char_type;
52 typedef size_t size_type;
53 typedef char* pointer;
54 typedef const char* const_pointer;
55 enum {INLINE_BUFFER_SIZE = 32, INIT_RESERVE = 16 };
56 protected: typedef USHORT internal_size_type;
57 char_type inlineBuffer[INLINE_BUFFER_SIZE];
58 char_type* stringBuffer;
59 internal_size_type stringLength, bufferSize;
60 inline AbstractString() : stringBuffer(inlineBuffer), stringLength(0), bufferSize(INLINE_BUFFER_SIZE) { stringBuffer[0] = 0; }
61 AbstractString(size_type sizeL, char_type c);
62 pointer baseAppend(size_type n);
63 public: inline const_pointer c_str() const { return stringBuffer; }
64 inline size_type length() const { return stringLength; }
65 void printf(const char* Format, ...);
66 };
67 class StringComparator {
68 };
69 template<typename Comparator> class StringBase : public AbstractString {
70 typedef StringBase<Comparator> StringType;
71 public: inline StringBase<Comparator>() : AbstractString() {}
72 inline StringBase<Comparator>(char_type c) : AbstractString(1, c) {}
73 inline StringType& append(const StringType& str) { {if (!(&str != this)) {fprintf (stderr, "GDS Assertion failure: %s %""d""\n", "../src/include/../common/classes/fb_string.h", 416); abort();}}; return append(str.c_str(), str.length()); }
74 inline StringType& append(const_pointer s, size_type n) { memcpy(baseAppend(n), s, n); return *this; }
75 inline StringType& operator+=(const StringType& v) { {if (!(&v != this)) {fprintf (stderr, "GDS Assertion failure: %s %""d""\n", "../src/include/../common/classes/fb_string.h", 474); abort();}}; return append(v); }
76 };
77 typedef StringBase<StringComparator> string;
78 class ClumpletReader : protected AutoStorage {
79 public: enum Kind {Tagged, UnTagged, SpbAttach, SpbStart, Tpb };
80 ClumpletReader(Kind k, const UCHAR* buffer, size_t buffLen);
81 bool isEof() const { return cur_offset >= getBufferLength(); }
82 void moveNext();
83 void rewind();
84 UCHAR getClumpTag() const;
85 size_t getClumpLength() const;
86 const UCHAR* getBytes() const;
87 UCHAR getBufferTag() const;
88 size_t getBufferLength() const { size_t rc = getBufferEnd() - getBuffer(); if (rc == 1 && kind != UnTagged && kind != SpbStart) { rc = 0; } return rc; }
89 size_t getCurOffset() const { return cur_offset; }
90 void dump() const;
91 size_t cur_offset;
92 const Kind kind;
93 virtual const UCHAR* getBuffer() const { return static_buffer; }
94 virtual const UCHAR* getBufferEnd() const { return static_buffer_end; }
95 const UCHAR* static_buffer;
96 const UCHAR* static_buffer_end;
97 };
98 extern int isprint (int) throw ();
99 void ClumpletReader::dump() const {
100 class ClumpletDump : public ClumpletReader { public: ClumpletDump(Kind k, const UCHAR* buffer, size_t buffLen) : ClumpletReader(k, buffer, buffLen) { } static string hexString(const UCHAR* b, size_t len) { string t1, t2; for (; len > 0; --len, ++b) { if (isprint(*b)) t2 += *b; else { t1.printf("<%02x>", *b); t2 += t1; } } return t2; } protected: virtual void usage_mistake(const char* what) const { fatal_exception::raiseFmt( "Internal error when using clumplet API: %s", what); } virtual void invalid_structure(const char* what) const { fatal_exception::raiseFmt( "Invalid clumplet buffer structure: %s", what); } };
101 try { ClumpletDump d(kind, getBuffer(), getBufferLength()); int t = (kind == SpbStart || kind == UnTagged) ? -1 : d.getBufferTag(); gds__log("Tag=%d Offset=%d Length=%d Eof=%d\n", t, getCurOffset(), getBufferLength(), isEof()); for (d.rewind(); !(d.isEof()); d.moveNext()) { gds__log("Clump %d at offset %d: %s", d.getClumpTag(), d.getCurOffset(), ClumpletDump::hexString(d.getBytes(), d.getClumpLength()).c_str()); } }
102 catch(const fatal_exception& x) { gds__log("Fatal exception during clumplet dump: %s", x.what()); size_t l = getBufferLength() - getCurOffset(); const UCHAR *p = getBuffer() + getCurOffset(); gds__log("Plain dump starting with offset %d: %s", getCurOffset(), ClumpletDump::hexString(p, l).c_str()); }
103 }
104 }