modules/up/src/gnug++/Obstack.h

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. Obstack
  2. Obstack
  3. base
  4. next_free
  5. alignment_mask
  6. chunk_size
  7. size
  8. room
  9. grow
  10. grow
  11. grow
  12. grow
  13. blank
  14. finish
  15. copy
  16. copy
  17. copy
  18. copy
  19. alloc
  20. free
  21. grow_fast
  22. blank_fast
  23. shrink

   1 // This may look like C code, but it is really -*- C++ -*-
   2 /* 
   3 Copyright (C) 1988 Free Software Foundation
   4     written by Doug Lea (dl@rocky.oswego.edu)
   5 
   6 This file is part of the GNU C++ Library.  This library is free
   7 software; you can redistribute it and/or modify it under the terms of
   8 the GNU Library General Public License as published by the Free
   9 Software Foundation; either version 2 of the License, or (at your
  10 option) any later version.  This library is distributed in the hope
  11 that it will be useful, but WITHOUT ANY WARRANTY; without even the
  12 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13 PURPOSE.  See the GNU Library General Public License for more details.
  14 You should have received a copy of the GNU Library General Public
  15 License along with this library; if not, write to the Free Software
  16 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17 */
  18 
  19 
  20 #ifndef _Obstack_h
  21 #ifdef __GNUG__
  22 #pragma interface
  23 #endif
  24 #define _Obstack_h 1
  25 
  26 #include <std.h>
  27 
  28 #undef OK
  29 
  30 class Obstack
     /* [<][>][^][v][top][bottom][index][help] */
  31 {
  32   struct _obstack_chunk
  33   {
  34     char*           limit;
  35     _obstack_chunk* prev;
  36     char            contents[4];
  37   };
  38 
  39 protected:
  40   long            chunksize;
  41   _obstack_chunk* chunk;
  42   char*           objectbase;
  43   char*           nextfree;
  44   char*           chunklimit;
  45   int             alignmentmask;
  46 
  47   void  _free(void* obj);
  48   void  newchunk(int size);
  49 
  50 public:
  51         Obstack(int size = 4080, int alignment = 4); // 4080=4096-mallocslop
  52 
  53         ~Obstack();
  54 
  55   void* base();
  56   void* next_free();
  57   int   alignment_mask();
  58   int   chunk_size();
  59   int   size();
  60   int   room();
  61   int   contains(void* p);      // does Obstack hold pointer p?
  62 
  63   void  grow(const void* data, int size);
  64   void  grow(const void* data, int size, char terminator);
  65   void  grow(const char* s);
  66   void  grow(char c);
  67   void  grow_fast(char c);
  68   void  blank(int size);
  69   void  blank_fast(int size);
  70 
  71   void* finish();
  72   void* finish(char terminator);
  73 
  74   void* copy(const void* data, int size);
  75   void* copy(const void* data, int size, char terminator);
  76   void* copy(const char* s);
  77   void* copy(char c);
  78   void* alloc(int size);
  79 
  80   void  free(void* obj);
  81   void  shrink(int size = 1); // suggested by ken@cs.rochester.edu
  82 
  83   int   OK();                   // rep invariant
  84 };
  85 
  86 
  87 inline Obstack::~Obstack()
     /* [<][>][^][v][top][bottom][index][help] */
  88 {
  89   _free(0); 
  90 }
  91 
  92 inline void* Obstack::base()
     /* [<][>][^][v][top][bottom][index][help] */
  93 {
  94   return objectbase; 
  95 }
  96 
  97 inline void* Obstack::next_free()
     /* [<][>][^][v][top][bottom][index][help] */
  98 {
  99   return nextfree; 
 100 }
 101 
 102 inline int Obstack::alignment_mask()
     /* [<][>][^][v][top][bottom][index][help] */
 103 {
 104   return alignmentmask; 
 105 }
 106 
 107 inline int Obstack::chunk_size()
     /* [<][>][^][v][top][bottom][index][help] */
 108 {
 109   return chunksize; 
 110 }
 111 
 112 inline int Obstack::size()
     /* [<][>][^][v][top][bottom][index][help] */
 113 {
 114   return nextfree - objectbase; 
 115 }
 116 
 117 inline int Obstack::room()
     /* [<][>][^][v][top][bottom][index][help] */
 118 {
 119   return chunklimit - nextfree; 
 120 }
 121 
 122 inline void Obstack:: grow(const void* data, int size)
     /* [<][>][^][v][top][bottom][index][help] */
 123 {
 124   if (nextfree+size > chunklimit) 
 125     newchunk(size);
 126   memcpy(nextfree, data, size);
 127   nextfree += size; 
 128 }
 129 
 130 inline void Obstack:: grow(const void* data, int size, char terminator)
     /* [<][>][^][v][top][bottom][index][help] */
 131 {
 132   if (nextfree+size+1 > chunklimit) 
 133     newchunk(size+1);
 134   memcpy(nextfree, data, size);
 135   nextfree += size; 
 136   *(nextfree)++ = terminator; 
 137 }
 138 
 139 inline void Obstack:: grow(const char* s)
     /* [<][>][^][v][top][bottom][index][help] */
 140 {
 141   grow((const void*)s, strlen(s), 0); 
 142 }
 143 
 144 inline void Obstack:: grow(char c)
     /* [<][>][^][v][top][bottom][index][help] */
 145 {
 146   if (nextfree+1 > chunklimit) 
 147     newchunk(1); 
 148   *(nextfree)++ = c; 
 149 }
 150 
 151 inline void Obstack:: blank(int size)
     /* [<][>][^][v][top][bottom][index][help] */
 152 {
 153   if (nextfree+size > chunklimit) 
 154     newchunk(size);
 155   nextfree += size; 
 156 }
 157 
 158 inline void* Obstack::finish(char terminator)
     /* [<][>][^][v][top][bottom][index][help] */
 159 {
 160   grow(terminator); 
 161   return finish(); 
 162 }
 163 
 164 inline void* Obstack::copy(const void* data, int size)
     /* [<][>][^][v][top][bottom][index][help] */
 165 {
 166   grow (data, size);
 167   return finish(); 
 168 }
 169 
 170 inline void* Obstack::copy(const void* data, int size, char terminator)
     /* [<][>][^][v][top][bottom][index][help] */
 171 {
 172   grow(data, size, terminator); 
 173   return finish(); 
 174 }
 175 
 176 inline void* Obstack::copy(const char* s)
     /* [<][>][^][v][top][bottom][index][help] */
 177 {
 178   grow((const void*)s, strlen(s), 0); 
 179   return finish(); 
 180 }
 181 
 182 inline void* Obstack::copy(char c)
     /* [<][>][^][v][top][bottom][index][help] */
 183 {
 184   grow(c);
 185   return finish(); 
 186 }
 187 
 188 inline void* Obstack::alloc(int size)
     /* [<][>][^][v][top][bottom][index][help] */
 189 {
 190   blank(size);
 191   return finish(); 
 192 }
 193 
 194 inline void Obstack:: free(void* obj)     
     /* [<][>][^][v][top][bottom][index][help] */
 195 {
 196   if (obj >= (void*)chunk && obj<(void*)chunklimit)
 197     nextfree = objectbase = (char *) obj;
 198   else 
 199     _free(obj); 
 200 }
 201 
 202 inline void Obstack:: grow_fast(char c)
     /* [<][>][^][v][top][bottom][index][help] */
 203 {
 204   *(nextfree)++ = c; 
 205 }
 206 
 207 inline void Obstack:: blank_fast(int size)
     /* [<][>][^][v][top][bottom][index][help] */
 208 {
 209   nextfree += size; 
 210 }
 211 
 212 inline void Obstack:: shrink(int size) // from ken@cs.rochester.edu
     /* [<][>][^][v][top][bottom][index][help] */
 213 {
 214   if (nextfree >= objectbase + size)
 215     nextfree -= size;
 216 }
 217 
 218 #endif

/* [<][>][^][v][top][bottom][index][help] */