]> git.wh0rd.org Git - ICEs.git/blob - 137054/ice.ii.3
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     }