Port to OpenSolaris (Dyson/Illumos).

This might be portability for portability sake (Solaris is so dead), but
come on, we can't disappoint Igor Pashev by porting our stuff later than
several hours after the first installable build of Dyson is released :)

1 files changed, 33 insertions, 33 deletions

diff --git a/crawl-ref/source/package.h b/crawl-ref/source/package.h
index 2e00258dab..0e0a136e56 100644
--- a/crawl-ref/source/package.h
+++ b/crawl-ref/source/package.h
@@ -13,7 +13,7 @@
 
 #define MAX_CHUNK_NAME_LENGTH 255
 
-typedef uint32_t len_t;
+typedef uint32_t plen_t;
 
 class package;
 
@@ -22,40 +22,40 @@ class chunk_writer
 private:
     package *pkg;
     string name;
-    len_t first_block;
-    len_t cur_block;
-    len_t block_len;
+    plen_t first_block;
+    plen_t cur_block;
+    plen_t block_len;
 #ifdef USE_ZLIB
     z_stream zs;
     Bytef *z_buffer;
 #endif
-    void raw_write(const void *data, len_t len);
-    void finish_block(len_t next);
+    void raw_write(const void *data, plen_t len);
+    void finish_block(plen_t next);
 public:
     chunk_writer(package *parent, const string _name);
     ~chunk_writer();
-    void write(const void *data, len_t len);
+    void write(const void *data, plen_t len);
     friend class package;
 };
 
 class chunk_reader
 {
 private:
-    chunk_reader(package *parent, len_t start);
-    void init(len_t start);
+    chunk_reader(package *parent, plen_t start);
+    void init(plen_t start);
     package *pkg;
-    len_t first_block, next_block;
-    len_t off, block_left;
+    plen_t first_block, next_block;
+    plen_t off, block_left;
 #ifdef USE_ZLIB
     bool eof;
     z_stream zs;
     Bytef z_buffer[32768];
 #endif
-    len_t raw_read(void *data, len_t len);
+    plen_t raw_read(void *data, plen_t len);
 public:
     chunk_reader(package *parent, const string _name);
     ~chunk_reader();
-    len_t read(void *data, len_t len);
+    plen_t read(void *data, plen_t len);
     void read_all(vector<char> &data);
     friend class package;
 };
@@ -76,37 +76,37 @@ public:
     void unlink();
 
     // statistics
-    len_t get_slack();
-    len_t get_size() const { return file_len; };
-    len_t get_chunk_fragmentation(const string name);
-    len_t get_chunk_compressed_length(const string name);
+    plen_t get_slack();
+    plen_t get_size() const { return file_len; };
+    plen_t get_chunk_fragmentation(const string name);
+    plen_t get_chunk_compressed_length(const string name);
 private:
     string filename;
     bool rw;
     int fd;
-    len_t file_len;
+    plen_t file_len;
     int n_users;
     bool dirty;
     bool aborted;
     bool tmp;
-    map<string, len_t> directory;
-    map<len_t, len_t> free_blocks;
-    vector<len_t> unlinked_blocks;
-    map<len_t, pair<len_t, len_t> > block_map;
-    set<len_t> new_chunks;
-    map<len_t, uint32_t> reader_count;
-    len_t extend_block(len_t at, len_t size, len_t by);
-    len_t alloc_block(len_t &size);
-    void finish_chunk(const string name, len_t at);
+    map<string, plen_t> directory;
+    map<plen_t, plen_t> free_blocks;
+    vector<plen_t> unlinked_blocks;
+    map<plen_t, pair<plen_t, plen_t> > block_map;
+    set<plen_t> new_chunks;
+    map<plen_t, uint32_t> reader_count;
+    plen_t extend_block(plen_t at, plen_t size, plen_t by);
+    plen_t alloc_block(plen_t &size);
+    void finish_chunk(const string name, plen_t at);
     void free_chunk(const string name);
-    len_t write_directory();
+    plen_t write_directory();
     void collect_blocks();
-    void free_block_chain(len_t at);
-    void free_block(len_t at, len_t size);
-    void seek(len_t to);
+    void free_block_chain(plen_t at);
+    void free_block(plen_t at, plen_t size);
+    void seek(plen_t to);
     void fsck();
-    void read_directory(len_t start, uint8_t version);
-    void trace_chunk(len_t start);
+    void read_directory(plen_t start, uint8_t version);
+    void trace_chunk(plen_t start);
     void load();
     void load_traces();
     friend class chunk_writer;