dmd2/root.h

   1
   2
   3 // Copyright (c) 1999-2006 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 /* NOTE: This file has been patched from the original DMD distribution to
  12    work with the GDC compiler.
  13
  14    Modified by David Friedman, September 2004
  15 */
  16
  17 #ifndef ROOT_H
  18 #define ROOT_H
  19
  20 #include <stdlib.h>
  21 #include <stdarg.h>
  22
  23 #if __DMC__
  24 #pragma once
  25 #endif
  26
  27 typedef size_t hash_t;
  28
  29 #include "dchar.h"
  30
  31 char *wchar2ascii(wchar_t *);
  32 int wcharIsAscii(wchar_t *);
  33 char *wchar2ascii(wchar_t *, unsigned len);
  34 int wcharIsAscii(wchar_t *, unsigned len);
  35
  36 int bstrcmp(unsigned char *s1, unsigned char *s2);
  37 char *bstr2str(unsigned char *b);
  38 #ifndef GCC_SAFE_DMD
  39 void error(const char *format, ...);
  40 void error(const wchar_t *format, ...);
  41 void warning(const char *format, ...);
  42 #endif
  43
  44 #ifndef TYPEDEFS
  45 #define TYPEDEFS
  46
  47 #if _MSC_VER
  48 typedef __int64 longlong;
  49 typedef unsigned __int64 ulonglong;
  50 #else
  51 typedef long long longlong;
  52 typedef unsigned long long ulonglong;
  53 #endif
  54
  55 #endif
  56
  57 longlong randomx();
  58
  59 /*
  60  * Root of our class library.
  61  */
  62
  63 struct OutBuffer;
  64 struct Array;
  65
  66 struct Object
  67 {
  68     Object() { }
  69     virtual ~Object() { }
  70
  71     virtual int equals(Object *o);
  72
  73     /**
  74      * Returns a hash code, useful for things like building hash tables of Objects.
  75      */
  76     virtual hash_t hashCode();
  77
  78     /**
  79      * Return <0, ==0, or >0 if this is less than, equal to, or greater than obj.
  80      * Useful for sorting Objects.
  81      */
  82     virtual int compare(Object *obj);
  83
  84     /**
  85      * Pretty-print an Object. Useful for debugging the old-fashioned way.
  86      */
  87     virtual void print();
  88
  89     virtual char *toChars();
  90     virtual dchar *toDchars();
  91     virtual void toBuffer(OutBuffer *buf);
  92
  93     /**
  94      * Used as a replacement for dynamic_cast. Returns a unique number
  95      * defined by the library user. For Object, the return value is 0.
  96      */
  97     virtual int dyncast();
  98
  99     /**
 100      * Marks pointers for garbage collector by calling mem.mark() for all pointers into heap.
 101      */
 102     /*virtual*/         // not used, disable for now
 103         void mark();
 104 };
 105
 106 struct String : Object
 107 {
 108     int ref;                    // != 0 if this is a reference to someone else's string
 109     char *str;                  // the string itself
 110
 111     String(char *str, int ref = 1);
 112
 113     ~String();
 114
 115     static hash_t calcHash(const char *str, size_t len);
 116     static hash_t calcHash(const char *str);
 117     hash_t hashCode();
 118     unsigned len();
 119     int equals(Object *obj);
 120     int compare(Object *obj);
 121     char *toChars();
 122     void print();
 123     void mark();
 124 };
 125
 126 struct FileName : String
 127 {
 128     FileName(char *str, int ref);
 129     FileName(char *path, char *name);
 130     hash_t hashCode();
 131     int equals(Object *obj);
 132     int compare(Object *obj);
 133     static int absolute(const char *name);
 134     static char *ext(const char *);
 135     char *ext();
 136     static char *removeExt(const char *str);
 137     static char *name(const char *);
 138     char *name();
 139     static char *path(const char *);
 140     static char *replaceName(char *path, char *name);
 141
 142     static char *combine(char *path, char *name);
 143     static Array *splitPath(const char *path);
 144     static FileName *defaultExt(const char *name, const char *ext);
 145     static FileName *forceExt(const char *name, const char *ext);
 146     int equalsExt(const char *ext);
 147
 148     void CopyTo(FileName *to);
 149     static char *searchPath(Array *path, char *name, int cwd);
 150     static int exists(const char *name);
 151     static void ensurePathExists(const char *path);
 152 };
 153
 154 struct File : Object
 155 {
 156     int ref;                    // != 0 if this is a reference to someone else's buffer
 157     unsigned char *buffer;      // data for our file
 158     unsigned len;               // amount of data in buffer[]
 159     void *touchtime;            // system time to use for file
 160
 161     FileName *name;             // name of our file
 162
 163     File(char *);
 164     File(FileName *);
 165     ~File();
 166
 167     void mark();
 168
 169     char *toChars();
 170
 171     /* Read file, return !=0 if error
 172      */
 173
 174     int read();
 175
 176     /* Write file, either succeed or fail
 177      * with error message & exit.
 178      */
 179
 180     void readv();
 181
 182     /* Read file, return !=0 if error
 183      */
 184
 185     int mmread();
 186
 187     /* Write file, either succeed or fail
 188      * with error message & exit.
 189      */
 190
 191     void mmreadv();
 192
 193     /* Write file, return !=0 if error
 194      */
 195
 196     int write();
 197
 198     /* Write file, either succeed or fail
 199      * with error message & exit.
 200      */
 201
 202     void writev();
 203
 204     /* Return !=0 if file exists.
 205      *  0:      file doesn't exist
 206      *  1:      normal file
 207      *  2:      directory
 208      */
 209
 210     /* Append to file, return !=0 if error
 211      */
 212
 213     int append();
 214
 215     /* Append to file, either succeed or fail
 216      * with error message & exit.
 217      */
 218
 219     void appendv();
 220
 221     /* Return !=0 if file exists.
 222      *  0:      file doesn't exist
 223      *  1:      normal file
 224      *  2:      directory
 225      */
 226
 227     int exists();
 228
 229     /* Given wildcard filespec, return an array of
 230      * matching File's.
 231      */
 232
 233     static Array *match(char *);
 234     static Array *match(FileName *);
 235
 236     // Compare file times.
 237     // Return   <0      this < f
 238     //          =0      this == f
 239     //          >0      this > f
 240     int compareTime(File *f);
 241
 242     // Read system file statistics
 243     void stat();
 244
 245     /* Set buffer
 246      */
 247
 248     void setbuffer(void *buffer, unsigned len)
 249     {
 250         this->buffer = (unsigned char *)buffer;
 251         this->len = len;
 252     }
 253
 254     void checkoffset(size_t offset, size_t nbytes);
 255
 256     void remove();              // delete file
 257 };
 258
 259 struct OutBuffer : Object
 260 {
 261     unsigned char *data;
 262     unsigned offset;
 263     unsigned size;
 264
 265     OutBuffer();
 266     ~OutBuffer();
 267     void *extractData();
 268     void mark();
 269
 270     void reserve(unsigned nbytes);
 271     void setsize(unsigned size);
 272     void reset();
 273     void write(const void *data, unsigned nbytes);
 274     void writebstring(unsigned char *string);
 275     void writestring(const char *string);
 276     void writedstring(const char *string);
 277     void writedstring(const wchar_t *string);
 278     void prependstring(char *string);
 279     void writenl();                     // write newline
 280     void writeByte(unsigned b);
 281     void writebyte(unsigned b) { writeByte(b); }
 282     void writeUTF8(unsigned b);
 283     void writedchar(unsigned b);
 284     void prependbyte(unsigned b);
 285     void writeword(unsigned w);
 286     void writeUTF16(unsigned w);
 287     void write4(unsigned w);
 288     void write(OutBuffer *buf);
 289     void write(Object *obj);
 290     void fill0(unsigned nbytes);
 291     void align(unsigned size);
 292     void vprintf(const char *format, va_list args);
 293     void printf(const char *format, ...);
 294 #if M_UNICODE
 295     void vprintf(const unsigned short *format, va_list args);
 296     void printf(const unsigned short *format, ...);
 297 #endif
 298     void bracket(char left, char right);
 299     unsigned bracket(unsigned i, char *left, unsigned j, char *right);
 300     void spread(unsigned offset, unsigned nbytes);
 301     unsigned insert(unsigned offset, const void *data, unsigned nbytes);
 302     void remove(unsigned offset, unsigned nbytes);
 303     char *toChars();
 304     char *extractString();
 305 };
 306
 307 struct Array : Object
 308 {
 309     unsigned dim;
 310     unsigned allocdim;
 311     void **data;
 312
 313     Array();
 314     ~Array();
 315     void mark();
 316     char *toChars();
 317
 318     void reserve(unsigned nentries);
 319     void setDim(unsigned newdim);
 320     void fixDim();
 321     void push(void *ptr);
 322     void *pop();
 323     void shift(void *ptr);
 324     void insert(unsigned index, void *ptr);
 325     void insert(unsigned index, Array *a);
 326     void append(Array *a);
 327     void remove(unsigned i);
 328     void zero();
 329     void *tos();
 330     void sort();
 331     Array *copy();
 332 };
 333
 334 struct Bits : Object
 335 {
 336     unsigned bitdim;
 337     unsigned allocdim;
 338     unsigned *data;
 339
 340     Bits();
 341     ~Bits();
 342     void mark();
 343
 344     void resize(unsigned bitdim);
 345
 346     void set(unsigned bitnum);
 347     void clear(unsigned bitnum);
 348     int test(unsigned bitnum);
 349
 350     void set();
 351     void clear();
 352     void copy(Bits *from);
 353     Bits *clone();
 354
 355     void sub(Bits *b);
 356 };
 357
 358 #endif