Changeset 17 for abuse/trunkTweet

Timestamp:

Nov 10, 2005, 9:41:13 PM (18 years ago)

Author:

Sam Hocevar

Message:

• absolute shitloads of 64 bit fixes.

Location:

abuse/trunk/src

Files:

• cache.cpp (modified) (23 diffs)
• clisp.cpp (modified) (4 diffs)
• compiled.cpp (modified) (3 diffs)
• cop.cpp (modified) (1 diff)
• crc.cpp (modified) (2 diffs)
• demo.cpp (modified) (7 diffs)
• dev.cpp (modified) (2 diffs)
• director.cpp (modified) (1 diff)
• endgame.cpp (modified) (12 diffs)
• extend.cpp (modified) (1 diff)
• game.cpp (modified) (18 diffs)
• gamma.cpp (modified) (1 diff)
• go.cpp (modified) (5 diffs)
• imlib/filter.cpp (modified) (3 diffs)
• imlib/gifread.cpp (modified) (6 diffs)
• imlib/glread.cpp (modified) (7 diffs)
• imlib/image.cpp (modified) (48 diffs)
• imlib/include/image.hpp (modified) (7 diffs)
• imlib/include/jmalloc.hpp (modified) (1 diff)
• imlib/include/jwindow.hpp (modified) (1 diff)
• imlib/include/macs.hpp (modified) (1 diff)
• imlib/include/packet.hpp (modified) (2 diffs)
• imlib/include/scroller.hpp (modified) (1 diff)
• imlib/include/specs.hpp (modified) (2 diffs)
• imlib/include/system.h (modified) (2 diffs)
• imlib/include/timage.hpp (modified) (2 diffs)
• imlib/jmalloc.cpp (modified) (30 diffs)
• imlib/lbmread.cpp (modified) (3 diffs)
• imlib/mdlread.cpp (modified) (8 diffs)
• imlib/morph.cpp (modified) (5 diffs)
• imlib/packet.cpp (modified) (5 diffs)
• imlib/palette.cpp (modified) (3 diffs)
• imlib/pcxread.cpp (modified) (2 diffs)
• imlib/readwav.cpp (modified) (5 diffs)
• imlib/readxwd.cpp (modified) (9 diffs)
• imlib/scroller.cpp (modified) (9 diffs)
• imlib/specs.cpp (modified) (9 diffs)
• imlib/targa.cpp (modified) (4 diffs)
• imlib/timage.cpp (modified) (22 diffs)
• imlib/xwdread.cpp (modified) (14 diffs)
• include/cache.hpp (modified) (6 diffs)
• include/compiled.hpp (modified) (1 diff)
• include/crc.hpp (modified) (1 diff)
• include/extend.hpp (modified) (5 diffs)
• include/fakelib.hpp (modified) (1 diff)
• include/game.hpp (modified) (1 diff)
• include/items.hpp (modified) (7 diffs)
• include/level.hpp (modified) (5 diffs)
• include/light.hpp (modified) (2 diffs)
• include/netface.hpp (modified) (4 diffs)
• include/particle.hpp (modified) (1 diff)
• include/transp.hpp (modified) (1 diff)
• include/view.hpp (modified) (4 diffs)
• innet.cpp (modified) (6 diffs)
• items.cpp (modified) (10 diffs)
• lcache.cpp (modified) (5 diffs)
• level.cpp (modified) (57 diffs)
• light.cpp (modified) (31 diffs)
• lisp.cpp (modified) (3 diffs)
• lisp_gc.cpp (modified) (6 diffs)
• loader2.cpp (modified) (1 diff)
• net/engine.cpp (modified) (24 diffs)
• net/fileman.cpp (modified) (13 diffs)
• net/gclient.cpp (modified) (6 diffs)
• net/gserver.cpp (modified) (7 diffs)
• net/include/endian.hpp (modified) (1 diff)
• net/include/fileman.hpp (modified) (4 diffs)
• net/include/indian.hpp (modified) (2 diffs)
• net/include/ipx.hpp (modified) (1 diff)
• net/netdrv.cpp (modified) (18 diffs)
• net/netfile.cpp (modified) (16 diffs)
• netcfg.cpp (modified) (1 diff)
• newlight.cpp (modified) (5 diffs)
• nfclient.cpp (modified) (1 diff)
• old.nfclient.cpp (modified) (14 diffs)
• old.nfserver.cpp (modified) (13 diffs)
• old_earth_menu.cpp (modified) (9 diffs)
• old_server.cpp (modified) (35 diffs)
• particle.cpp (modified) (6 diffs)
• profile.cpp (modified) (1 diff)
• server2.cpp (modified) (3 diffs)
• sndserver.cpp (modified) (8 diffs)
• specache.cpp (modified) (2 diffs)
• transp.cpp (modified) (4 diffs)
• unixnfc.cpp (modified) (22 diffs)
• version.cpp (modified) (2 diffs)
• view.cpp (modified) (11 diffs)

abuse/trunk/src/cache.cpp

@@ -67 +67 @@
   }
 
-  fp->write_short(total);
+  fp->write_uint16(total);
   total=0;
   for (i=0;i<total_files;i++)
   {
-    ulong crc;
+    uint32_t crc;
     int failed=0;
     crc=get_crc(i,failed);
     if (!failed)
     {
-      fp->write_long(crc);
-      uchar len=strlen(get_filename(i))+1;
-      fp->write_byte(len);
+      fp->write_uint32(crc);
+      uint8_t len=strlen(get_filename(i))+1;
+      fp->write_uint8(len);
       fp->write(get_filename(i),len);
       total++;
@@ -96 +96 @@
   } else
   {
-    short total=fp->read_short();
+    short total=fp->read_uint16();
     int i;
     for (i=0;i<total;i++)
     {
       char name[256];
-      ulong crc=fp->read_long();
-      uchar len=fp->read_byte();
+      uint32_t crc=fp->read_uint32();
+      uint8_t len=fp->read_uint8();
       fp->read(name,len);
       set_crc(get_filenumber(name),crc);
@@ -148 +148 @@
 }
 
-char *crc_manager::get_filename(long filenumber)
+char *crc_manager::get_filename(int32_t filenumber)
 {
   CHECK(filenumber>=0 && filenumber<total_files);
@@ -154 +154 @@
 }
 
-ulong crc_manager::get_crc(long filenumber, int &failed)
+uint32_t crc_manager::get_crc(int32_t filenumber, int &failed)
 {    
   CHECK(filenumber>=0 && filenumber<total_files);
@@ -166 +166 @@
 }
 
-void crc_manager::set_crc(long filenumber, ulong crc)
+void crc_manager::set_crc(int32_t filenumber, uint32_t crc)
 {
   CHECK(filenumber>=0 && filenumber<total_files);
@@ -248 +248 @@
     if (fp)
     {
-      fp->write_short(crc_man.total_filenames());
+      fp->write_uint16(crc_man.total_filenames());
       for (i=0;i<crc_man.total_filenames();i++)
       {
         int l=strlen(crc_man.get_filename(i))+1;
-        fp->write_byte(l);
+        fp->write_uint8(l);
         fp->write(crc_man.get_filename(i),l);
       }
@@ -259 +259 @@
       for (i=0;i<total;i++)
         if (list[i].last_access>0) tsaved++;
-      fp->write_long(tsaved);
+      fp->write_uint32(tsaved);
 
       for (i=0;i<total;i++)
@@ -266 +266 @@
         if (list[id].last_access>0)       // don't save unaccessed counts      
         {
-          fp->write_byte(list[id].type);    // save type, if type changed on reload 
+          fp->write_uint8(list[id].type);    // save type, if type changed on reload 
                                             // don't cache in-> its a different refrence
-          fp->write_short(list[id].file_number);
-          fp->write_long(list[id].offset);
+          fp->write_uint16(list[id].file_number);
+          fp->write_uint32(list[id].offset);
         }
       }      
@@ -310 +310 @@
 
 
-int cache_list::search(int *sarray, ushort filenum, long offset)
+int cache_list::search(int *sarray, uint16_t filenum, int32_t offset)
 {
   int x1=0,x2=total-1;
@@ -423 +423 @@
 
   int j;
-  ushort *fg_line;
+  uint16_t *fg_line;
   for (j=0;j<lev->foreground_height();j++)
   {
@@ -439 +439 @@
   }
 
-  ushort *bg_line;
+  uint16_t *bg_line;
   for (j=0;j<lev->background_height();j++)
   {
@@ -481 +481 @@
       int *fnum_remap;    // remaps old filenumbers into current ones
       
-      tnames=fp->read_short();
+      tnames=fp->read_uint16();
       if (tnames)                     /// make sure there isn't bad info in the file
       {
@@ -489 +489 @@
         for (i=0;i<tnames;i++)
         {
-          fp->read(name,fp->read_byte());
+          fp->read(name,fp->read_uint8());
           fnum_remap[i]=-1;                    // initialize the map to no-map
 
@@ -498 +498 @@
         }
         
-        long tsaved=fp->read_long();
+        uint32_t tsaved=fp->read_uint32();
 
 
@@ -511 +511 @@
         for (i=0;i<tsaved;i++)
         {
-          uchar type=fp->read_byte();
-          short file_num=fp->read_short();
+          uint8_t type=fp->read_uint8();
+          short file_num=fp->read_uint16();
           if (file_num>=tnames)  // bad data?
             file_num=-1;
           else file_num=fnum_remap[file_num];
 
-          ulong offset=fp->read_long();
+          uint32_t offset=fp->read_uint32();
 
           // search for a match 
@@ -805 +805 @@
 }
 
-long cache_list::alloc_id()
+int32_t cache_list::alloc_id()
 {
   int id;
@@ -851 +851 @@
 
 
-long cache_list::reg_lisp_block(Cell *block)
+int32_t cache_list::reg_lisp_block(Cell *block)
 { 
-  long s;
+  uint32_t s;
   if (lcache_number==-1)
     lcache_number=crc_man.get_filenumber(lfname);
@@ -893 +893 @@
 
   s=block_size(block);
-  cache_file->write_long(s);
+  cache_file->write_uint32(s);
   write_level(cache_file,block);
   return id;    
 }
 
-long cache_list::reg_object(char *filename, void *object, int type, int rm_dups)
+int32_t cache_list::reg_object(char *filename, void *object, int type, int rm_dups)
 { 
   char *name;
@@ -912 +912 @@
 extern int total_files_open;
 
-long cache_list::reg(char *filename, char *name, int type, int rm_dups)
+int32_t cache_list::reg(char *filename, char *name, int type, int rm_dups)
 {
         int id=alloc_id(),i,fn=crc_man.get_filenumber(filename);
@@ -1169 +1169 @@
       int cache_size=80*1024;                   // 80K
       cache_read_file->set_read_buffer_size(cache_size); 
-      uchar mini_buf;
+      uint8_t mini_buf;
       cache_read_file->read(&mini_buf,1);       // prime the buffer
     }
@@ -1177 +1177 @@
     int sp=alloc_space; alloc_space=ALLOC_SPACE_CACHE;
 
-    long size=cache_read_file->read_long();
+    uint32_t size=cache_read_file->read_uint32();
     void *space;
 
@@ -1206 +1206 @@
 void cache_list::free_oldest()
 {
-  long i,old_time=last_access;
+  uint32_t i,old_time=last_access;
   cache_item *ci=list,*oldest=NULL;
   ful=1;
@@ -1257 +1257 @@
       printf("type=(%20s) file=(%20s) access=(%6ld)\n",spec_types[ci->type],
              crc_man.get_filename(ci->file_number),
-             ci->last_access);
+             (long int)ci->last_access);
     }
   } while (new_old);

abuse/trunk/src/clisp.cpp

@@ -20 +20 @@
 #include "netcfg.hpp"
 
-extern uchar major_version;
-extern uchar minor_version;
+extern uint8_t major_version;
+extern uint8_t minor_version;
 extern int has_joystick;
 
@@ -60 +60 @@
 
             *l_statbar_logo_x,*l_statbar_logo_y;
-uchar chatting_enabled=0; 
+uint8_t chatting_enabled=0; 
 
 extern void scatter_line(int x1, int y1, int x2, int y2, int c, int s);
@@ -1909 +1909 @@
     {
       palette *p=pal->copy();
-      uchar *addr=(uchar *)p->addr();
+      uint8_t *addr=(uint8_t *)p->addr();
       int r,g,b;
       int ra=lnumber_value(CAR(args)); args=CDR(args);
@@ -1916 +1916 @@
       for (int i=0;i<256;i++)
       {
-        r=(int)*addr+ra; if (r>255) r=255; else if (r<0) r=0; *addr=(uchar)r; addr++;
-        g=(int)*addr+ga; if (g>255) g=255; else if (g<0) g=0; *addr=(uchar)g; addr++;
-        b=(int)*addr+ba; if (b>255) b=255; else if (b<0) b=0; *addr=(uchar)b; addr++;
+        r=(int)*addr+ra; if (r>255) r=255; else if (r<0) r=0; *addr=(uint8_t)r; addr++;
+        g=(int)*addr+ga; if (g>255) g=255; else if (g<0) g=0; *addr=(uint8_t)g; addr++;
+        b=(int)*addr+ba; if (b>255) b=255; else if (b<0) b=0; *addr=(uint8_t)b; addr++;
       }
       p->load();

abuse/trunk/src/compiled.cpp

@@ -6 +6 @@
 extern int total_objects;
 
-uchar *bad_guy_array=NULL;    // list flaging each character saying they are a bad bug or not
+uint8_t *bad_guy_array=NULL;  // list flaging each character saying they are a bad bug or not
                               // mainly used by the rocket to find targets
 
-long S_fall_start,S_falling,S_landing,S_pounce_wait,
+int32_t S_fall_start,S_falling,S_landing,S_pounce_wait,
      S_turn_around,S_fire_wait,S_ceil_fire,S_top_walk,
      S_blown_back_dead,S_jump_up,S_hiding,S_weapon_fire,
@@ -28 +28 @@
 int compile_error=0;
 
-long c_state(char *name)
+int32_t c_state(char *name)
 {
   void *sym=find_symbol(name);
@@ -114 +114 @@
   {
     b=symbol_value(b);
-    bad_guy_array=(uchar *)jmalloc(total_objects,"bad_guy_array");
+    bad_guy_array=(uint8_t *)jmalloc(total_objects,"bad_guy_array");
     memset(bad_guy_array,0,total_objects);
     while (b)
     {
-      long x=lnumber_value(CAR(b));
+      int32_t x=lnumber_value(CAR(b));
       if (x>=0 && x<total_objects)
         bad_guy_array[x]=1;

abuse/trunk/src/cop.cpp

@@ -797 +797 @@
 
     palette *p=pal->copy();
-    uchar *addr=(uchar *)p->addr();
+    uint8_t *addr=(uint8_t *)p->addr();
     int ra,ga,ba;
     
     for (int i=0;i<256;i++)
     {
-      ra=(int)*addr+r; if (ra>255) ra=255; else if (ra<0) r=0; *addr=(uchar)ra; addr++;
-      ga=(int)*addr+g; if (ga>255) ga=255; else if (ga<0) g=0; *addr=(uchar)ga; addr++;
-      ba=(int)*addr+b; if (ba>255) ba=255; else if (ba<0) b=0; *addr=(uchar)ba; addr++;
+      ra=(int)*addr+r; if (ra>255) ra=255; else if (ra<0) r=0; *addr=(uint8_t)ra; addr++;
+      ga=(int)*addr+g; if (ga>255) ga=255; else if (ga<0) g=0; *addr=(uint8_t)ga; addr++;
+      ba=(int)*addr+b; if (ba>255) ba=255; else if (ba<0) b=0; *addr=(uint8_t)ba; addr++;
     }
     p->load();

abuse/trunk/src/crc.cpp

@@ -1 +1 @@
 #include "crc.hpp"
 
-unsigned short calc_crc(unsigned char *buf, long len)
+uint16_t calc_crc(uint8_t *buf, int len)
 {
-  unsigned char c1=0,c2=0;
+  uint8_t c1=0,c2=0;
   while (len)
   {
@@ -16 +16 @@
 
  
-ulong crc_file(bFILE *fp)
+uint32_t crc_file(bFILE *fp)
 {
-  uchar crc1=0,crc2=0,crc3=0,crc4=0;
+  uint8_t crc1=0,crc2=0,crc3=0,crc4=0;
 
   int size=0x1000;
-  uchar *buffer=(uchar *)jmalloc(size,"crc_buffer"),*c;
+  uint8_t *buffer=(uint8_t *)jmalloc(size,"crc_buffer"),*c;
   long l=fp->file_size();
   long cur_pos=fp->tell();

abuse/trunk/src/demo.cpp

@@ -62 +62 @@
   the_game->load_level(name);
   record_file->write((void *)"DEMO,VERSION:2",14);
-  record_file->write_byte(strlen(name)+1);
+  record_file->write_uint8(strlen(name)+1);
   record_file->write(name,strlen(name)+1);
   
@@ -68 +68 @@
   if (DEFINEDP(symbol_value(l_difficulty)))
   {
-    if (symbol_value(l_difficulty)==l_easy) record_file->write_byte(0);
-    else if (symbol_value(l_difficulty)==l_medium) record_file->write_byte(1);
-    else if (symbol_value(l_difficulty)==l_hard) record_file->write_byte(2);
-    else record_file->write_byte(3);
-  } else record_file->write_byte(3);
+    if (symbol_value(l_difficulty)==l_easy) record_file->write_uint8(0);
+    else if (symbol_value(l_difficulty)==l_medium) record_file->write_uint8(1);
+    else if (symbol_value(l_difficulty)==l_hard) record_file->write_uint8(2);
+    else record_file->write_uint8(3);
+  } else record_file->write_uint8(3);
   
 
@@ -94 +94 @@
           p->get_input();
 
-      base->packet.write_byte(SCMD_SYNC);
-      base->packet.write_short(make_sync());
+      base->packet.write_uint8(SCMD_SYNC);
+      base->packet.write_uint16(make_sync());
       demo_man.save_packet(base->packet.packet_data(),base->packet.packet_size());
       process_packet_commands(base->packet.packet_data(),base->packet.packet_size());
@@ -102 +102 @@
     case PLAYING :
     {
-      uchar buf[1500];
+      uint8_t buf[1500];
       int size;
       if (get_packet(buf,size))              // get starting inputs
@@ -138 +138 @@
 int demo_manager::start_playing(char *filename)
 {
-  uchar sig[15];
+  uint8_t sig[15];
   record_file=open_file(filename,"rb");
   if (record_file->open_failure()) { delete record_file; return 0; }  
@@ -232 +232 @@
   if (state==RECORDING)
   {
-    ushort ps=lstl(packet_size);
+    uint16_t ps=lstl(packet_size);
     if (record_file->write(&ps,2)!=2 ||
         record_file->write(packet,packet_size)!=packet_size)
@@ -247 +247 @@
   if (state==PLAYING)
   {
-    ushort ps;
+    uint16_t ps;
     if (record_file->read(&ps,2)!=2)
     {

abuse/trunk/src/dev.cpp

@@ -405 +405 @@
     new_height-=y+new_height-cy2;
   
-  uchar d;
+  uint8_t d;
   for (iy=iy_start;new_height>0;new_height--,y++,iy+=ystep)
   {
@@ -568 +568 @@
     jfree(ch);
     char buf[100];
-    sprintf(buf,"%8ld %8ld",j_allocated(),j_available());
+    sprintf(buf,"%8ld %8ld",(long int)j_allocated(),(long int)j_available());
     eh->font()->put_string(memprof->screen,memprof->x1(),memprof->y2()-eh->font()->height(),buf);
 

abuse/trunk/src/director.cpp

@@ -25 +25 @@
 
 
-int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uchar *cmap, char color)
+int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uint8_t *cmap, char color)
 {
   short cx1,cy1,cx2,cy2,word_size,word_len;

abuse/trunk/src/endgame.cpp

@@ -21 +21 @@
 {
   int x,size;
-  ushort *remap;
-  uchar *light;
+  uint16_t *remap;
+  uint8_t *light;
 } ;
 
 
-int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uchar *cmap, char color);
+int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uint8_t *cmap, char color);
 
 mask_line *make_mask_lines(image *mask, int map_width)
@@ -34 +34 @@
   {
     // find the start of the run..
-    uchar *sl=mask->scan_line(y);    
+    uint8_t *sl=mask->scan_line(y);    
     int x=0;
     while (*sl==0) { sl++; x++; }
@@ -42 +42 @@
     // find the length of the run
     int size=0; 
-    uchar *sl_start=sl;
+    uint8_t *sl_start=sl;
     while (*sl!=0 && x<mask->width()) { sl++; x++; size++; }
     p[y].size=size;
 
     // now calculate remap for line
-    p[y].remap=(ushort *)jmalloc(size*2,"mask remap");
-    p[y].light=(uchar *)jmalloc(size,"mask light");
-    ushort *rem=p[y].remap;
-    uchar *lrem=p[y].light;
+    p[y].remap=(uint16_t *)jmalloc(size*2,"mask remap");
+    p[y].light=(uint8_t *)jmalloc(size,"mask light");
+    uint16_t *rem=p[y].remap;
+    uint8_t *lrem=p[y].light;
     for (x=0;x<size;x++,rem++)
     {
@@ -69 +69 @@
 
 
-void scan_map(image *screen, int sx, int sy, image *im1, image *im2, int fade256, long *paddr, mask_line *p, int mask_height, 
+void scan_map(image *screen, int sx, int sy, image *im1, image *im2, int fade256, int32_t *paddr, mask_line *p, int mask_height, 
               int xoff, int coff)
 {  
   int x1=10000,x2=0;
   int iw=im1->width();  
-  ushort r,off;
+  uint16_t r,off;
   int y=0;
-  uchar *l;
+  uint8_t *l;
 
   for (;y<mask_height;y++)
   {
     mask_line *n=p+y;
-    uchar *sl=screen->scan_line(y+sy)+sx+n->x;
-    uchar *sl2=im1->scan_line(y);
-    uchar *sl3=im2->scan_line(y);
+    uint8_t *sl=screen->scan_line(y+sy)+sx+n->x;
+    uint8_t *sl2=im1->scan_line(y);
+    uint8_t *sl3=im2->scan_line(y);
     l=n->light;
-    ushort *rem=n->remap;
+    uint16_t *rem=n->remap;
     if (sx+n->x<x1) x1=sx+n->x;    
     int x=0;
@@ -95 +95 @@
       if (off>=iw) off-=iw;
 
-      long p1=*(paddr+sl2[off]);
-      long p2=*(paddr+sl3[off]);
+      int32_t p1=*(paddr+sl2[off]);
+      int32_t p2=*(paddr+sl3[off]);
 
       int r1=p1>>16,g1=(p1>>8)&0xff,b1=p1&0xff;
@@ -104 +104 @@
           b3=b1+(b2-b1)*fade256/256;
 
-      uchar c=color_table->lookup_color(r3>>3,g3>>3,b3>>3);
+      uint8_t c=color_table->lookup_color(r3>>3,g3>>3,b3>>3);
                                 
       *sl=*(white_light+((*l)/2+28+jrand()%4)*256+c); 
@@ -123 +123 @@
 class ex_char { 
   public :
-  uchar frame,char_num;
+  uint8_t frame,char_num;
   int x,y;
   ex_char *next; 
@@ -175 +175 @@
             pal->find_closest(100,100,100),
             pal->find_closest(64,64,64)};
-  ushort sinfo[800*3],*si;
+  uint16_t sinfo[800*3],*si;
 
   for (si=sinfo,i=0;i<800;i++)
@@ -184 +184 @@
     screen->putpixel(si[-3],si[-2],si[-1]);
   }
-  long paddr[256];
+  int32_t paddr[256];
   if (old_pal)
   {
@@ -354 +354 @@
 
 
-  uchar cmap[32];
+  uint8_t cmap[32];
   for (i=0;i<32;i++)
     cmap[i]=pal->find_closest(i*256/32,i*256/32,i*256/32);
@@ -428 +428 @@
   fade_in(NULL,32);
 
-  uchar cmap[32];
+  uint8_t cmap[32];
   int i;
   for (i=0;i<32;i++)
@@ -480 +480 @@
   fade_in(im,32);
 
-  uchar cmap[32];
+  uint8_t cmap[32];
   int i;
   for (i=0;i<32;i++)

abuse/trunk/src/extend.cpp

@@ -4 +4 @@
 
   Simple object             (power ups, non-moving objects)
-    long x,y;
-    schar direction;
-    ushort otype,state
-    ushort current_frame;
+    int32_t x,y;
+    int8_t direction;
+    uint16_t otype,state
+    uint16_t current_frame;
     extension *
 
 
   Moving object             (simple lisp controlled characters)
-     uchar flags;
-     long xvel,yvel,xacel,yacel;
-     uchar fx,fy,fxvel,fyvel,fxacel,fyacel,aitype;
-     ushort aistate,aistate_time;
-     unsigned short hp,mp,
+     uint8_t flags;
+     int32_t xvel,yvel,xacel,yacel;
+     uint8_t fx,fy,fxvel,fyvel,fxacel,fyacel,aitype;
+     uint16_t aistate,aistate_time;
+     uint16_t hp,mp,
      extension *
 
 
   Complex objects          (can controll lights, other characters, and have a neural net ai)
-    uchar tobjs,tlights;
+    uint8_t tobjs,tlights;
     object_list *                       
     light_list *
     nnet_info *
-    schar fade_dir, frame_dir;        
-    unsigned char fade_count,fade_max;
+    int8_t fade_dir, frame_dir;        
+    uint8_t fade_count,fade_max;
     morph_char *morph_status;
 

abuse/trunk/src/game.cpp

@@ -71 +71 @@
 
 int registered=0;
-extern uchar chatting_enabled;
+extern uint8_t chatting_enabled;
 
 extern int confirm_quit();
@@ -686 +686 @@
 }
 
-void remap_area(image *screen, int x1, int y1, int x2, int y2, uchar *remap)
-{
-  uchar *sl=(uchar *)screen->scan_line(y1)+x1;
+void remap_area(image *screen, int x1, int y1, int x2, int y2, uint8_t *remap)
+{
+  uint8_t *sl=(uint8_t *)screen->scan_line(y1)+x1;
   int x,y,a=screen->width()-(x2-x1+1);
-  uchar c;
+  uint8_t c;
   for (y=y1;y<=y2;y++)
   {
@@ -826 +826 @@
     
     int bh=current_level->background_height(),bw=current_level->background_width();
-    ushort *bl;
+    uint16_t *bl;
     for (draw_y=yo,y=y1;y<=y2;y++,draw_y+=yinc)
     {
@@ -853 +853 @@
 //    server_check();
 
-  uchar rescan=0;  
+  uint8_t rescan=0;  
 
     int fw,fh;
@@ -918 +918 @@
         if (!(draw_y<ncy1 ||draw_y+yinc>=ncy2))
         {
-          ushort *cl=current_level->get_fgline(y)+x1;
-          uchar *sl1=screen->scan_line(draw_y)+xo;
+          uint16_t *cl=current_level->get_fgline(y)+x1;
+          uint8_t *sl1=screen->scan_line(draw_y)+xo;
           for (x=x1,draw_x=xo;x<=x2;x++,cl++,sl1+=xinc,draw_x+=xinc)
           {
@@ -929 +929 @@
 //            else fort_num=0;
 
-              uchar *sl2=get_fg(fort_num)->micro_image->scan_line(0);
-              uchar *sl3=sl1;
+              uint8_t *sl2=get_fg(fort_num)->micro_image->scan_line(0);
+              uint8_t *sl3=sl1;
               memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
               memcpy(sl3,sl2,AUTOTILE_WIDTH); sl2+=AUTOTILE_WIDTH; sl3+=scr_w;
@@ -949 +949 @@
       {
         
-        ushort *cl;
+        uint16_t *cl;
         if (y<fg_h)
           cl=current_level->get_fgline(y)+x1;
         else cl=NULL;
-        uchar *sl1=draw_y<ncy1 ? 0 : screen->scan_line(draw_y)+xo;
+        uint8_t *sl1=draw_y<ncy1 ? 0 : screen->scan_line(draw_y)+xo;
 
         for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++,sl1+=xinc)
@@ -1007 +1007 @@
       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
       {
-        ushort *cl=current_level->get_fgline(y)+x1;
+        uint16_t *cl=current_level->get_fgline(y)+x1;
         for (x=x1,draw_x=xo;x<=x2;x++,draw_x+=xinc,cl++)
         {
@@ -1041 +1041 @@
       for (y=y1,draw_y=yo;y<=y2;y++,draw_y+=yinc)
       {
-        ushort *cl;
+        uint16_t *cl;
         if (y<fg_h)
           cl=current_level->get_fgline(y)+x1;
@@ -1053 +1053 @@
             {
               point_list *p=get_fg(fort_num)->points;
-              uchar *d=p->data; 
+              uint8_t *d=p->data;       
               if (p->tot)
               {
@@ -1202 +1202 @@
   for (i=0;i<steps;i++)
   {
-    uchar *sl1=(uchar *)pal->addr();    
-    uchar *sl2=(uchar *)old_pal->addr();    
+    uint8_t *sl1=(uint8_t *)pal->addr();    
+    uint8_t *sl2=(uint8_t *)old_pal->addr();    
     int j;
     int v=(i+1)*256/steps;
@@ -1226 +1226 @@
   for (i=0;i<steps;i++)
   {
-    uchar *sl1=(uchar *)pal->addr();    
-    uchar *sl2=(uchar *)old_pal->addr();    
+    uint8_t *sl1=(uint8_t *)pal->addr();    
+    uint8_t *sl2=(uint8_t *)old_pal->addr();    
     int j;
     int v=(steps-i)*256/steps;
@@ -1248 +1248 @@
 }
 
-int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uchar *cmap, char color);
+int text_draw(int y, int x1, int y1, int x2, int y2, char *buf, JCFont *font, uint8_t *cmap, char color);
 
 void do_title()
@@ -1311 +1311 @@
 
                         fade_in( NULL, 16 );
-                        uchar cmap[32];
+                        uint8_t cmap[32];
                         for( i = 0; i < 32; i++ )
                         cmap[i] = pal->find_closest( i * 256 / 32, i * 256 / 32, i * 256 / 32 );
@@ -1733 +1733 @@
                                         {
                                                 if( chat && chat->chat_event( ev ) )
-                                                        base->packet.write_byte( SCMD_CHAT_KEYPRESS );
+                                                        base->packet.write_uint8( SCMD_CHAT_KEYPRESS );
                                                 else
-                                                        base->packet.write_byte( SCMD_KEYPRESS );
+                                                        base->packet.write_uint8( SCMD_KEYPRESS );
                                         }
                                         else
-                                                base->packet.write_byte( SCMD_EXT_KEYPRESS );
-                                        base->packet.write_byte( client_number() );
+                                                base->packet.write_uint8( SCMD_EXT_KEYPRESS );
+                                        base->packet.write_uint8( client_number() );
                                         if( ev.key > 256 )
-                                                base->packet.write_byte( ev.key - 256 );
+                                                base->packet.write_uint8( ev.key - 256 );
                                         else
-                                                base->packet.write_byte( ev.key );
+                                                base->packet.write_uint8( ev.key );
                                 }
                         }
@@ -1752 +1752 @@
                                 {
                                         if( ev.key < 256 )
-                                                base->packet.write_byte( SCMD_KEYRELEASE );
+                                                base->packet.write_uint8( SCMD_KEYRELEASE );
                                         else
-                                                base->packet.write_byte( SCMD_EXT_KEYRELEASE );
-                                        base->packet.write_byte( client_number() );
+                                                base->packet.write_uint8( SCMD_EXT_KEYRELEASE );
+                                        base->packet.write_uint8( client_number() );
                                         if( ev.key > 255 )
-                                                base->packet.write_byte( ev.key - 256 );
+                                                base->packet.write_uint8( ev.key - 256 );
                                         else
-                                                base->packet.write_byte( ev.key );
+                                                base->packet.write_uint8( ev.key );
                                 }
                         }
@@ -2032 +2032 @@
 
 
-      base->packet.write_byte(SCMD_SYNC);
-      base->packet.write_short(make_sync());
+      base->packet.write_uint8(SCMD_SYNC);
+      base->packet.write_uint16(make_sync());
 
       if (base->join_list)
-      base->packet.write_byte(SCMD_RELOAD);
+      base->packet.write_uint8(SCMD_RELOAD);
 
       //      printf("save tick %d, pk size=%d, rand_on=%d, sync=%d\n",current_level->tick_counter(),
@@ -2049 +2049 @@
   if (!(dev&EDIT_MODE) && current_level)
   {
-    uchar buf[PACKET_MAX_SIZE+1];
+    uint8_t buf[PACKET_MAX_SIZE+1];
     int size;
 

abuse/trunk/src/gamma.cpp

@@ -220 +220 @@
         for( int i = 0; i < 256; i++ )
         {
-                uchar oldr, oldg, oldb;
+                uint8_t oldr, oldg, oldb;
                 old_pal->get( i, oldr, oldg, oldb );
                 pal->set( i, (int)( pow( oldr / 255.0, gamma ) * 255 ),

abuse/trunk/src/go.cpp

@@ -60 +60 @@
 {
   load(fp,state_remap);
-  allow_dir=read_short(fp);
+  allow_dir=read_uint16(fp);
 }
 
@@ -118 +118 @@
 {
   load(fp,state_remap);  
-  dir=read_short(fp);  
-  speed=read_short(fp);  
+  dir=read_uint16(fp);  
+  speed=read_uint16(fp);  
 }
 
@@ -125 +125 @@
 { 
   game_object::save(fp); 
-  write_short(fp,dir);    
-  write_short(fp,speed);    
+  write_uint16(fp,dir);    
+  write_uint16(fp,speed);    
 }
 
@@ -268 +268 @@
 void sensor::save(FILE *fp) 
 { game_object::save(fp); 
-  write_short(fp,xrange);
-  write_short(fp,yrange);
-  write_short(fp,signal);  
-
-  write_byte(fp,strlen(aname())+1);
+  write_uint16(fp,xrange);
+  write_uint16(fp,yrange);
+  write_uint16(fp,signal);  
+
+  write_uint8(fp,strlen(aname())+1);
   fwrite(aname(),strlen(aname())+1,1,fp);  
 }
@@ -279 +279 @@
 {
   load(fp,state_remap);
-  xrange=read_short(fp);
-  yrange=read_short(fp);
-  signal=read_short(fp);  
+  xrange=read_uint16(fp);
+  yrange=read_uint16(fp);
+  signal=read_uint16(fp);  
 
   char name[200];
-  fread(name,read_byte(fp),1,fp);
+  fread(name,read_uint8(fp),1,fp);
   get_activate(name);
 }

abuse/trunk/src/imlib/filter.cpp

@@ -172 +172 @@
 {
   fp->seek(e->offset,0);
-  fp->read_short();
+  fp->read_uint16();
   int colors=32;
   color_table=(unsigned char *)jmalloc(colors*colors*colors,"color_filter : loaded");
@@ -187 +187 @@
 {
   int colors=32;
-  fp->write_short(colors);
+  fp->write_uint16(colors);
   return fp->write(color_table,colors*colors*colors)==colors*colors*colors;
 }
@@ -220 +220 @@
   screen->add_dirty(x,y,x+xl-1,y+yl-1);
 
-  uchar *pg1=screen->scan_line(y),*source,*dest;
-  uchar *pg2=im->scan_line(y1);
+  uint8_t *pg1=screen->scan_line(y),*source,*dest;
+  uint8_t *pg2=im->scan_line(y1);
   int i;
   for (int j=0;j<yl;j++)        

abuse/trunk/src/imlib/gifread.cpp

@@ -15 +15 @@
 
 struct {
-        unsigned short int      Width;
-        unsigned short int      Height;
-        unsigned char   ColorMap[3][256];
-        unsigned short int      BitPixel;
-        unsigned short int      ColorResolution;
-        unsigned short int      Background;
-        unsigned short int      AspectRatio;
+        uint16_t        Width;
+        uint16_t        Height;
+        uint8_t         ColorMap[3][256];
+        uint16_t        BitPixel;
+        uint16_t        ColorResolution;
+        uint16_t        Background;
+        uint16_t        AspectRatio;
 } GifScreen;
 
 struct {
-  unsigned short int w,h;
-  unsigned char color_info,background,reserved;
+  uint16_t w,h;
+  uint8_t color_info,background,reserved;
 } gif_screen;
 
 struct {
-  unsigned short int xoff,yoff,w,h;
-  unsigned char color_info;
+  uint16_t xoff,yoff,w,h;
+  uint8_t color_info;
 } gif_image;
 
@@ -37 +37 @@
 {
   char buf[100],er;
-  unsigned char sep;
+  uint8_t sep;
   unsigned int ncolors;
   FILE *fp;
@@ -53 +53 @@
       if (!strcmp("GIF87a",buf))
       {
-        fread((char *)&gif_screen.w,2,1,fp);
-        gif_screen.w=int_to_local(gif_screen.w);
-        fread((char *)&gif_screen.h,2,1,fp);
-        gif_screen.h=int_to_local(gif_screen.h);
-        fread((char *)&gif_screen.color_info,1,1,fp);
-        fread((char *)&gif_screen.background,1,1,fp);
-        if (fread((char *)&gif_screen.reserved,1,1,fp)==1)
+        fread((uint8_t *)&gif_screen.w,2,1,fp);
+        gif_screen.w=uint16_to_local(gif_screen.w);
+        fread((uint8_t *)&gif_screen.h,2,1,fp);
+        gif_screen.h=uint16_to_local(gif_screen.h);
+        fread((uint8_t *)&gif_screen.color_info,1,1,fp);
+        fread((uint8_t *)&gif_screen.background,1,1,fp);
+        if (fread((uint8_t *)&gif_screen.reserved,1,1,fp)==1)
         {
           if (gif_screen.color_info&128)
@@ -69 +69 @@
             if (pal)
             {  
-              if (fread((char *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
+              if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
             } else er=imMEMORY_ERROR;
           }
@@ -75 +75 @@
           { do
             {
-              if (fread((char *)&sep,1,1,fp)!=1)
+              if (fread((uint8_t *)&sep,1,1,fp)!=1)
                 er=imREAD_ERROR;
             } while (!er && sep!=',');
-            fread((char *)&gif_image.xoff,2,1,fp);
-            gif_image.xoff=int_to_local(gif_image.xoff);
-            fread((char *)&gif_image.yoff,2,1,fp);
-            gif_image.yoff=int_to_local(gif_image.yoff);
-            fread((char *)&gif_image.w,2,1,fp);
-            gif_image.w=int_to_local(gif_image.w);
-            fread((char *)&gif_image.h,2,1,fp);
-            gif_image.h=int_to_local(gif_image.h);
-            if (!er && (fread((char *)&gif_image.color_info,1,1,fp)==1))
+            fread((uint8_t *)&gif_image.xoff,2,1,fp);
+            gif_image.xoff=uint16_to_local(gif_image.xoff);
+            fread((uint8_t *)&gif_image.yoff,2,1,fp);
+            gif_image.yoff=uint16_to_local(gif_image.yoff);
+            fread((uint8_t *)&gif_image.w,2,1,fp);
+            gif_image.w=uint16_to_local(gif_image.w);
+            fread((uint8_t *)&gif_image.h,2,1,fp);
+            gif_image.h=uint16_to_local(gif_image.h);
+            if (!er && (fread((uint8_t *)&gif_image.color_info,1,1,fp)==1))
             {
               if (gif_image.color_info&128)
@@ -95 +95 @@
                 pal = new palette(ncolors);
                 if (pal)
-                { if (fread((char *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
+                { if (fread((uint8_t *)pal->addr(),1,ncolors*3,fp)!=ncolors*3) er=imREAD_ERROR;
                 } else er=imMEMORY_ERROR;
               }

abuse/trunk/src/imlib/glread.cpp

@@ -9 +9 @@
 {
   image *im,*sub;
-  unsigned short length,y;
-  unsigned char size,first,width,height,gsize,last;
+  uint16_t length,y;
+  uint8_t size,first,width,height,gsize,last;
   FILE *fp;
   fp=fopen(fn,"rb");
   if (!fp) return NULL;
-  fread(&length,1,2,fp);  length=int_to_local(length);
+  fread(&length,1,2,fp);  length=uint16_to_local(length);
   fread(&size,1,1,fp);
   fread(&first,1,1,fp);
@@ -45 +45 @@
   image *im;
   char x[4],bpp;
-  unsigned char *sl=NULL,esc,c,n,marker,vmode;
-  unsigned short w,h,len,bufsize,blocks,sn,esize,edesc;
+  uint8_t *sl=NULL,esc,c,n,marker,vmode;
+  uint16_t w,h,len,bufsize,blocks,sn,esize,edesc;
   int xx,yy;
   FILE *fp;
@@ -55 +55 @@
   fread(&w,1,2,fp);
   fread(&h,1,2,fp);
-  w=int_to_local(w);  h=int_to_local(h);
+  w=uint16_to_local(w);  h=uint16_to_local(h);
   fread(x,1,4,fp);
   fread(&bpp,1,1,fp);
@@ -66 +66 @@
   fread(&vmode,1,1,fp);
   fread(&edesc,1,2,fp);
-  edesc=int_to_local(edesc);
+  edesc=uint16_to_local(edesc);
   fread(&esize,1,2,fp);
-  esize=int_to_local(esize);
+  esize=uint16_to_local(esize);
   if (esize==768 && !pal)
   { pal=new palette(1<<bpp);
@@ -77 +77 @@
     fseek(fp,esize,SEEK_CUR);
   fread(&blocks,1,2,fp);
-  blocks=int_to_local(blocks);
+  blocks=uint16_to_local(blocks);
 
   yy=h; xx=w;
@@ -84 +84 @@
   {
     fread(&bufsize,1,2,fp);
-    bufsize=int_to_local(bufsize);
+    bufsize=uint16_to_local(bufsize);
     fread(&len,1,2,fp);
-    len=int_to_local(len);
+    len=uint16_to_local(len);
     fread(&esc,1,1,fp);
     while (yy>=0 && len)
@@ -113 +113 @@
         {
           fread(&sn,1,2,fp);
-          sn=int_to_local(sn);
+          sn=uint16_to_local(sn);
           fread(&c,1,1,fp);
           while (sn-- && yy>=0 && len)

abuse/trunk/src/imlib/image.cpp

@@ -12 +12 @@
 #include <stdlib.h>
 
-extern unsigned char current_background;
+extern uint8_t current_background;
 char *imerr_messages[]={"No error",
                         "Error occured while reading",
@@ -23 +23 @@
                         
                          
-short imerror=0;
-short swpfile_num=0;
-
-short current_error()
+int16_t imerror=0;
+int16_t swpfile_num=0;
+
+int16_t current_error()
 { return imerror; }
 
@@ -48 +48 @@
 }
 
-void set_error(short x)
+void set_error(int16_t x)
 { imerror=x; }
 
-short last_error()
-{
-  short ec;
+int16_t last_error()
+{
+  int16_t ec;
   ec=imerror;
   imerror=0;
@@ -62 +62 @@
 
 
-image_descriptor::image_descriptor(short length, short height,
+image_descriptor::image_descriptor(int16_t length, int16_t height,
                                    int keep_dirties, int static_memory)
 
@@ -72 +72 @@
 }
 
-void image::change_size(short new_width, short new_height, unsigned char *page)
+void image::change_size(int16_t new_width, int16_t new_height, uint8_t *page)
 {
   delete_page();
@@ -97 +97 @@
 }
 
-unsigned char image::pixel(short x, short y)
+uint8_t image::pixel(int16_t x, int16_t y)
 {
   CONDITION(x>=0 && x<width() && y>=0 && y<height(),
@@ -104 +104 @@
 }
 
-void image::putpixel(short x, short y, char color)
+void image::putpixel(int16_t x, int16_t y, char color)
 {
   CONDITION(x>=0 && x<width() && y>=0 && y<height(),
@@ -116 +116 @@
 
 
-image::image(short width, short height, unsigned char *page_buffer, short create_descriptor)
+image::image(int16_t width, int16_t height, uint8_t *page_buffer, int16_t create_descriptor)
 {
   w=width;
@@ -132 +132 @@
 image::image(spec_entry *e, bFILE *fp)
 {
-  short i; 
+  int16_t i; 
   fp->seek(e->offset,0);
-  w=fp->read_short();
-  h=fp->read_short();
+  w=fp->read_uint16();
+  h=fp->read_uint16();
   special=NULL;
   make_page(w,h,NULL);
@@ -145 +145 @@
 image::image(bFILE *fp)
 {
-  short i; 
-  w=fp->read_short();
-  h=fp->read_short();
+  int16_t i; 
+  w=fp->read_uint16();
+  h=fp->read_uint16();
   special=NULL;
   make_page(w,h,NULL);
@@ -172 +172 @@
 void image_init()
 {
-  unsigned char bt[2];
-  unsigned short wrd,*up;
+  uint8_t bt[2];
+  uint16_t wrd,*up;
   bt[0]=1;
   bt[1]=0;
-  up=(unsigned short *)bt;
-  wrd=int_to_intel(*up);
+  up=(uint16_t *)bt;
+  wrd=uint16_to_intel(*up);
   if (wrd!=0x01)
   { printf("Compiled under wrong ENDING-nes, edit system.h and try again\n");
@@ -187 +187 @@
 
 
-long image::total_pixels(unsigned char background)
-{
-  short i,j;
-  long co;
-  unsigned char *c;
+int32_t image::total_pixels(uint8_t background)
+{
+  int16_t i,j;
+  int32_t co;
+  uint8_t *c;
   for (co=0,i=height()-1;i>=0;i--)
   { c=scan_line(i);
@@ -200 +200 @@
 }
 
-void image::clear(short color)
-{
-  short i;
+void image::clear(int16_t color)
+{
+  int16_t i;
   if (color==-1) color=current_background;
   if (special)
@@ -220 +220 @@
 {
   image *im;
-  unsigned char *c,*dat;
+  uint8_t *c,*dat;
   int i;
-  dat=(unsigned char *)jmalloc(width(),"image copy");
+  dat=(uint8_t *)jmalloc(width(),"image copy");
   im=new image(width(),height());
   for (i=height()-1;i>=0;i--)
@@ -236 +236 @@
 
 
-void image::line(short x1, short y1,short x2, short y2, unsigned char color)
-{
-  short i,xc,yc,er,n,m,xi,yi,xcxi,ycyi,xcyi;
+void image::line(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
+{
+  int16_t i,xc,yc,er,n,m,xi,yi,xcxi,ycyi,xcyi;
   unsigned dcy,dcx;
   // check to make sure that both endpoint are on the screen
 
-  short cx1,cy1,cx2,cy2;
+  int16_t cx1,cy1,cx2,cy2;
 
   // check to see if the line is completly clipped off
@@ -378 +378 @@
 
 
-void image::put_image(image *screen, short x, short y, char transparent)
-{
-  short i,j,xl,yl;
-  unsigned char *pg1,*pg2,*source,*dest;
+void image::put_image(image *screen, int16_t x, int16_t y, char transparent)
+{
+  int16_t i,j,xl,yl;
+  uint8_t *pg1,*pg2,*source,*dest;
   if (screen->special)  // the screen is clipped then we onl want to put
                     // part of the image
@@ -417 +417 @@
 }
 
-void image::fill_image(image *screen, short x1, short y1, short x2, short y2, short allign)
-{
-  short i,j,w,xx,start,xl,starty;
-  unsigned char *pg1,*pg2;
+void image::fill_image(image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t allign)
+{
+  int16_t i,j,w,xx,start,xl,starty;
+  uint8_t *pg1,*pg2;
   CHECK(x1<=x2 && y1<=y2);  // we should have gotten this
 
@@ -467 +467 @@
 
 
-void image::put_part(image *screen, short x, short y,
-                short x1, short y1, short x2, short y2, char transparent)
-{
-  short xl,yl,j,i;
-  short cx1,cy1,cx2,cy2;
-  unsigned char *pg1,*pg2,*source,*dest;
+void image::put_part(image *screen, int16_t x, int16_t y,
+                int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
+{
+  int16_t xl,yl,j,i;
+  int16_t cx1,cy1,cx2,cy2;
+  uint8_t *pg1,*pg2,*source,*dest;
   CHECK(x1<=x2 && y1<=y2);
 
@@ -533 +533 @@
 }
 
-void image::put_part_xrev(image *screen, short x, short y,
-                short x1, short y1, short x2, short y2, char transparent)
-{
-  short xl,yl,j,i;
-  short cx1,cy1,cx2,cy2;
-  unsigned char *pg1,*pg2,*source,*dest;
+void image::put_part_xrev(image *screen, int16_t x, int16_t y,
+                int16_t x1, int16_t y1, int16_t x2, int16_t y2, char transparent)
+{
+  int16_t xl,yl,j,i;
+  int16_t cx1,cy1,cx2,cy2;
+  uint8_t *pg1,*pg2,*source,*dest;
   CHECK(x1<=x2 && y1<=y2);
 
@@ -596 +596 @@
 
 
-void image::put_part_masked(image *screen, image *mask, short x, short y,
-                short maskx, short masky,
-                short x1, short y1, short x2, short y2)
-{
-  short xl,yl,j,i,ml,mh;
-  short cx1,cy1,cx2,cy2;
-  unsigned char *pg1,*pg2,*pg3;
+void image::put_part_masked(image *screen, image *mask, int16_t x, int16_t y,
+                int16_t maskx, int16_t masky,
+                int16_t x1, int16_t y1, int16_t x2, int16_t y2)
+{
+  int16_t xl,yl,j,i,ml,mh;
+  int16_t cx1,cy1,cx2,cy2;
+  uint8_t *pg1,*pg2,*pg3;
   CHECK(x1<=x2 && y1<=y2);
 
@@ -658 +658 @@
 
 
-unsigned char image::brightest_color(palette *pal)
-{ unsigned char *p,r,g,b,bri;
-  short i,j;
-  long brv;
+uint8_t image::brightest_color(palette *pal)
+{ uint8_t *p,r,g,b,bri;
+  int16_t i,j;
+  int32_t brv;
   brv=0; bri=0;
   for (j=0;j<h;j++)
@@ -668 +668 @@
     for (i=0;i<w;i++)
     { pal->get(p[i],r,g,b);
-      if ((long)r*(long)g*(long)b>brv)
-      { brv=(long)r*(long)g*(long)b;
+      if ((int32_t)r*(int32_t)g*(int32_t)b>brv)
+      { brv=(int32_t)r*(int32_t)g*(int32_t)b;
         bri=p[i];
       }
@@ -677 +677 @@
 }
 
-unsigned char image::darkest_color(palette *pal, short noblack)
-{ unsigned char *p,r,g,b,bri;
-  short i,j;
-  long brv,x;
-  brv=(long)258*(long)258*(long)258; bri=0;
+uint8_t image::darkest_color(palette *pal, int16_t noblack)
+{ uint8_t *p,r,g,b,bri;
+  int16_t i,j;
+  int32_t brv,x;
+  brv=(int32_t)258*(int32_t)258*(int32_t)258; bri=0;
   for (j=0;j<h;j++)
   {
@@ -687 +687 @@
     for (i=0;i<w;i++)
     { pal->get(p[i],r,g,b);
-      x=(long)r*(long)g*(long)b;
+      x=(int32_t)r*(int32_t)g*(int32_t)b;
       if (x<brv && (x || !noblack))
       { brv=x;
@@ -697 +697 @@
 }
 
-void image::rectangle(short x1, short y1,short x2, short y2, unsigned char color)
+void image::rectangle(int16_t x1, int16_t y1,int16_t x2, int16_t y2, uint8_t color)
 {
   line(x1,y1,x2,y1,color);
@@ -705 +705 @@
 }
 
-void image::set_clip(short x1, short y1, short x2, short y2)
+void image::set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
 {
   // If the image does not already have an Image descriptor, allocate one.
@@ -718 +718 @@
 }
 
-void image::get_clip (short &x1, short &y1, short &x2, short &y2)
+void image::get_clip (int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
 {
   if (special)
@@ -726 +726 @@
 }
 
-void image::in_clip  (short x1, short y1, short x2, short y2)
+void image::in_clip  (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
 {
   if (special)
@@ -747 +747 @@
 {
   dirty_rect *p,*q;
-  short x1,y1,x2,y2,nn;
+  int16_t x1,y1,x2,y2,nn;
   x1=6000; y1=6000;
   x2=0; y2=0;
@@ -769 +769 @@
 void image_descriptor::delete_dirty(int x1, int y1, int x2, int y2)
 {
-  short i,ax1,ay1,ax2,ay2;
+  int16_t i,ax1,ay1,ax2,ay2;
   dirty_rect *p,*next;
   if (keep_dirt)
@@ -869 +869 @@
 void image_descriptor::add_dirty(int x1, int y1, int x2, int y2)
 {
-  short i;
+  int16_t i;
   dirty_rect *p;
   if (keep_dirt)
@@ -941 +941 @@
 }
 
-void image::bar      (short x1, short y1, short x2, short y2, unsigned char color)
-{
-  short y;
+void image::bar      (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
+{
+  int16_t y;
   if (x1>x2 || y1>y2) return ;
   if (special)
@@ -964 +964 @@
 }
 
-void image::xor_bar  (short x1, short y1, short x2, short y2, unsigned char color)
-{
-  short y,x;
+void image::xor_bar  (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color)
+{
+  int16_t y,x;
   if (x1>x2 || y1>y2) return ;
   if (special)
@@ -983 +983 @@
     return ;
 
-  unsigned char *sl=scan_line(y1)+x1; 
+  uint8_t *sl=scan_line(y1)+x1; 
   for (y=y1;y<=y2;y++)
   {
-    unsigned char *s=sl;
+    uint8_t *s=sl;
     for (x=x1;x<=x2;x++,s++)
       *s=(*s)^color;
@@ -996 +996 @@
 
 
-void image::unpack_scanline(short line, char bitsperpixel)
-{
-  short x;
-  unsigned char *sl,*ex,mask,bt,sh;
-  ex=(unsigned char *)jmalloc(width(),"image::unpacked scanline");
+void image::unpack_scanline(int16_t line, char bitsperpixel)
+{
+  int16_t x;
+  uint8_t *sl,*ex,mask,bt,sh;
+  ex=(uint8_t *)jmalloc(width(),"image::unpacked scanline");
   sl=scan_line(line);
   memcpy(ex,sl,width());
@@ -1018 +1018 @@
 void image::dither(palette *pal)
 {
-  short x,y,i,j;
-  unsigned char dt_matrix[]={0,  136,24, 170,
+  int16_t x,y,i,j;
+  uint8_t dt_matrix[]={0,  136,24, 170,
                    68, 204,102,238,
                    51, 187, 17,153,
                    119,255, 85,221};
 
-  unsigned char *sl;
+  uint8_t *sl;
   for (y=height()-1;y>=0;y--)
   {
@@ -1049 +1049 @@
 }
 
-void image::resize(short new_width, short new_height)
+void image::resize(int16_t new_width, int16_t new_height)
 {
   int old_width=width(),old_height=height();
-  unsigned char *im=(unsigned char *)jmalloc(width()*height(),"image::resized");
+  uint8_t *im=(uint8_t *)jmalloc(width()*height(),"image::resized");
   memcpy(im,scan_line(0),width()*height());
 
@@ -1060 +1060 @@
   h=new_height;
 
-  unsigned char *sl1,*sl2;
-  short y,y2,x2;
+  uint8_t *sl1,*sl2;
+  int16_t y,y2,x2;
   double yc,xc,yd,xd;
 
@@ -1080 +1080 @@
 }
 
-void image::scroll(short x1, short y1, short x2, short y2, short xd, short yd)
-{
-  short cx1,cy1,cx2,cy2;
+void image::scroll(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd)
+{
+  int16_t cx1,cy1,cx2,cy2;
   CHECK(x1>=0 && y1>=0 && x1<x2 && y1<y2 && x2<width() && y2<height());
   if (special)
@@ -1089 +1089 @@
     x1=max(x1,cx1); y1=max(cy1,y1); x2=min(x2,cx2); y2=min(y2,cy2);
   }
-  short xsrc,ysrc,xdst,ydst,xtot=x2-x1-abs(xd)+1,ytot,xt;
-  unsigned char *src,*dst;
+  int16_t xsrc,ysrc,xdst,ydst,xtot=x2-x1-abs(xd)+1,ytot,xt;
+  uint8_t *src,*dst;
   if (xd<0) { xsrc=x1-xd; xdst=x1; } else { xsrc=x2-xd; xdst=x2; }
   if (yd<0) { ysrc=y1-yd; ydst=y1; } else { ysrc=y2-yd; ydst=y2; }
@@ -1107 +1107 @@
 
 
-image *image::create_smooth(short smoothness)
-{
-  short i,j,k,l,t,d;
+image *image::create_smooth(int16_t smoothness)
+{
+  int16_t i,j,k,l,t,d;
   image *im;
   CHECK(smoothness>=0);
@@ -1129 +1129 @@
 }
 
-void image::wiget_bar(short x1, short y1, short x2, short y2, 
-        unsigned char light, unsigned char med, unsigned char dark)
+void image::wiget_bar(int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
+        uint8_t light, uint8_t med, uint8_t dark)
 {
   line(x1,y1,x2,y1,light);
@@ -1142 +1142 @@
 {
 public :
-  short x,y;
+  int16_t x,y;
   fill_rec *last;
-  fill_rec(short X, short Y, fill_rec *Last)
+  fill_rec(int16_t X, int16_t Y, fill_rec *Last)
   { x=X; y=Y; last=Last; }
 } ;
 
-void image::flood_fill(short x, short y, unsigned char color)
-{
-  unsigned char *sl,*above,*below;
+void image::flood_fill(int16_t x, int16_t y, uint8_t color)
+{
+  uint8_t *sl,*above,*below;
   fill_rec *recs=NULL,*r;
-  unsigned char fcolor;
+  uint8_t fcolor;
   sl=scan_line(y);
   fcolor=sl[x];
@@ -1231 +1231 @@
 #define LED_L 5
 #define LED_H 5
-void image::burn_led(short x, short y, long num, short color, short scale)
+void image::burn_led(int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale)
 {
   char st[100];
-  short ledx[]={1,2,1,2,3,3,3,3,1,2,0,0,0,0};
-  short ledy[]={3,3,0,0,1,2,4,6,7,7,4,6,1,2};
-
-  short dig[]={2+4+8+16+32+64,4+8,2+4+1+32+16,2+4+1+8+16,64+1+4+8,
+  int16_t ledx[]={1,2,1,2,3,3,3,3,1,2,0,0,0,0};
+  int16_t ledy[]={3,3,0,0,1,2,4,6,7,7,4,6,1,2};
+
+  int16_t dig[]={2+4+8+16+32+64,4+8,2+4+1+32+16,2+4+1+8+16,64+1+4+8,
              2+64+1+8+16,64+32+1+8+16,2+4+8,1+2+4+8+16+32+64,64+2+4+1+8,1};
-  short xx,yy,zz;
-  sprintf(st,"%8ld",num);
+  int16_t xx,yy,zz;
+  sprintf(st,"%8ld",(long int)num);
   for (xx=0;xx<8;xx++)
   {
@@ -1258 +1258 @@
 }
 
-unsigned char dither_matrix[]={0,  136,24, 170,
+uint8_t dither_matrix[]={0,  136,24, 170,
                      68, 204,102,238,
                      51, 187, 17,153,
                      119,255, 85,221};
 
-image *image::copy_part_dithered (short x1, short y1, short x2, short y2)
-{
-  short x,y,cx1,cy1,cx2,cy2,ry,rx,bo,dity,ditx;
+image *image::copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2)
+{
+  int16_t x,y,cx1,cy1,cx2,cy2,ry,rx,bo,dity,ditx;
   image *ret;
-  unsigned char *sl1,*sl2;
+  uint8_t *sl1,*sl2;
   get_clip(cx1,cy1,cx2,cy2);
   if (y1<cy1) y1=cy1;
@@ -1304 +1304 @@
 void image::flip_x()
 {
-  unsigned char *rev=(unsigned char *)jmalloc(width(),"image tmp::flipped_x"),*sl;
+  uint8_t *rev=(uint8_t *)jmalloc(width(),"image tmp::flipped_x"),*sl;
   CONDITION(rev,"memory allocation"); 
   int y,x,i;
@@ -1318 +1318 @@
 void image::flip_y()
 {
-  unsigned char *rev=(unsigned char *)jmalloc(width(),"image::flipped_y"),*sl;
+  uint8_t *rev=(uint8_t *)jmalloc(width(),"image::flipped_y"),*sl;
   CONDITION(rev,"memory allocation"); 
   int y;
@@ -1329 +1329 @@
 }
 
-void image::make_color(unsigned char color)
-{
-  unsigned char *sl;
+void image::make_color(uint8_t color)
+{
+  uint8_t *sl;
   int y,x;
   for (y=0;y<height();y++)

abuse/trunk/src/imlib/include/image.hpp

@@ -19 +19 @@
 #define imMAX_ERROR            7
 
-short current_error();
+int16_t current_error();
 void clear_errors();
-void set_error(short x);
-short last_error();
+void set_error(int16_t x);
+int16_t last_error();
 void make_block(size_t size);
 void image_init();
@@ -30 +30 @@
 typedef struct image_color_t
 {
-        unsigned short r;
-        unsigned short g;
-        unsigned short b;
+        uint16_t r;
+        uint16_t g;
+        uint16_t b;
 } image_color;
 
@@ -41 +41 @@
 {
 public :
-  short dx1,dy1,dx2,dy2;
-  dirty_rect(short x1, short y1, short x2, short y2)
+  int16_t dx1,dy1,dx2,dy2;
+  dirty_rect(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
   { dx1=x1; dy1=y1; dx2=x2; dy2=y2; 
     if (x2<x1 || y2<y1) 
       printf("add inccorect dirty\n");
   }
-  virtual short compare(void *n1, short field)
+  virtual int16_t compare(void *n1, int16_t field)
   { return ((dirty_rect *)n1)->dy1>dy1; }
 } ;
@@ -53 +53 @@
 class image_descriptor
 {
-  short l,h;
-  short clipx1, clipy1, clipx2, clipy2;
+  int16_t l,h;
+  int16_t clipx1, clipy1, clipx2, clipy2;
 public :  
-  unsigned char keep_dirt,
-                static_mem;      // if this flag is set then don't free memory on exit
+  uint8_t keep_dirt,
+          static_mem;      // if this flag is set then don't free memory on exit
   
   linked_list dirties;
   void *extended_descriptor;              // type depends on current system
 
-  image_descriptor(short length, short height,
+  image_descriptor(int16_t length, int16_t height,
                   int keep_dirties=1, int static_memory=0);
-  short bound_x1(short x1)  { return x1<clipx1 ? clipx1 : x1; }
-  short bound_y1(short y1)  { return y1<clipy1 ? clipy1 : y1; }
-  short bound_x2(short x2)  { return x2>clipx2 ? clipx2 : x2; }
-  short bound_y2(short y2)  { return y2>clipy2 ? clipy2 : y2; }
-  short x1_clip() { return clipx1; }
-  short y1_clip() { return clipy1; }
-  short x2_clip() { return clipx2; }
-  short y2_clip() { return clipy2; }
-  void dirty_area(short x1, short y1, short x2, short y2) { ;}
-  void clean_area(short x1, short y1, short x2, short y2) { ; }
+  int16_t bound_x1(int16_t x1)  { return x1<clipx1 ? clipx1 : x1; }
+  int16_t bound_y1(int16_t y1)  { return y1<clipy1 ? clipy1 : y1; }
+  int16_t bound_x2(int16_t x2)  { return x2>clipx2 ? clipx2 : x2; }
+  int16_t bound_y2(int16_t y2)  { return y2>clipy2 ? clipy2 : y2; }
+  int16_t x1_clip() { return clipx1; }
+  int16_t y1_clip() { return clipy1; }
+  int16_t x2_clip() { return clipx2; }
+  int16_t y2_clip() { return clipy2; }
+  void dirty_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ;}
+  void clean_area(int16_t x1, int16_t y1, int16_t x2, int16_t y2) { ; }
   void clear_dirties();
-  short get_dirty_area(short &x1, short &y1, short &x2, short &y2) { return 0; }
-  void get_clip(short &x1, short &y1, short &x2, short &y2)
+  int16_t get_dirty_area(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2) { return 0; }
+  void get_clip(int16_t &x1, int16_t &y1, int16_t &x2, int16_t &y2)
     { x1=clipx1; y1=clipy1; x2=clipx2; y2=clipy2; }
-  void set_clip(short x1, short y1, short x2, short y2)
+  void set_clip(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
     { if (x2<x1) x2=x1;
       if (y2<y1) y2=y1;
@@ -89 +89 @@
   void add_dirty(int x1, int y1, int x2, int y2);
   void delete_dirty(int x1, int y1, int x2, int y2);
-  void resize(short length, short height)
+  void resize(int16_t length, int16_t height)
    { l=length; h=height; clipx1=0; clipy1=0; clipx2=l-1; clipy2=h-1; }
 } ;
@@ -95 +95 @@
 class image : public linked_node
 { 
-  unsigned char *data;
-  short w,h;
-  void make_page(short width, short height, unsigned char *page_buffer);
+  uint8_t *data;
+  int16_t w,h;
+  void make_page(int16_t width, int16_t height, uint8_t *page_buffer);
   void delete_page();
 public :
@@ -103 +103 @@
   image(spec_entry *e, bFILE *fp);
   image(bFILE *fp);
-  image(short width, short height,                 // required
-        unsigned char *page_buffer=NULL,
-        short create_descriptor=0);        // 0=no, 1=yes, 2=yes & keep dirties
-  unsigned char  pixel              (short x, short y);
-  void           putpixel           (short x, short y, char color);
-  unsigned char *scan_line          (short y) { return data+y*w; }
-  unsigned char *next_line          (short lasty, unsigned char *last_scan) 
+  image(int16_t width, int16_t height,                 // required
+        uint8_t *page_buffer=NULL,
+        int16_t create_descriptor=0);        // 0=no, 1=yes, 2=yes & keep dirties
+  uint8_t  pixel              (int16_t x, int16_t y);
+  void     putpixel           (int16_t x, int16_t y, char color);
+  uint8_t *scan_line          (int16_t y) { return data+y*w; }
+  uint8_t *next_line          (int16_t lasty, uint8_t *last_scan) 
                                     { return last_scan+w; }          
-  long           total_pixels       (unsigned char background=0);
-  image         *copy               ();    // makes a copy of an image
-  void           clear              (short color=-1);  // -1 is background color
-  void           to_24bit           (palette &pal);
-  short          width              () { return (short)w; }
-  short          height             () { return (short)h; }
-  void           scroll             (short x1, short y1, short x2, short y2, short xd, short yd);
-  void           fill_image         (image *screen, short x1, short y1, short x2, short y2, 
-                                     short allign=1);
-  void           put_image          (image *screen, short x, short y, char transparent=0);
-  void           put_part           (image *screen, short x, short y, short x1, short y1, 
-                                     short x2, short y2, char transparent=0);
-  void           put_part_xrev      (image *screen, short x, short y, short x1, short y1, 
-                                     short x2, short y2, char transparent=0);
-  void           put_part_masked    (image *screen, image *mask, short x, short y, 
-                                     short maskx, short masky, short x1, short y1, short x2, short y2);
-  image         *copy_part_dithered (short x1, short y1, short x2, short y2);
-  void           bar                (short x1, short y1, short x2, short y2, unsigned char color);
-  void           xor_bar            (short x1, short y1, short x2, short y2, unsigned char color);
-  void           wiget_bar          (short x1, short y1, short x2, short y2, 
-                                     unsigned char light, unsigned char med, unsigned char dark);
-  void           line               (short x1, short y1, short x2, short y2, unsigned char color);
-  void           rectangle          (short x1, short y1, short x2, short y2, unsigned char color);
-  void           burn_led           (short x, short y, long num, short color, short scale=1);
-  void           set_clip           (short x1, short y1, short x2, short y2);
-  void           get_clip           (short &x1,short &y1,short &x2,short &y2);
-  void           in_clip            (short x1, short y1, short x2, short y2);
+  int32_t  total_pixels       (uint8_t background=0);
+  image    *copy               ();    // makes a copy of an image
+  void     clear              (int16_t color=-1);  // -1 is background color
+  void     to_24bit           (palette &pal);
+  int16_t  width              () { return (int16_t)w; }
+  int16_t  height             () { return (int16_t)h; }
+  void     scroll             (int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t xd, int16_t yd);
+  void     fill_image         (image *screen, int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
+                              int16_t allign=1);
+  void     put_image          (image *screen, int16_t x, int16_t y, char transparent=0);
+  void     put_part           (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
+                                     int16_t x2, int16_t y2, char transparent=0);
+  void     put_part_xrev      (image *screen, int16_t x, int16_t y, int16_t x1, int16_t y1, 
+                                     int16_t x2, int16_t y2, char transparent=0);
+  void     put_part_masked    (image *screen, image *mask, int16_t x, int16_t y, 
+                                     int16_t maskx, int16_t masky, int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+  image    *copy_part_dithered (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+  void     bar                (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+  void     xor_bar            (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+  void     wiget_bar          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, 
+                                     uint8_t light, uint8_t med, uint8_t dark);
+  void     line               (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+  void     rectangle          (int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t color);
+  void     burn_led           (int16_t x, int16_t y, int32_t num, int16_t color, int16_t scale=1);
+  void     set_clip           (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
+  void     get_clip           (int16_t &x1,int16_t &y1,int16_t &x2,int16_t &y2);
+  void     in_clip            (int16_t x1, int16_t y1, int16_t x2, int16_t y2);
 
-  void           dirt_off           () { if (special && special->keep_dirt) special->keep_dirt=0; }
-  void           dirt_on            () { if (special) special->keep_dirt=1; }
+  void     dirt_off           () { if (special && special->keep_dirt) special->keep_dirt=0; }
+  void     dirt_on            () { if (special) special->keep_dirt=1; }
 
-  void           add_dirty          (int x1, int y1, int x2, int y2) 
+  void     add_dirty          (int x1, int y1, int x2, int y2) 
                                     { if (special) special->add_dirty(x1,y1,x2,y2); }
-  void           delete_dirty       (int x1, int y1, int x2, int y2) 
+  void     delete_dirty       (int x1, int y1, int x2, int y2) 
                                     { if (special) special->delete_dirty(x1,y1,x2,y2); }
-  void           clear_dirties      () { if (special) special->clear_dirties(); }
-  void           dither             (palette *pal); // use a b&w palette!
-  void           resize             (short new_width, short new_height);
-  void           change_size        (short new_width, short new_height, unsigned char *page=NULL);
-  void           flood_fill         (short x, short y, unsigned char color);
-  image         *create_smooth      (short smoothness=1); // 0 no smoothness
-  void           unpack_scanline    (short line, char bitsperpixel=1);
-  unsigned char  brightest_color    (palette *pal);
-  void           flip_x             ();
-  void           flip_y             ();
-  void           make_color         (unsigned char color);
-  unsigned char  darkest_color      (palette *pal, short noblack=0);
+  void     clear_dirties      () { if (special) special->clear_dirties(); }
+  void     dither             (palette *pal); // use a b&w palette!
+  void     resize             (int16_t new_width, int16_t new_height);
+  void     change_size        (int16_t new_width, int16_t new_height, uint8_t *page=NULL);
+  void     flood_fill         (int16_t x, int16_t y, uint8_t color);
+  image    *create_smooth     (int16_t smoothness=1); // 0 no smoothness
+  void     unpack_scanline    (int16_t line, char bitsperpixel=1);
+  uint8_t  brightest_color    (palette *pal);
+  void     flip_x             ();
+  void     flip_y             ();
+  void     make_color         (uint8_t color);
+  uint8_t  darkest_color      (palette *pal, int16_t noblack=0);
 
   ~image();

abuse/trunk/src/imlib/include/jmalloc.hpp

@@ -8 +8 @@
 enum {ALLOC_SPACE_STATIC,ALLOC_SPACE_CACHE};
 extern int alloc_space;
-void *jmalloc(long size, char *what_for);
-void *jrealloc(void *ptr, long size, char *what_for);
+void *jmalloc(int32_t size, char *what_for);
+void *jrealloc(void *ptr, int32_t size, char *what_for);
 void jfree(void *ptr);
 void mem_report(char *filename);
-void jmalloc_init(long min_size);
+void jmalloc_init(int32_t min_size);
 void jmalloc_uninit();
-long j_allocated();
-long j_available();
+int32_t j_allocated();
+int32_t j_available();
 extern void free_up_memory();
 #else

abuse/trunk/src/imlib/include/jwindow.hpp

@@ -69 +69 @@
 struct jwindow_properties
 {
-  uchar moveable,
-        hidden;
-  
+  uint8_t moveable,
+          hidden;
 } ;
 

abuse/trunk/src/imlib/include/macs.hpp

@@ -24 +24 @@
 #endif
 
-#define uchar  unsigned char
-#define schar  signed char
+//#define uchar  unsigned char
+//#define schar  signed char
 //#define ushort unsigned short
-typedef unsigned short int ushort;
-#define sshort signed short
+//typedef unsigned short int ushort;
+//#define sshort signed short
 //#define ulong  unsigned long
-typedef unsigned long int ulong;
+//typedef unsigned long int ulong;
 
 #endif

abuse/trunk/src/imlib/include/packet.hpp

@@ -5 +5 @@
 {
   public :
-  uchar *buf;
-  long buf_size,ro,wo,rend;
+  uint8_t *buf;
+  int32_t buf_size,ro,wo,rend;
   int pre_size;
   void make_bigger(int max);
@@ -12 +12 @@
   int get_read_position() { return ro; }
   void set_read_position(int x) { ro=x; }
-  int read(uchar *buffer, int size);
-  int write(uchar *buffer, int size);
+  int read(uint8_t *buffer, int size);
+  int write(uint8_t *buffer, int size);
   int eop() { return ro>=rend; }
   void reset();
   packet(int prefix_size=2);
   void get_string(char *st, int len);
-  int advance(long offset);
+  int advance(int32_t offset);
 
-  void write_long(ulong x);      // writes can't fail...
-  void write_short(ushort x);
-  void write_byte(uchar x);
+  void write_uint32(uint32_t x);      // writes can't fail...
+  void write_uint16(uint16_t x);
+  void write_uint8(uint8_t x);
   void insert_into(packet &pk);
   int size() { return rend-pre_size; }

abuse/trunk/src/imlib/include/scroller.hpp

@@ -51 +51 @@
   protected :
   int r,c,m,last_sel,cur_sel;
-  uchar *select;
+  uint8_t *select;
   public :
   spicker(int X, int Y, int ID, int Rows, int Cols, int Vert, int MultiSelect, ifield *Next);

abuse/trunk/src/imlib/include/specs.hpp

@@ -97 +97 @@
 
   // these read and writes, allways read/write Intel endian-ness
-  uint16_t read_short();
-  uint32_t read_long();
-  uint8_t read_byte();
+  uint16_t read_uint16();
+  uint32_t read_uint32();
+  uint8_t read_uint8();
   double read_double();
-  void write_short(uint16_t x);
-  void write_long(uint32_t x);
-  void write_byte(uint8_t x);
+  void write_uint16(uint16_t x);
+  void write_uint32(uint32_t x);
+  void write_uint8(uint8_t x);
   void write_double(double x);
   void set_read_buffer_size(long size);
@@ -194 +194 @@
                          char *link_filename=NULL);*/
 
-uint16_t read_short(FILE *fp);
-uint32_t read_long(FILE *fp);
-uint32_t read_other_long(FILE *fp);
-uint16_t read_other_short(FILE *fp);
-uint8_t read_byte(FILE *fp);
-
-void write_short(FILE *fp, uint16_t x);
-void write_long(FILE *fp, uint32_t x);
-void write_other_short(FILE *fp, uint16_t x);
-void write_other_long(FILE *fp, uint32_t x);
-void write_byte(FILE *fp, uint8_t x);
+uint16_t read_uint16(FILE *fp);
+uint32_t read_uint32(FILE *fp);
+uint32_t read_other_uint32(FILE *fp);
+uint16_t read_other_uint16(FILE *fp);
+uint8_t read_uint8(FILE *fp);
+
+void write_uint16(FILE *fp, uint16_t x);
+void write_uint32(FILE *fp, uint32_t x);
+void write_other_uint16(FILE *fp, uint16_t x);
+void write_other_uint32(FILE *fp, uint32_t x);
+void write_uint8(FILE *fp, uint8_t x);
 
 void set_spec_main_file(char *filename, int Search_order);

abuse/trunk/src/imlib/include/system.h

@@ -30 +30 @@
 
 
-#define short_swap(x) (((((uint16_t) (x)))<<8)|((((uint16_t) (x)))>>8))
-#define long_swap(x) \
+#define uint16_swap(x) (((((uint16_t) (x)))<<8)|((((uint16_t) (x)))>>8))
+#define uint32_swap(x) \
    ((( ((uint32_t)(x)) )>>24)|((( ((uint32_t)(x)) )&0x00ff0000)>>8)| \
    ((( ((uint32_t)(x)) )&0x0000ff00)<<8)|(( ((uint32_t)(x)) )<<24))
@@ -37 +37 @@
 #if defined BIG_ENDIANS
 #define LONG int32_t
-#define int_to_intel(x) short_swap(x)
-#define int_to_local(x) int_to_intel(x)
-#define big_long_to_local(x) (x)
-#define big_short_to_local(x) (x)
-#define long_to_intel(x) long_swap(x)
-#define long_to_local(x) long_to_intel(x)
+#define uint16_to_intel(x) uint16_swap(x)
+#define uint16_to_local(x) uint16_to_intel(x)
+#define big_uint32_to_local(x) (x)
+#define big_uint16_to_local(x) (x)
+#define uint32_to_intel(x) uint32_swap(x)
+#define uint32_to_local(x) uint32_to_intel(x)
 #else
 #define LONG int32_t
-#define int_to_intel(x) (x)
-#define int_to_local(x) (x)
-#define long_to_local(x) (x)
-#define long_to_intel(x) (x)
-#define big_long_to_local(x) long_swap(x)
-#define big_short_to_local(x) short_swap(x)
+#define uint16_to_intel(x) (x)
+#define uint16_to_local(x) (x)
+#define uint32_to_local(x) (x)
+#define uint32_to_intel(x) (x)
+#define big_uint32_to_local(x) uint32_swap(x)
+#define big_uint16_to_local(x) uint16_swap(x)
 #endif
 
-#define bltl(x) big_long_to_local(x)
-#define bstl(x) big_short_to_local(x)
-#define lltl(x) long_to_intel(x)
-#define lstl(x) int_to_intel(x)
+#define bltl(x) big_uint32_to_local(x)
+#define bstl(x) big_uint16_to_local(x)
+#define lltl(x) uint32_to_intel(x)
+#define lstl(x) uint16_to_intel(x)
 
 #endif

abuse/trunk/src/imlib/include/timage.hpp

@@ -28 +28 @@
   // if screen x & y offset already calculated save a mul
   // and no clipping, but fast use this
-  void put_image_offseted(image *screen, uchar *s_off);   
+  void put_image_offseted(image *screen, uint8_t *s_off);   
   void put_image_filled(image *screen, int x, int y, 
-                        uchar fill_color);
+                        uint8_t fill_color);
   void put_fade(image *screen, int x, int y,
                            int frame_on, int total_frames, 
@@ -36 +36 @@
   void put_fade_tint(image *screen, int x, int y,
                      int frame_on, int total_frames, 
-                     uchar *tint,
+                     uint8_t *tint,
                      color_filter *f, palette *pal);
   void put_color(image *screen, int x, int y, int color);

abuse/trunk/src/imlib/jmalloc.cpp

@@ -13 +13 @@
 
 #include "jmalloc.hpp"
-#define uchar unsigned char
 #define JM_SMALL_SIZE 128      // above 128 bytes is considered to be a big block and no hashing is done
 int alloc_space=ALLOC_SPACE_STATIC;
@@ -29 +28 @@
 struct memory_node
 {
-  long size;
+  int32_t size;
 #ifdef MEM_CHECK
   char *name;                     // name is allocated on regular heap
@@ -40 +39 @@
 struct small_block
 {  
-  unsigned long size;             // size of blocks...
+  uint32_t size;             // size of blocks...
   uint32_t alloc_list;            // bit field saying weither each block is allocated or not.
   small_block *next;              // next small block of same size
@@ -54 +53 @@
   public :
 
-  long block_size;                             // size of this memory_block
+  int32_t block_size;                             // size of this memory_block
   small_block *sblocks[JM_SMALL_SIZE];
   small_block *cblocks[JM_SMALL_SIZE];
@@ -61 +60 @@
   memory_node *sfirst,*slast,
               *cfirst;
-  unsigned char block_type;
-
-  void init(void *block, long Block_size, uchar type);
-  void *static_alloc(long size, char *name);
-  void *cache_alloc(long size, char *name);
+  uint8_t block_type;
+
+  void init(void *block, int32_t Block_size, uint8_t type);
+  void *static_alloc(int32_t size, char *name);
+  void *cache_alloc(int32_t size, char *name);
   void static_free(void *ptr);
   void cache_free(void *ptr);
-  long available();
-  long allocated();
-  long pointer_size(void *ptr);
+  int32_t available();
+  int32_t allocated();
+  int32_t pointer_size(void *ptr);
   void report(FILE *fp);
   void inspect();
@@ -90 +89 @@
 int block_manager::valid_static_ptr(void *ptr)
 {
-  void *next=(void *)(*(((long *)ptr)-1));
+  void *next=(void *)(*(((int32_t *)ptr)-1));
   if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
   {
@@ -111 +110 @@
 int block_manager::valid_cache_ptr(void *ptr)
 {
-  void *next=(void *)(*(((long *)ptr)-1));
+  void *next=(void *)(*(((int32_t *)ptr)-1));
   if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
   {
@@ -274 +273 @@
 }
 
-long block_manager::pointer_size(void *ptr)
+int32_t block_manager::pointer_size(void *ptr)
 {
   void *next=(void *)(*(((intptr_t *)ptr)-1));
@@ -282 +281 @@
 }
 
-long block_manager::available()
-{
-  long size=0;
+int32_t block_manager::available()
+{
+  int32_t size=0;
   memory_node *f;
   for (f=sfirst;f;f=f->next)
@@ -294 +293 @@
 }
 
-long block_manager::allocated()
-{
-  long size=0;
+int32_t block_manager::allocated()
+{
+  int32_t size=0;
   memory_node *f;
   for (f=sfirst;f;f=f->next)
@@ -306 +305 @@
 }
 
-void block_manager::init(void *block, long Block_size, uchar type)
+void block_manager::init(void *block, int32_t Block_size, uint8_t type)
 {
   block_size=Block_size;
@@ -326 +325 @@
 }
 
-void *block_manager::static_alloc(long size, char *name)
+void *block_manager::static_alloc(int32_t size, char *name)
 {
   if (size<JM_SMALL_SIZE)
@@ -345 +344 @@
         break_mem_fun();
 #endif      
-      long *addr=(long *)(((char *)s)+sizeof(small_block));
-      *addr=(long)s;
+      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
+      *addr=(intptr_t)s;
       return (void *)(addr+1);  // return first block
     } else
@@ -360 +359 @@
           s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
 #endif           
-          *((long *)addr)=(long)s;
+          *((intptr_t *)addr)=(intptr_t)s;
 
 #ifdef MEM_CHECK
@@ -406 +405 @@
 
 
-void *block_manager::cache_alloc(long size, char *name)
+void *block_manager::cache_alloc(int32_t size, char *name)
 {
   if (size<JM_SMALL_SIZE)
@@ -424 +423 @@
 
 #endif      
-      long *addr=(long *)(((char *)s)+sizeof(small_block));
-      *addr=(long)s;
+      intptr_t *addr=(intptr_t *)(((char *)s)+sizeof(small_block));
+      *addr=(intptr_t)s;
 #ifdef MEM_CHECK
       if ((intptr_t)s==break_mem_point)
@@ -445 +444 @@
             break_mem_fun();
 #endif           
-          *((long *)addr)=(long)s;
+          *((intptr_t *)addr)=(intptr_t)s;
           return (void *)(addr+4);
         }
@@ -461 +460 @@
   if (!s) // no current cache space for object, see if we can enlarge the cache space
   {
-    long size_avail=-slast->size;
+    int32_t size_avail=-slast->size;
     size_avail-=sizeof(memory_node);
 
@@ -491 +490 @@
   {
     memory_node *p=s;    // store this position
-    long psize=s->size-size-sizeof(memory_node);
+    int32_t psize=s->size-size-sizeof(memory_node);
     s=(memory_node *)(((char *)s)+psize+sizeof(memory_node));
     p->size=-psize;
@@ -515 +514 @@
 {
   // see if this was a small_block allocation
-  void *next=(void *)(*(((long *)ptr)-1));
+  void *next=(void *)(*(((int32_t *)ptr)-1));
   if (next && ((small_block *)next)->size<JM_SMALL_SIZE)  // small allocation
   {
@@ -598 +597 @@
 {
   // see if this was a small_block allocation
-  void *next=(void *)(*(((long *)ptr)-1));
+  void *next=(void *)(*(((int32_t *)ptr)-1));
   if (next && next<ptr)  // small allocation
   {
@@ -696 +695 @@
                                    "    - add memory to your system\n";
 
-void jmalloc_init(long min_size)
+void jmalloc_init(int32_t min_size)
 {
   fprintf(stderr,"Disabling memory manager, using libc instead\n");
@@ -709 +708 @@
 
 #ifdef __POWERPC__
-    long size=jmalloc_max_size-0x10000;
+    int32_t size=jmalloc_max_size-0x10000;
     for (mem=NULL;!mem && size>0x10000;)
     {
@@ -718 +717 @@
     mem = malloc(size);
 #else
-    long size=jmalloc_max_size;
+    int32_t size=jmalloc_max_size;
     for (mem=NULL;!mem && size>0x4000;)
     {
@@ -768 +767 @@
 
 
-long j_available()
-{
-  long size=0;
+int32_t j_available()
+{
+  int32_t size=0;
   for (int i=0;i<bmanage_total;i++) 
     size+=bmanage[i].available();
@@ -776 +775 @@
 }
 
-long j_allocated()
-{
-  long size=0;
+int32_t j_allocated()
+{
+  int32_t size=0;
   for (int i=0;i<bmanage_total;i++) 
     size+=bmanage[i].allocated();
@@ -785 +784 @@
 
 
-void *jmalloc(long size, char *name)
+void *jmalloc(int32_t size, char *name)
 {  
   if (!bmanage_total)
@@ -838 +837 @@
 
 
-void *jrealloc(void *ptr, long size, char *name)
+void *jrealloc(void *ptr, int32_t size, char *name)
 {  
   if (!ptr) return jmalloc(size,name);
@@ -845 +844 @@
   if (size==0) { jfree(ptr); return NULL; }
 
-  long old_size=0;
+  int32_t old_size=0;
   for (int i=0;i<bmanage_total;i++)
     if (ptr>=(void *)bmanage[i].sfirst && 
@@ -912 +911 @@
 
 
-long small_ptr_size(void *ptr)
-{
-  return ((small_block *)(((long *)ptr)[-1]))->size;
+int32_t small_ptr_size(void *ptr)
+{
+  return ((small_block *)(((int32_t *)ptr)[-1]))->size;
 }
 

abuse/trunk/src/imlib/lbmread.cpp

@@ -20 +20 @@
   else
   {
-    long size=read_other_long(fp);
+    int32_t size=read_other_uint32(fp);
     fread(type,1,4,fp);    
     if (memcmp(type,"PBM ",4))
@@ -30 +30 @@
     else
     {
-      long ssize;    
+      int32_t ssize;    
       char stype[4];
-      short w=0,h=0,x,y,tcolor,pagew,pageh;
+      int16_t w=0,h=0,x,y,tcolor,pagew,pageh;
       char planes,masking,compr=0,padl,xa,ya;
       
@@ -38 +38 @@
       {
         fread(stype,1,4,fp);
-        ssize=read_other_long(fp);
+        ssize=read_other_uint32(fp);
         if (ssize &1) ssize++;            // specs say all chunks are padded by 2
         if (!memcmp(stype,"BMHD",4))
         {
-          w=read_other_short(fp);
-          h=read_other_short(fp);
-          x=read_other_short(fp);
-          y=read_other_short(fp);
+          w=read_other_uint16(fp);
+          h=read_other_uint16(fp);
+          x=read_other_uint16(fp);
+          y=read_other_uint16(fp);
           planes=fgetc(fp);
           masking=fgetc(fp);
           compr=fgetc(fp);
           padl=fgetc(fp);
-          tcolor=read_other_short(fp);
+          tcolor=read_other_uint16(fp);
           xa=fgetc(fp);
           ya=fgetc(fp);
-          pagew=read_other_short(fp);
-          pageh=read_other_short(fp);
+          pagew=read_other_uint16(fp);
+          pageh=read_other_uint16(fp);
         } else if (!memcmp(stype,"CMAP",4))
         {

abuse/trunk/src/imlib/mdlread.cpp

@@ -11 +11 @@
 // images.  All images should be sized so they will fit on an mdl screen
 // but no checking of that is done hhere.
-void write_mdl(image **images, short total_images, palette *pal,char *fn,
-                short firstpage, short images_per_page)
+void write_mdl(image **images, int16_t total_images, palette *pal,char *fn,
+                int16_t firstpage, int16_t images_per_page)
 {
   FILE *fp;
   char buf[18];
-  unsigned short xy[2],x;
+  uint16_t xy[2],x;
   char name[13],page;
   unsigned char *c;
-  short i;
+  int16_t i;
   palette *np;
   clear_errors();
@@ -43 +43 @@
       memset(buf,0,6);            // each image has 6 bytes of reserved 0
       fwrite(buf,6,1,fp);
-      xy[0]=int_to_intel(i%100+20); xy[1]=int_to_intel(30);  // the x and y position on the screen
+      xy[0]=uint16_to_intel(i%100+20); xy[1]=uint16_to_intel(30);  // the x and y position on the screen
       fwrite(xy,4,1,fp);
       sprintf(name,"JC%-10d",i);  // set the name of the image
@@ -51 +51 @@
 
       fwrite(&page,1,1,fp);         // put all of the image on the first page
-      xy[0]=int_to_intel(images[i]->width()*images[i]->height()+4);  // calc the size of the image
+      xy[0]=uint16_to_intel(images[i]->width()*images[i]->height()+4);  // calc the size of the image
     
       fwrite(xy,2,1,fp);
-      xy[0]=int_to_intel(images[i]->width());
+      xy[0]=uint16_to_intel(images[i]->width());
       fwrite(xy,2,1,fp);
-      xy[0]=int_to_intel(images[i]->height());
+      xy[0]=uint16_to_intel(images[i]->height());
       fwrite(xy,2,1,fp);
-      for (x=0;x<(unsigned short)images[i]->height();x++)   // write all the scan_lines for the
+      for (x=0;x<(uint16_t)images[i]->height();x++)   // write all the scan_lines for the
       { c=images[i]->scan_line(x);            // image
         fwrite(c,images[i]->width(),1,fp);
@@ -67 +67 @@
 }
 
-short mdl_total_images(char *fn)
+int16_t mdl_total_images(char *fn)
 {
   char buf[800];
-  unsigned short xy[2],t;
+  uint16_t xy[2],t;
   FILE *fp;
   fp=fopen(fn,"rb");
@@ -92 +92 @@
     {
       fread(xy,2,1,fp);
-      xy[0]=int_to_local(xy[0]);
+      xy[0]=uint16_to_local(xy[0]);
       fseek(fp,xy[0],SEEK_CUR);
       t++;
@@ -104 +104 @@
 // and a palette that is read form the file
 // to load image numbers 4 through 9 let start =4, end=9
-image **read_mdl(char *fn, palette *&pal, short startn, short endn, short &total)
+image **read_mdl(char *fn, palette *&pal, int16_t startn, int16_t endn, int16_t &total)
 {
   FILE *fp;
   image **im;
   char buf[50];
-  unsigned short xy[2],i,j;
+  uint16_t xy[2],i,j;
   clear_errors();
   make_block(sizeof(FILE));
@@ -147 +147 @@
           set_error(imFILE_CORRUPTED);
         fread(xy,2,1,fp);
-        xy[0]=int_to_local(xy[0]);
+        xy[0]=uint16_to_local(xy[0]);
         fseek(fp,xy[0],SEEK_CUR);
         startn--; if (endn>0) endn--;
@@ -161 +161 @@
           else
           {
-            j=int_to_local(j);
+            j=uint16_to_local(j);
             j-=4;
             xy[0]=5; xy[1]=5;
             if (fread(xy,1,4,fp)!=4) set_error(imFILE_CORRUPTED);
             make_block(sizeof(image));
-            xy[0]=int_to_local(xy[0]);
-            xy[1]=int_to_local(xy[1]);
+            xy[0]=uint16_to_local(xy[0]);
+            xy[1]=uint16_to_local(xy[1]);
             im[startn]=new image(xy[0],xy[1]);
             total++;

abuse/trunk/src/imlib/morph.cpp

@@ -355 +355 @@
     for (i=0;i<total;i++)
     { 
-      ((morph_point16 *)p+i)->x1=fp->read_short();
-      ((morph_point16 *)p+i)->y1=fp->read_short();
-      ((morph_point16 *)p+i)->x2=fp->read_short();
-      ((morph_point16 *)p+i)->y2=fp->read_short();
+      ((morph_point16 *)p+i)->x1=fp->read_uint16();
+      ((morph_point16 *)p+i)->y1=fp->read_uint16();
+      ((morph_point16 *)p+i)->x2=fp->read_uint16();
+      ((morph_point16 *)p+i)->y2=fp->read_uint16();
       fp->read( &((morph_point16 *)p+i)->start_color,1);
       fp->read( &((morph_point16 *)p+i)->end_color,1);
@@ -365 +365 @@
     small=0;
   }
-  w[0]=fp->read_short();
-  h[0]=fp->read_short();  
-  w[1]=fp->read_short();
-  h[1]=fp->read_short();
+  w[0]=fp->read_uint16();
+  h[0]=fp->read_uint16();  
+  w[1]=fp->read_uint16();
+  h[1]=fp->read_uint16();
 }
 
@@ -678 +678 @@
 
   
-  fp->write_long(total);  
+  fp->write_uint32(total);  
   if (small)
   {
@@ -691 +691 @@
   {
     for (i=0;i<total;i++)
-    { fp->write_short(((morph_point16 *)p+i)->x1);
-      fp->write_short(((morph_point16 *)p+i)->y1);
-      fp->write_short(((morph_point16 *)p+i)->x2);
-      fp->write_short(((morph_point16 *)p+i)->y2);
+    { fp->write_uint16(((morph_point16 *)p+i)->x1);
+      fp->write_uint16(((morph_point16 *)p+i)->y1);
+      fp->write_uint16(((morph_point16 *)p+i)->x2);
+      fp->write_uint16(((morph_point16 *)p+i)->y2);
       fp->write( &((morph_point16 *)p+i)->start_color,1);
       fp->write( &((morph_point16 *)p+i)->end_color,1);
     }
   }
-  fp->write_short(w[0]);
-  fp->write_short(h[0]);
-  fp->write_short(w[1]);
-  fp->write_short(h[1]);
+  fp->write_uint16(w[0]);
+  fp->write_uint16(h[0]);
+  fp->write_uint16(w[1]);
+  fp->write_uint16(h[1]);
   return 1;
 }
@@ -877 +877 @@
   int i;
   
-  patches=fp->read_short();
+  patches=fp->read_uint16();
   pats=(morph_patch *)jmalloc(sizeof(morph_patch)*patches,"patched_morph::points");
   
   for (i=0;i<patches;i++)
   {
-    pats[i].patches=fp->read_short();
+    pats[i].patches=fp->read_uint16();
     if (pats[i].patches)
     {      

abuse/trunk/src/imlib/packet.cpp

@@ -5 +5 @@
 
 
-int packet::advance(long offset)
+int packet::advance(int32_t offset)
 {
   ro+=offset;
@@ -11 +11 @@
 }
 
-void packet::write_long(ulong x)
+void packet::write_uint32(uint32_t x)
 {
   x=lltl(x);
-  write((uchar *)&x,4);
+  write((uint8_t *)&x,4);
 }
 
-void packet::write_short(ushort x)
+void packet::write_uint16(uint16_t x)
 {
   x=lstl(x);
-  write((uchar *)&x,2);
+  write((uint8_t *)&x,2);
 }
 
-void packet::write_byte(uchar x)
+void packet::write_uint8(uint8_t x)
 {
   write(&x,1);
@@ -41 +41 @@
 
   buf_size=1000;
-  buf=(uchar *)jmalloc(buf_size,"packet buffer");
+  buf=(uint8_t *)jmalloc(buf_size,"packet buffer");
   reset(); 
 
@@ -72 +72 @@
   {
     buf_size=max;
-    buf=(uchar *)jrealloc(buf,max,"packet buffer"); 
+    buf=(uint8_t *)jrealloc(buf,max,"packet buffer"); 
   }
 }
 
-int packet::read(uchar *buffer, int size)
+int packet::read(uint8_t *buffer, int size)
 {
   if (size>rend-ro)
@@ -90 +90 @@
 
 
-int packet::write(uchar *buffer, int size)
+int packet::write(uint8_t *buffer, int size)
 {
   if (size>buf_size-wo)

abuse/trunk/src/imlib/palette.cpp

@@ -12 +12 @@
 palette::palette(bFILE *fp)
 {
-  ncolors=fp->read_short();
+  ncolors=fp->read_uint16();
   pal=(color *)jmalloc(sizeof(color)*ncolors,"palette");
   usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
@@ -23 +23 @@
 {
   fp->seek(e->offset,0);
-  ncolors=fp->read_short();
+  ncolors=fp->read_uint16();
   pal=(color *)jmalloc(sizeof(color)*ncolors,"palette");
   usd=(unsigned char *)jmalloc(ncolors/8+1,"palette used array");
@@ -38 +38 @@
 int palette::write(bFILE *fp)
 {
-  fp->write_short(ncolors);
+  fp->write_uint16(ncolors);
   return fp->write(pal,sizeof(color)*ncolors)==ncolors;
 }

abuse/trunk/src/imlib/pcxread.cpp

@@ -18 +18 @@
   if (!fread(&PCX_header.encoding,1,1,fp)) return 0;  
   if (!fread(&PCX_header.bits_per_pixel,1,1,fp)) return 0;  
-  PCX_header.xmin=read_short(fp);
-  PCX_header.ymin=read_short(fp);  
-  PCX_header.xmax=read_short(fp);
-  PCX_header.ymax=read_short(fp);
-  PCX_header.hres=read_short(fp);
-  PCX_header.vres=read_short(fp);
+  PCX_header.xmin=read_uint16(fp);
+  PCX_header.ymin=read_uint16(fp);  
+  PCX_header.xmax=read_uint16(fp);
+  PCX_header.ymax=read_uint16(fp);
+  PCX_header.hres=read_uint16(fp);
+  PCX_header.vres=read_uint16(fp);
   if (!fread(PCX_header.palette,1,48,fp)) return 0;
   if (!fread(&PCX_header.reserved,1,1,fp)) return 0;
   if (!fread(&PCX_header.color_planes,1,1,fp)) return 0;
-  PCX_header.bytes_per_line=read_short(fp); 
-  PCX_header.palette_type=read_short(fp); 
+  PCX_header.bytes_per_line=read_uint16(fp); 
+  PCX_header.palette_type=read_uint16(fp); 
   if (!fread(PCX_header.filter,1,58,fp)) return 0;
   return 1;
@@ -39 +39 @@
   if (!fwrite(&PCX_header.encoding,1,1,fp)) return 0;  
   if (!fwrite(&PCX_header.bits_per_pixel,1,1,fp)) return 0;  
-  write_short(fp,PCX_header.xmin);
-  write_short(fp,PCX_header.ymin);  
-  write_short(fp,PCX_header.xmax);
-  write_short(fp,PCX_header.ymax);
-  write_short(fp,PCX_header.hres);
-  write_short(fp,PCX_header.vres);
+  write_uint16(fp,PCX_header.xmin);
+  write_uint16(fp,PCX_header.ymin);  
+  write_uint16(fp,PCX_header.xmax);
+  write_uint16(fp,PCX_header.ymax);
+  write_uint16(fp,PCX_header.hres);
+  write_uint16(fp,PCX_header.vres);
   if (!fwrite(PCX_header.palette,1,48,fp)) return 0;
   if (!fwrite(&PCX_header.reserved,1,1,fp)) return 0;
   if (!fwrite(&PCX_header.color_planes,1,1,fp)) return 0;
-  write_short(fp,PCX_header.bytes_per_line); 
-  write_short(fp,PCX_header.palette_type); 
+  write_uint16(fp,PCX_header.bytes_per_line); 
+  write_uint16(fp,PCX_header.palette_type); 
   if (!fwrite(PCX_header.filter,1,58,fp)) return 0;
   return 1;

abuse/trunk/src/imlib/readwav.cpp

@@ -38 +38 @@
 {
   fp->read(&chunk.id,4);
-  chunk.size=fp->read_long();
+  chunk.size=fp->read_uint32();
   fp->read(&chunk.type,4);  
 }
@@ -45 +45 @@
 {
   fp->read(&tag.id,4);
-  tag.size=fp->read_long();
+  tag.size=fp->read_uint32();
 }
 
 void read_wav_format(wav_format &fmt, bFILE *fp)
 {
-  fmt.fmt_tag=fp->read_short();
-  fmt.channels=fp->read_short(); 
-  fmt.samplesps=fp->read_long();
-  fmt.avg_bytesps=fp->read_long();  
-  fmt.align=fp->read_short();  
+  fmt.fmt_tag=fp->read_uint16();
+  fmt.channels=fp->read_uint16(); 
+  fmt.samplesps=fp->read_uint32();
+  fmt.avg_bytesps=fp->read_uint32();  
+  fmt.align=fp->read_uint16();  
 }
 
@@ -61 +61 @@
 {
   read_wav_format(pcm.wf,fp);
-  pcm.bitsps=fp->read_short();  
+  pcm.bitsps=fp->read_uint16();  
 }
 
@@ -78 +78 @@
   /***************  Write the chunk ***************************/
   fp->write((void *)"RIFF",4);  
-  fp->write_long(data_size+36);
+  fp->write_uint32(data_size+36);
   fp->write((void *)"WAVE",4);
 
@@ -84 +84 @@
   /************** Write the tag *******************************/
   fp->write((void *)"fmt ",4);
-  fp->write_long(16);
+  fp->write_uint32(16);
   
   
   /************** Write PCM ***********************************/
-  fp->write_short(1);          // format_tag
-  fp->write_short(1);          // mono recording
-  fp->write_long(sample_rate);
-  fp->write_long(sample_rate);   // average bytes per sec
-  fp->write_short(1);    // allignment? Don't know what this does?
-  fp->write_short(8);    // 8 bits per sample
+  fp->write_uint16(1);          // format_tag
+  fp->write_uint16(1);          // mono recording
+  fp->write_uint32(sample_rate);
+  fp->write_uint32(sample_rate);   // average bytes per sec
+  fp->write_uint16(1);    // allignment? Don't know what this does?
+  fp->write_uint16(8);    // 8 bits per sample
   
   /************* Write data tag ******************************/
   fp->write((void *)"data",4);
-  fp->write_long(data_size);
+  fp->write_uint32(data_size);
 
   /************ Now write sample data ************************/

abuse/trunk/src/imlib/readxwd.cpp

@@ -106 +106 @@
 
 
-int bs_int(int s);
-long bs_long(long s);
-short bs_short(short s );
+int32_t bs_int32(int32_t s);
+int16_t bs_int16(int16_t s );
 
 
@@ -325 +324 @@
 
 
-short bs_short(short s )
+short bs_int16(short s )
 {
   short ss;
@@ -338 +337 @@
 }
 
-int bs_int(int i )
-{
-  int ii;
-  unsigned char *bp, t;
+int32_t bs_int32(int32_t l )
+{
+  int32_t ii;
+  uint8_t *bp, t;
 
   ii = i;
-  bp = (unsigned char *) ⅈ
+  bp = (uint8_t *) ⅈ
   t = bp[0];
   bp[0] = bp[3];
@@ -352 +351 @@
   bp[2] = t;
   return ii;
-}
-
-long bs_long(long l )
-{
-  return bs_int( l );
 }
 
@@ -374 +368 @@
   FILE *fp;
   int i,bytes;
-  unsigned char pal_quad[4];
+  uint8_t pal_quad[4];
 //  fp=fopen("d:\\windows\\256color.bmp","rb");
 //  fread(&bmp,1,sizeof(bmp),fp);
@@ -411 +405 @@
 {
   image *ni;
-  unsigned char *sl1,*sl2;
+  uint8_t *sl1,*sl2;
   int i,x;
-  unsigned char r,g,b;
+  uint8_t r,g,b;
   printf("Creating image size (%d, %d)\n",im->width()*3,im->height());
   ni=new image(im->width()*3,im->height());
@@ -429 +423 @@
 }
 
-unsigned char addb(int n1, int n2)
+uint8_t addb(int n1, int n2)
 { int n3;
   n3=n1+n2;
@@ -441 +435 @@
 {
   image *i24;
-  unsigned char min[3],max[3],mid[3],*ad,*sl,*sl2,crimp;
+  uint8_t min[3],max[3],mid[3],*ad,*sl,*sl2,crimp;
   int i,j,x,y,delta;
   (void *)ad=pal->addr();
@@ -523 +517 @@
   image *im,*i24;
   palette *pal;
-  unsigned char *sl;
+  uint8_t *sl;
   FILE *fp;
   char def_name[10],*dev_name,*fname=NULL;
-  unsigned char cp[500],mp[500],yp[500],kp[500];
+  uint8_t cp[500],mp[500],yp[500],kp[500];
   strcpy(def_name,"\\dev\\lp");  // set the default output device to /dev/lp
                 // since we are in vpix, however we will use the backslash

abuse/trunk/src/imlib/scroller.cpp

@@ -4 +4 @@
 
 
-unsigned char hs_left_arrow[10*8]={
+uint8_t hs_left_arrow[10*8]={
     0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
     0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
@@ -13 +13 @@
 
 
-unsigned char hs_right_arrow[10*8]={
+uint8_t hs_right_arrow[10*8]={
     0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
@@ -22 +22 @@
 
 
-unsigned char vs_up_arrow[8*10]={
+uint8_t vs_up_arrow[8*10]={
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 0,
     0, 0, 0, 1, 1, 1, 1, 2, 0, 0, 1, 2, 1, 1, 2,
@@ -31 +31 @@
 
 
-unsigned char vs_down_arrow[8*10]={
+uint8_t vs_down_arrow[8*10]={
     0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 1, 1, 2, 0,
     0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 1, 1, 2,
@@ -39 +39 @@
     0, 0, 0, 0, 0};
 
-void show_icon(image *screen, window_manager *wm, int x, int y, int icw, int ich, unsigned char *buf)
+void show_icon(image *screen, window_manager *wm, int x, int y, int icw, int ich, uint8_t *buf)
 {
   short cx1,cy1,cx2,cy2;
   screen->get_clip(cx1,cy1,cx2,cy2);
-  unsigned char remap[3];
+  uint8_t remap[3];
   remap[0]=wm->medium_color();
   remap[1]=wm->bright_color();
@@ -52 +52 @@
     if (y>=cy1 && y<=cy2)
     {
-      unsigned char *sl=screen->scan_line(y)+x;
+      uint8_t *sl=screen->scan_line(y)+x;
       for (int xc=icw,xo=x;xc;xc--,xo++,sl++,buf++)
       {
@@ -88 +88 @@
 int scroller::bw() { if (vert) return 12; else return 14; }
 
-unsigned char *scroller::b1()
+uint8_t *scroller::b1()
 {
   if (vert) return vs_up_arrow;
@@ -94 +94 @@
 }
 
-unsigned char *scroller::b2()
+uint8_t *scroller::b2()
 {
   if (vert) return vs_down_arrow;
@@ -553 +553 @@
   if (m)
   {
-    select=(uchar *)jmalloc((t+7)/8,"selection bit array");
+    select=(uint8_t *)jmalloc((t+7)/8,"selection bit array");
     memset(select,0,(t+7)/8);
   } else cur_sel=0;

abuse/trunk/src/imlib/specs.cpp

@@ -595 +595 @@
 
 
-uint8_t bFILE::read_byte()
+uint8_t bFILE::read_uint8()
 { uint8_t x;
   read(&x,1);
@@ -601 +601 @@
 }
 
-uint16_t bFILE::read_short()
+uint16_t bFILE::read_uint16()
 { 
   uint16_t x;
   read(&x,2); 
-  return int_to_local(x);
-}
-
-
-uint32_t bFILE::read_long()
+  return uint16_to_local(x);
+}
+
+
+uint32_t bFILE::read_uint32()
 { 
   uint32_t x;
   read(&x,4); 
-  return long_to_local(x);
-}
-
-void bFILE::write_byte(uint8_t x)
+  return uint32_to_local(x);
+}
+
+void bFILE::write_uint8(uint8_t x)
 {
   write(&x,1);
 }
 
-void bFILE::write_short(uint16_t x)
+void bFILE::write_uint16(uint16_t x)
 { 
-  x=int_to_local(x);
+  x=uint16_to_local(x);
   write(&x,2);
 }
 
 
-void bFILE::write_long(uint32_t x)
-{
-  x=long_to_local(x);
+void bFILE::write_uint32(uint32_t x)
+{
+  x=uint32_to_local(x);
   write(&x,4);
 }
@@ -637 +637 @@
 {
   double a;
-  write_long((long)(modf(x,&a)*(double)(1<<32-1)));
-  write_long((long)a);
+  write_uint32((long)(modf(x,&a)*(double)(1<<32-1)));
+  write_uint32((long)a);
 }
 
@@ -644 +644 @@
 {
   long a,b;
-  a=read_long();
-  b=read_long();
+  a=read_uint32();
+  b=read_uint32();
   return (double)b+a/(double)(1<<32-1);
 }
@@ -762 +762 @@
   if (!strcmp(buf,SPEC_SIGNATURE))
   {    
-    total=fp->read_short();   
+    total=fp->read_uint16();   
     entries=(spec_entry **)jmalloc(sizeof(spec_entry *)*total,"spec_directory::entries");
     long start=fp->tell();
@@ -793 +793 @@
       fp->read(&flags,1); 
 
-      se->size=fp->read_long();
-      se->offset=fp->read_long();
+      se->size=fp->read_uint32();
+      se->offset=fp->read_uint32();
       dp+=((sizeof(spec_entry)+len)+3)&(~3);
     }
@@ -880 +880 @@
 
   if (fp->write(sig,sizeof(sig))!=sizeof(sig))    return 0;
-  fp->write_short(total);
+  fp->write_uint16(total);
 
 
@@ -891 +891 @@
     if (fp->write(&flags,1)!=1)                     return 0; 
 
-    data_size=long_to_intel((*e)->size); 
+    data_size=uint32_to_intel((*e)->size); 
     if (fp->write((char *)&data_size,4)!=4)              return 0; 
-    offset=long_to_intel((*e)->offset);
+    offset=uint32_to_intel((*e)->offset);
     if (fp->write((char *)&offset,4)!=4)                  return 0; 
 
@@ -913 +913 @@
 }
 
-uint16_t read_short(FILE *fp)
+uint16_t read_uint16(FILE *fp)
 {
   uint16_t x;
   fread(&x,1,2,fp); 
-  return int_to_local(x);
-}
-
-uint32_t read_long(FILE *fp)
+  return uint16_to_local(x);
+}
+
+uint32_t read_uint32(FILE *fp)
 {
   uint32_t x;
   fread(&x,1,4,fp);
-  return long_to_local(x);
-}
-void write_short(FILE *fp, uint16_t x)
-{
-  x=int_to_local(x);
+  return uint32_to_local(x);
+}
+void write_uint16(FILE *fp, uint16_t x)
+{
+  x=uint16_to_local(x);
   fwrite(&x,1,2,fp);
 }
 
-void write_long(FILE *fp, uint32_t x)
-{
-  x=long_to_local(x);
+void write_uint32(FILE *fp, uint32_t x)
+{
+  x=uint32_to_local(x);
   fwrite(&x,1,4,fp);
 }
 
-uint8_t read_byte(FILE *fp) { return fgetc(fp)&0xff; }
-void write_byte(FILE *fp, uint8_t x) { fputc((unsigned char)x,fp); }
-
-uint32_t read_other_long(FILE *fp)
+uint8_t read_uint8(FILE *fp) { return fgetc(fp)&0xff; }
+void write_uint8(FILE *fp, uint8_t x) { fputc((unsigned char)x,fp); }
+
+uint32_t read_other_int32(FILE *fp)
 {
   uint32_t x;
   fread(&x,1,4,fp);
-  return big_long_to_local(x);
-}
-
-uint16_t read_other_short(FILE *fp)
+  return big_uint32_to_local(x);
+}
+
+uint16_t read_other_uint16(FILE *fp)
 {
   uint16_t x;
   fread(&x,1,2,fp);
-  return big_short_to_local(x);
-}
-
-
-void write_other_short(FILE *fp, uint16_t x)
-{
-  x=big_short_to_local(x);
+  return big_uint16_to_local(x);
+}
+
+
+void write_other_uint16(FILE *fp, uint16_t x)
+{
+  x=big_uint16_to_local(x);
   fwrite(&x,1,2,fp);
 }
 
-void write_other_long(FILE *fp, uint32_t x)
-{
-  x=big_long_to_local(x);
+void write_other_int32(FILE *fp, uint32_t x)
+{
+  x=big_uint32_to_local(x);
   fwrite(&x,1,4,fp);
 }

abuse/trunk/src/imlib/targa.cpp

@@ -14 +14 @@
   }
   
-  unsigned char id,color_map,im_type;
+  uint8_t id,color_map,im_type;
 
-  id=fp->read_byte();
-  color_map=fp->read_byte();
-  im_type=fp->read_byte();
+  id=fp->read_uint8();
+  color_map=fp->read_uint8();
+  im_type=fp->read_uint8();
 
   if (color_map!=0)
@@ -32 +32 @@
   }
 
-  fp->read_short();
-  fp->read_short();
-  fp->read_byte();
+  fp->read_uint16();
+  fp->read_uint16();
+  fp->read_uint8();
 
-  fp->read_short();
-  fp->read_short();
+  fp->read_uint16();
+  fp->read_uint16();
 
 
-  int w=fp->read_short();
-  int h=fp->read_short();
-  unsigned char bpp=fp->read_byte();
-  unsigned char im_des=fp->read_byte();
+  int w=fp->read_uint16();
+  int h=fp->read_uint16();
+  uint8_t bpp=fp->read_uint8();
+  uint8_t im_des=fp->read_uint8();
 
   if (bpp!=32)
@@ -54 +54 @@
 
   int x,y;
-  unsigned char ctrl;
-  unsigned char bgra[4],*sl,c,lr=0,lg=0,lb=0,ll=0,lc=0;
+  uint8_t ctrl;
+  uint8_t bgra[4],*sl,c,lr=0,lg=0,lb=0,ll=0,lc=0;
   
   
@@ -68 +68 @@
       for (x=0;x<w;)
       {
-        ctrl=fp->read_byte();
+        ctrl=fp->read_uint8();
         if (ctrl&0x80)
         {

abuse/trunk/src/imlib/timage.cpp

@@ -3 +3 @@
 void trans_image::make_color(int c)
 {
-  unsigned char *dp=data;
+  uint8_t *dp=data;
   int y,x;
   for (y=0;y<h;y++)
@@ -25 +25 @@
 {
   image *im=new image(w,h);
-  unsigned char *d=im->scan_line(0),*dp=data,*dline;
+  uint8_t *d=im->scan_line(0),*dp=data,*dline;
   int y,x;
   for (y=0;y<h;y++)
@@ -54 +54 @@
 {
   int size=0,x,y;
-  unsigned char *sl,*datap,*marker; 
+  uint8_t *sl,*datap,*marker; 
   w=im->width();
   h=im->height();
@@ -84 +84 @@
   char st[80];
   sprintf(st,"trans_image::data (%s)",name);
-  data=(unsigned char *)jmalloc(size,st);
+  data=(uint8_t *)jmalloc(size,st);
 #else
-  data=(unsigned char *)jmalloc(size,"");
+  data=(uint8_t *)jmalloc(size,"");
 #endif
   int ww=im->width(),hh=im->height();
@@ -125 +125 @@
 void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent   
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   screen->get_clip(x1,y1,x2,y2);
   if (y+line<y1 || y+line>y2 || x>x2 || x+w-1<x1)            // clipped off completely?
     return;
 
-  unsigned char *datap=data;
+  uint8_t *datap=data;
   int ix;  
   while (line)            // skip scan line data until we get to the line of interest
@@ -151 +151 @@
   
   // now slam this list of runs to the screen
-  unsigned char *screen_line=screen->scan_line(y)+x;
+  uint8_t *screen_line=screen->scan_line(y)+x;
     
   for (ix=0;ix<w;)             
@@ -202 +202 @@
 
 
-inline unsigned char *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2, 
+inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2, 
                                    int x, int &y, int &ysteps)
 {
@@ -209 +209 @@
     return NULL;
 
-  register unsigned char *datap=data;  
+  register uint8_t *datap=data;  
 
 
@@ -245 +245 @@
 
 void trans_image::put_image_filled(image *screen, int x, int y, 
-                                   uchar fill_color)
-{
- short x1,y1,x2,y2;
+                                   uint8_t fill_color)
+{
+ int16_t x1,y1,x2,y2;
   int chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  register unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
   
@@ -316 +316 @@
 }
 
-void trans_image::put_image_offseted(image *screen, uchar *s_off)   // if screen x & y offset already calculated save a mul
+void trans_image::put_image_offseted(image *screen, uint8_t *s_off)   // if screen x & y offset already calculated save a mul
 {
   int ix,ysteps=height();
   int screen_skip=screen->width()-w;
-  uchar skip,*datap=data;
+  uint8_t skip,*datap=data;
   for (;ysteps;ysteps--)
   {
@@ -353 +353 @@
 void trans_image::put_image(image *screen, int x, int y) 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  register unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
   
@@ -414 +414 @@
 }
 
-void trans_image::put_remaped(image *screen, int x, int y, unsigned char *remap) 
-{
-  short x1,y1,x2,y2;
+void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap) 
+{
+  int16_t x1,y1,x2,y2;
   int chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  register unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
   
@@ -470 +470 @@
               counter=slam_length;
 
-            register unsigned char *sl=screen_line+ix,*sl2=datap;
+            register uint8_t *sl=screen_line+ix,*sl2=datap;
             ix+=slam_length;        
             datap+=slam_length;
@@ -490 +490 @@
 
 
-void trans_image::put_double_remaped(image *screen, int x, int y, unsigned char *remap, unsigned char *remap2) 
-{
-  short x1,y1,x2,y2;
+void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2) 
+{
+  int16_t x1,y1,x2,y2;
   int chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  register unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
   
@@ -546 +546 @@
               counter=slam_length;
 
-            register unsigned char *sl=screen_line+ix,*sl2=datap;
+            register uint8_t *sl=screen_line+ix,*sl2=datap;
             ix+=slam_length;        
             datap+=slam_length;
@@ -570 +570 @@
                            color_filter *f, palette *pal) 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                 *screen_line;
   if (!datap) return ;
 
-  unsigned char *screen_run,*paddr=(unsigned char *)pal->addr(),
+  uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
                 *caddr1,*caddr2,r_dest,g_dest,b_dest;
 
@@ -659 +659 @@
 void trans_image::put_fade_tint(image *screen, int x, int y,
                                 int frame_on, int total_frames, 
-                                uchar *tint,
+                                uint8_t *tint,
                                 color_filter *f, palette *pal) 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                 *screen_line;
   if (!datap) return ;
 
-  unsigned char *screen_run,*paddr=(unsigned char *)pal->addr(),
+  uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
                 *caddr1,*caddr2,r_dest,g_dest,b_dest;
 
@@ -753 +753 @@
 void trans_image::put_color(image *screen, int x, int y, int color) 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
   
   screen->get_clip(x1,y1,x2,y2);
-  unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                 *screen_line;
   if (!datap) return ;
@@ -819 +819 @@
 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int ix,slam_length,chop_length,ysteps;
-  unsigned char *paddr=(unsigned char *)pal->addr();  
+  uint8_t *paddr=(uint8_t *)pal->addr();  
   
   screen->get_clip(x1,y1,x2,y2);
-  unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
+  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
                 *blend_line,*screen_line;
   if (!datap) return ;
@@ -876 +876 @@
             else chop_length=slam_length;
 
-            unsigned char *screen_run=screen_line+x+ix,
+            uint8_t *screen_run=screen_line+x+ix,
                           *blend_run=blend_line+x+ix-blendx,
                           *caddr1,*caddr2,r_dest,g_dest,b_dest;      
@@ -918 +918 @@
 void trans_image::put_predator(image *screen, int x, int y) 
 {
-  short x1,y1,x2,y2;
+  int16_t x1,y1,x2,y2;
   int chop_length,ysteps;
 
   screen->get_clip(x1,y1,x2,y2);
-  register unsigned char *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
+  register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
   if (!datap) return ;     // if clip_y says nothing to draw, return
 
@@ -1002 +1002 @@
 int trans_image::size()
 {
-  uchar *d=data;
+  uint8_t *d=data;
   int t=0;
   for (int y=0;y<h;y++)

abuse/trunk/src/imlib/xwdread.cpp

@@ -123 +123 @@
 int bit_order, byte_swap;
 char buf[4];
-unsigned char *byteP;
-unsigned short *shortP;
-unsigned long *longP;
-
-
-int bs_int(int s);
-long bs_long(long s);
-short bs_short(short s );
+uint8_t *byteP;
+uint16_t *shortP;
+uint32_t *longP;
+
+
+uint32_t bs_uint32(uint32_t s);
+uint16_t bs_uint16(uint16_t s );
 
 
@@ -136 +135 @@
 {
   /* Assume X11 headers are larger than X10 ones. */
-  unsigned char header[sizeof(X11WDFileHeader)];
+  uint8_t header[sizeof(X11WDFileHeader)];
   image *im;
   X11WDFileHeader *h11P;
@@ -142 +141 @@
   unsigned int i;
   int dummy1, dummy2, dummy3;
-  unsigned  short minred, maxred;
+  uint16_t minred, maxred;
   X11XColor x11col;
 
@@ -275 +274 @@
   pixel_mask = ( 1 << bits_per_pixel ) - 1;
 
-  byteP = (unsigned char *) buf;
-  shortP = (unsigned short *) buf;
-  longP = (unsigned long *) buf;
+  byteP = (uint8_t *) buf;
+  shortP = (uint16_t *) buf;
+  longP = (uint32_t *) buf;
   return im;
 }
@@ -284 +283 @@
 {
   int i,j;
-  unsigned char *sl;
+  uint8_t *sl;
 #if BYTE_ORDER!=BIG_ENDIAN
   printf("little guys\n");
@@ -314 +313 @@
             break;
 
-          case 16: *shortP=short_swap(*shortP); break;
-
-          case 32: *longP=long_swap(*longP); break;
+          case 16: *shortP=uint16_swap(*shortP); break;
+
+          case 32: *longP=uint32_swap(*longP); break;
 
           default:
@@ -357 +356 @@
 
 
-short bs_short(short s )
-{
-  short ss;
-  unsigned char *bp, t;
+uint16_t bs_uint16(uint16_t s )
+{
+  uint16_t ss;
+  uint8_t *bp, t;
 
   ss = s;
-  bp = (unsigned char *) &ss;
+  bp = (uint8_t *) &ss;
   t = bp[0];
   bp[0] = bp[1];
@@ -370 +369 @@
 }
 
-int bs_int(int i )
-{
-  int ii;
-  unsigned char *bp, t;
-
-  ii = i;
-  bp = (unsigned char *) &ii;
+uint32_t bs_uint32(uint32_t l )
+{
+  uint32_t ii;
+  uint8_t *bp, t;
+
+  ii = l;
+  bp = (uint8_t *) &ii;
   t = bp[0];
   bp[0] = bp[3];
@@ -386 +385 @@
 }
 
-long bs_long(long l )
-{
-  return bs_int( l );
-}
-
 struct BMP_header
 {
   char id[2];
   long filesize;
-  short reserved[2];
+  int16_t reserved[2];
   long headersize,infosize,width,height;
-  short biplanes,bits;
+  int16_t biplanes,bits;
   long bicompression, bisizeimage, bixpelspermeter, biypelspermeter,
        biclrused,biclrimportant;
@@ -405 +399 @@
 {
   if (!fread(&bmp.id,1,2,fp)) return 0;         // 2 0
-  bmp.filesize=read_long(fp);                   // 4 4
+  bmp.filesize=read_uint32(fp);                   // 4 4
   if (!fread(bmp.reserved,1,4,fp)) return 0;    // 4 8
-  bmp.headersize=read_long(fp);                 // 4 12
-  bmp.infosize=read_long(fp);                   // 4 16
-  bmp.width=read_long(fp);                      // 4 20
-  bmp.height=read_long(fp);                     // 4 24
-  bmp.biplanes=read_short(fp);                  // 2 26
-  bmp.bits=read_short(fp);                      // 2 28
-  bmp.bicompression=read_long(fp);              // 4 32
-  bmp.bisizeimage=read_long(fp);                // 4 36
-  bmp.bixpelspermeter=read_long(fp);            // 4 40
-  bmp.biypelspermeter=read_long(fp);            // 4 44
-  bmp.biclrused=read_long(fp);                  // 4 48
-  bmp.biclrimportant=read_long(fp);             // 4 52
+  bmp.headersize=read_uint32(fp);                 // 4 12
+  bmp.infosize=read_uint32(fp);                   // 4 16
+  bmp.width=read_uint32(fp);                      // 4 20
+  bmp.height=read_uint32(fp);                     // 4 24
+  bmp.biplanes=read_uint16(fp);                  // 2 26
+  bmp.bits=read_uint16(fp);                      // 2 28
+  bmp.bicompression=read_uint32(fp);              // 4 32
+  bmp.bisizeimage=read_uint32(fp);                // 4 36
+  bmp.bixpelspermeter=read_uint32(fp);            // 4 40
+  bmp.biypelspermeter=read_uint32(fp);            // 4 44
+  bmp.biclrused=read_uint32(fp);                  // 4 48
+  bmp.biclrimportant=read_uint32(fp);             // 4 52
   return 1;
   
@@ -460 +454 @@
     return NULL;
   
-  unsigned char *sl;
+  uint8_t *sl;
   int trailer=im->width()%4;
   if (trailer==1) trailer=3;
   else if (trailer==3) trailer=1;
-  uchar buf[9];
+  uint8_t buf[9];
   for (i=im->height();i;i--)
   {
@@ -487 +481 @@
   image *im;
   FILE *fp;
-  unsigned char pal_quad[4];
+  uint8_t pal_quad[4];
   char *scrap;
   int bytes,i;
@@ -530 +524 @@
 {
   if (!fwrite(&bmp.id,1,2,fp)) return 0;  
-  write_long(fp,bmp.filesize);  
+  write_uint32(fp,bmp.filesize);  
   if (!fwrite(bmp.reserved,1,4,fp)) return 0;   
-  write_long(fp,bmp.headersize);
-  write_long(fp,bmp.infosize);  
-  write_long(fp,bmp.width);
-  write_long(fp,bmp.height);
-  write_short(fp,bmp.biplanes);
-  write_short(fp,bmp.bits);
-  write_long(fp,bmp.bicompression);
-  write_long(fp,bmp.bisizeimage);
-  write_long(fp,bmp.bixpelspermeter);
-  write_long(fp,bmp.biypelspermeter);
-  write_long(fp,bmp.biclrused);
-  write_long(fp,bmp.biclrimportant);   
+  write_uint32(fp,bmp.headersize);
+  write_uint32(fp,bmp.infosize);  
+  write_uint32(fp,bmp.width);
+  write_uint32(fp,bmp.height);
+  write_uint16(fp,bmp.biplanes);
+  write_uint16(fp,bmp.bits);
+  write_uint32(fp,bmp.bicompression);
+  write_uint32(fp,bmp.bisizeimage);
+  write_uint32(fp,bmp.bixpelspermeter);
+  write_uint32(fp,bmp.biypelspermeter);
+  write_uint32(fp,bmp.biclrused);
+  write_uint32(fp,bmp.biclrimportant);   
   return 1;
   
@@ -552 +546 @@
   FILE *fp;
   int i,bytes;
-  unsigned char pal_quad[4];
+  uint8_t pal_quad[4];
   fp=fopen(filename,"wb");
   if (!fp)

abuse/trunk/src/include/cache.hpp

@@ -23 +23 @@
 {
   void *data;
-  long last_access;   
-  unsigned char type;
-  short file_number;
-  long offset;
+  int32_t last_access;   
+  uint8_t type;
+  int16_t file_number;
+  int32_t offset;
 } ;
 
@@ -35 +35 @@
   public :
   int crc_calculated;
-  ulong crc;
+  uint32_t crc;
   char *filename;
   crced_file(char *name);
@@ -48 +48 @@
   crc_manager();
   int get_filenumber(char *filename);
-  ulong get_crc(long filenumber, int &failed);
-  void set_crc(long filenumber, ulong crc);
-  char *get_filename(long filenumber);
+  uint32_t get_crc(int32_t filenumber, int &failed);
+  void set_crc(int32_t filenumber, uint32_t crc);
+  char *get_filename(int32_t filenumber);
   void clean_up();
   int total_filenames() { return total_files; }
@@ -62 +62 @@
 {
   cache_item *list;
-  long total,last_registered,last_access,poll_start_access;
-  short last_file;           // for speed leave the last file accessed open
+  int32_t total,last_registered,last_access,poll_start_access;
+  int16_t last_file;           // for speed leave the last file accessed open
 
   bFILE *fp,*cache_file,*cache_read_file;
   spec_directory *last_dir;
-  long last_offset;          // store the last offset so we don't have to seek if
+  int32_t last_offset;          // store the last offset so we don't have to seek if
                              // we don't need to
   
 
-  short lcache_number;
-  long alloc_id();
+  int16_t lcache_number;
+  int32_t alloc_id();
   void locate(cache_item *i, int local_only=0);    // set up file and offset for this item
   void normalize();
@@ -87 +87 @@
   int in_use() { if (used) { used=0; return 1; } else return 0; }
   int full() { if (ful) { ful=0; return 1; } else return 0; }
-  long reg_object(char *filename, void *object, int type, int rm_dups);      // lisp object
-  long reg(char *filename, char *name, int type=-1, int rm_dups=0);          // returns id to item
-  long reg_lisp_block(Cell *block);
+  int32_t reg_object(char *filename, void *object, int type, int rm_dups);      // lisp object
+  int32_t reg(char *filename, char *name, int type=-1, int rm_dups=0);          // returns id to item
+  int32_t reg_lisp_block(Cell *block);
   int loaded(int id);
   void unreg(int id);
@@ -114 +114 @@
 
   void load_cache_prof_info(char *filename, level *lev);
-  int search(int *sarray, ushort filenum, long offset);  // sarray is a index table sorted by offset/filenum
+  int search(int *sarray, uint16_t filenum, int32_t offset);  // sarray is a index table sorted by offset/filenum
 
   void show_accessed();

abuse/trunk/src/include/compiled.hpp

@@ -25 +25 @@
 void compiled_uninit();
 
-extern uchar *bad_guy_array;    // list flaging each character saying they are a bad bug or not
+extern uint8_t *bad_guy_array;  // list flaging each character saying they are a bad bug or not
                                 // mainly used by the rocket to find targets
 

abuse/trunk/src/include/crc.hpp

@@ -4 +4 @@
 #include "macs.hpp"
 
-unsigned short calc_crc(unsigned char *buf, long len);
-ulong crc_file(bFILE *fp);
+uint16_t calc_crc(uint8_t *buf, int len);
+uint32_t crc_file(bFILE *fp);
 
 

abuse/trunk/src/include/extend.hpp

@@ -23 +23 @@
 {
   public :
-  schar Fade_dir;
-  uchar Fade_count,Fade_max;
-  uchar Flags,grav_on,targetable_on;
+  int8_t Fade_dir;
+  uint8_t Fade_count,Fade_max;
+  uint8_t Flags,grav_on,targetable_on;
   int32_t Xvel,Yvel,Xacel,Yacel;
-  uchar Fx,Fy,Fxvel,Fyvel,Fxacel,Fyacel;
-  uchar Aitype;
-  ushort Aistate,Aistate_time;
-  unsigned short Hp,Mp,Fmp;
-  schar Frame_dir;        
+  uint8_t Fx,Fy,Fxvel,Fyvel,Fxacel,Fyacel;
+  uint8_t Aitype;
+  uint16_t Aistate,Aistate_time;
+  uint16_t Hp,Mp,Fmp;
+  int8_t Frame_dir;        
 
 
-  uchar tobjs,tlights;
+  uint8_t tobjs,tlights;
   game_object **objs,*link;
   light_source **lights;
@@ -50 +50 @@
   int32_t x,y,
        last_x,last_y;              // used for frame interpolation on fast machines
-  schar direction,active;
-  ushort otype;
+  int8_t direction,active;
+  uint16_t otype;
   character_state state;
   short current_frame;
@@ -60 +60 @@
 
   int keep_ai_info()         { return 1; }
-  uchar flags()              { return Flags; }
+  uint8_t flags()            { return Flags; }
   int32_t xvel()             { return Xvel; }
   int32_t yvel()             { return Yvel; }
@@ -66 +66 @@
   int32_t yacel()            { return Yacel; }
 
-  uchar fx()                 { return Fx; }
-  uchar fy()                 { return Fy; }
-  uchar fxvel()              { return Fxvel; }
-  uchar fyvel()              { return Fyvel; }
-  uchar fxacel()             { return Fxacel; }
-  uchar fyacel()             { return Fyacel; }
+  uint8_t fx()               { return Fx; }
+  uint8_t fy()               { return Fy; }
+  uint8_t fxvel()            { return Fxvel; }
+  uint8_t fyvel()            { return Fyvel; }
+  uint8_t fxacel()           { return Fxacel; }
+  uint8_t fyacel()           { return Fyacel; }
 
-  uchar sfx()                { return Fx; }  // x & y should always be positive
-  uchar sfy()                { return Fy; }
-  uchar sfxvel()             { if (Xvel>=0) return Fxvel; else return -Fxvel; }
-  uchar sfyvel()             { if (Yvel>=0) return Fyvel; else return -Fyvel; }
-  uchar sfxacel()            { if (Xacel>=0) return Fxacel; else return -Fxacel; }
-  uchar sfyacel()            { if (Yacel>=0) return Fyacel; else return -Fyacel; }
+  uint8_t sfx()              { return Fx; }  // x & y should always be positive
+  uint8_t sfy()              { return Fy; }
+  uint8_t sfxvel()           { if (Xvel>=0) return Fxvel; else return -Fxvel; }
+  uint8_t sfyvel()           { if (Yvel>=0) return Fyvel; else return -Fyvel; }
+  uint8_t sfxacel()          { if (Xacel>=0) return Fxacel; else return -Fxacel; }
+  uint8_t sfyacel()          { if (Yacel>=0) return Fyacel; else return -Fyacel; }
 
-  uchar aitype()             { return Aitype; }
-  ushort aistate()           { return Aistate; }
-  ushort aistate_time()      { return Aistate_time; }
-  ushort hp()                { return Hp;         }
-  ushort mp()                { return Mp;         }
-  ushort fmp()               { return Fmp;        }
-  schar fade_dir()           { return Fade_dir;   }
-  schar frame_dir()          { return Frame_dir;  }
-  uchar fade_count()         { return Fade_count; }
-  uchar fade_max()           { return Fade_max;   }
-  uchar total_objects()      { return tobjs;      }
-  uchar total_lights()       { return tlights;    }
+  uint8_t aitype()           { return Aitype; }
+  uint16_t aistate()         { return Aistate; }
+  uint16_t aistate_time()    { return Aistate_time; }
+  uint16_t hp()              { return Hp;         }
+  uint16_t mp()              { return Mp;         }
+  uint16_t fmp()             { return Fmp;        }
+  int8_t fade_dir()          { return Fade_dir;   }
+  int8_t frame_dir()         { return Frame_dir;  }
+  uint8_t fade_count()       { return Fade_count; }
+  uint8_t fade_max()         { return Fade_max;   }
+  uint8_t total_objects()    { return tobjs;      }
+  uint8_t total_lights()     { return tlights;    }
 
   morph_char *morph_status()     { return mc; }
@@ -100 +100 @@
   view *controller()             { return Controller; }
 
-  void set_targetable(uchar x)    { targetable_on=x; }
-  void set_flags(uchar f)         { Flags=f; }
+  void set_targetable(uint8_t x)  { targetable_on=x; }
+  void set_flags(uint8_t f)       { Flags=f; }
   void set_xvel(int32_t xv)       { Xvel=xv; }
   void set_yvel(int32_t yv)       { Yvel=yv; }
   void set_xacel(int32_t xa)      { Xacel=xa; }
   void set_yacel(int32_t ya)      { Yacel=ya; }
-  void set_fx(uchar x)            { Fx=x; }
-  void set_fy(uchar y)            { Fy=y; }
-  void set_fxvel(uchar xv)        { Fxvel=abs(xv); }
-  void set_fyvel(uchar yv)        { Fyvel=abs(yv); }
-  void set_fxacel(uchar xa)       { Fxacel=abs(xa); }
-  void set_fyacel(uchar ya)       { Fyacel=abs(ya); }
-  void set_aitype(uchar t)        { Aitype=t; }
-  void set_aistate(ushort s)      { Aistate=s; }
-  void set_aistate_time(ushort t) { Aistate_time=t; }
-  void set_hp(ushort h)           { Hp=h; }
-  void set_mp(ushort m)           { Mp=m; }
-  void set_fmp(ushort m)          { Fmp=m; }
+  void set_fx(uint8_t x)          { Fx=x; }
+  void set_fy(uint8_t y)          { Fy=y; }
+  void set_fxvel(uint8_t xv)      { Fxvel=abs(xv); }
+  void set_fyvel(uint8_t yv)      { Fyvel=abs(yv); }
+  void set_fxacel(uint8_t xa)     { Fxacel=abs(xa); }
+  void set_fyacel(uint8_t ya)     { Fyacel=abs(ya); }
+  void set_aitype(uint8_t t)      { Aitype=t; }
+  void set_aistate(uint16_t s)      { Aistate=s; }
+  void set_aistate_time(uint16_t t) { Aistate_time=t; }
+  void set_hp(uint16_t h)           { Hp=h; }
+  void set_mp(uint16_t m)           { Mp=m; }
+  void set_fmp(uint16_t m)          { Fmp=m; }
 
 
 
-  void set_fade_count(uchar f)          { Fade_count=f; }
-  void set_fade_max(uchar m)            { Fade_max=m;  }
-  void set_fade_dir(schar d)            { Fade_dir=d; }
+  void set_fade_count(uint8_t f)        { Fade_count=f; }
+  void set_fade_max(uint8_t m)          { Fade_max=m;  }
+  void set_fade_dir(int8_t d)            { Fade_dir=d; }
 
-  void set_frame_dir(schar d)           { Frame_dir=d; }
+  void set_frame_dir(int8_t d)           { Frame_dir=d; }
   void add_light(light_source *ls);
   void add_object(game_object *o);

abuse/trunk/src/include/fakelib.hpp

@@ -5 +5 @@
 #define jrealloc(x,y,z) realloc(x,y)
 #define jfree(x) free(x)
-#define uchar  unsigned char
-#define schar  signed char
-#define sshort signed short
 
 #ifdef __sgi
 #include <sys/bsd_types.h>
 #else
-#define ulong  unsigned long
-#define ushort unsigned short
+#include <stdint.h>
 #endif
 

abuse/trunk/src/include/game.hpp

@@ -66 +66 @@
   jwindow *top_menu,*joy_win,*last_input;
   JCFont *game_font;
-  uchar keymap[512/8];
+  uint8_t keymap[512/8];
 
 public : 

abuse/trunk/src/include/items.hpp

@@ -15 +15 @@
 public :  
   boundary(bFILE *fp,char *er_name);
-  unsigned char *inside;     // tells which side of the line is on the inside
+  uint8_t *inside;     // tells which side of the line is on the inside
   boundary(boundary *p);      // flips the *inside list
   ~boundary() { if (tot) jfree(inside); }
@@ -23 +23 @@
 {
 public :
-  unsigned short next;
+  uint16_t next;
   image *im;
   backtile(spec_entry *e, bFILE *fp);
   backtile(bFILE *fp);
-  long size() { return 2+4+im->width()*im->height(); }
+  int32_t size() { return 2+4+im->width()*im->height(); }
   ~backtile() { delete im; }
 } ;
@@ -35 +35 @@
 public :
   trans_image *im;
-  unsigned short next;
-  unsigned char damage;
-  uchar ylevel;            // for fast intersections, this is the y level offset for the ground
+  uint16_t next;
+  uint8_t damage;
+  uint8_t ylevel;            // for fast intersections, this is the y level offset for the ground
                            // if ground is not level this is 255
   boundary *points;
@@ -44 +44 @@
 
   foretile(bFILE *fp);
-  long size() { return im->width()*im->height()+4+2+1+points->size(); }
+  int32_t size() { return im->width()*im->height()+4+2+1+points->size(); }
   ~foretile() { delete im; delete points; delete micro_image; }
 } ;
@@ -52 +52 @@
 public :
   trans_image *forward,*backward;
-  unsigned char hit_damage,xcfg;
-  signed char advance;
+  uint8_t hit_damage,xcfg;
+  int8_t advance;
   point_list *hit;
   boundary *f_damage,*b_damage;
@@ -62 +62 @@
   int height() { return forward->height(); }
 
-/*  long size(int type)         // taken from spaint items
+/*  int32_t size(int type)         // taken from spaint items
   {
     if 
@@ -80 +80 @@
 {
   public :
-  uchar data[256];
+  uint8_t data[256];
   ~char_tint() { ; }
   char_tint(bFILE *fp);               // should be a palette entry

abuse/trunk/src/include/level.hpp

@@ -38 +38 @@
 class level        // contain map info and objects
 {
-  unsigned short *map_fg,        // just big 2d arrays
-                 *map_bg,
-                 bg_width,bg_height,
-                 fg_width,fg_height;  
+  uint16_t *map_fg,        // just big 2d arrays
+           *map_bg,
+           bg_width,bg_height,
+           fg_width,fg_height;  
   char *Name,*first_name;
   int32_t total_objs;
@@ -64 +64 @@
   int all_block_list_size,all_block_total;
   void add_all_block(game_object *who);
-  ulong ctick;
+  uint32_t ctick;
   
 public :
   char *original_name() { if (first_name) return first_name; else return Name; }
-  ulong tick_counter() { return ctick; }
-  void set_tick_counter(ulong x);
+  uint32_t tick_counter() { return ctick; }
+  void set_tick_counter(uint32_t x);
   area_controller *area_list;
  
@@ -80 +80 @@
   game_object *first_object() { return first; }
   game_object *first_active_object() { return first_active; }
-  unsigned short foreground_width() { return fg_width; }
-  unsigned short foreground_height() { return fg_height; }
-  unsigned short background_width() { return bg_width; }
-  unsigned short background_height() { return bg_height; }
+  uint16_t foreground_width() { return fg_width; }
+  uint16_t foreground_height() { return fg_height; }
+  uint16_t background_width() { return bg_width; }
+  uint16_t background_height() { return bg_height; }
   int load_failed() { return map_fg==NULL; } 
   level(spec_directory *sd, bFILE *fp, char *lev_name);
@@ -98 +98 @@
                                  return (*(map_fg+x+y*fg_width))&0x4000; }
   void fg_set_raised(int x, int y, int r) { CHECK(x>=0 && y>=0 && x<fg_width && y<fg_height);
-                                            ushort v=(*(map_fg+x+y*fg_width))&(0xffff-0x4000);
+                                            uint16_t v=(*(map_fg+x+y*fg_width))&(0xffff-0x4000);
                                             if (r) (*(map_fg+x+y*fg_width))=v|0x4000;
                                             else (*(map_fg+x+y*fg_width))=v;
@@ -106 +106 @@
   void clear_fg(int32_t x, int32_t y) { *(map_fg+x+y*fg_width)&=0x7fff; }
 
-  unsigned short *get_fgline(int y) { CHECK(y>=0 && y<fg_height); return map_fg+y*fg_width; }
-  unsigned short *get_bgline(int y) { CHECK(y>=0 && y<bg_height); return map_bg+y*bg_width; }
-  unsigned short get_fg(int x, int y) { if (x>=0 && y>=0 && x<fg_width && y<fg_height)
+  uint16_t *get_fgline(int y) { CHECK(y>=0 && y<fg_height); return map_fg+y*fg_width; }
+  uint16_t *get_bgline(int y) { CHECK(y>=0 && y<bg_height); return map_bg+y*bg_width; }
+  uint16_t get_fg(int x, int y) { if (x>=0 && y>=0 && x<fg_width && y<fg_height)
                                           return fgvalue(*(map_fg+x+y*fg_width)); 
                                         else return 0;
                                       }
-  unsigned short get_bg(int x, int y) { if (x>=0 && y>=0 && x<bg_width && y<bg_height)
+  uint16_t get_bg(int x, int y) { if (x>=0 && y>=0 && x<bg_width && y<bg_height)
                                           return *(map_bg+x+y*bg_width); 
                                          else return 0;
                                         }
-  void put_fg(int x, int y, unsigned short tile) { *(map_fg+x+y*fg_width)=tile; }   
-  void put_bg(int x, int y, unsigned short tile) { *(map_bg+x+y*bg_width)=tile; }
+  void put_fg(int x, int y, uint16_t tile) { *(map_fg+x+y*fg_width)=tile; }   
+  void put_bg(int x, int y, uint16_t tile) { *(map_bg+x+y*bg_width)=tile; }
   void draw_objects(view *v); 
   void interpolate_draw_objects(view *v);

abuse/trunk/src/include/light.hpp

@@ -8 +8 @@
 
 #define TTINTS 9
-extern uchar *tints[TTINTS];
-extern unsigned char *white_light,*white_light_initial,*green_light,*trans_table;
-extern short ambient_ramp;
+extern uint8_t *tints[TTINTS];
+extern uint8_t *white_light,*white_light_initial,*green_light,*trans_table;
+extern int16_t ambient_ramp;
 #define REVERSE_GREEN_TINT 8
 
-extern short shutdown_lighting_value,shutdown_lighting;
+extern int16_t shutdown_lighting_value,shutdown_lighting;
 
 class light_source
@@ -63 +63 @@
 light_patch *find_patch(int screenx, int screeny, light_patch *list);
 int calc_light_value(int32_t x, int32_t y, light_patch *which);                        
-void light_screen(image *sc, int32_t screenx, int32_t screeny, uchar *light_lookup, ushort ambient);
-void double_light_screen(image *sc, int32_t screenx, int32_t screeny, uchar *light_lookup, ushort ambient,
+void light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient);
+void double_light_screen(image *sc, int32_t screenx, int32_t screeny, uint8_t *light_lookup, uint16_t ambient,
                          image *out, int32_t out_x, int32_t out_y);
 

abuse/trunk/src/include/netface.hpp

@@ -96 +96 @@
 struct net_packet
 {
-  unsigned char data[PACKET_MAX_SIZE];
+  uint8_t data[PACKET_MAX_SIZE];
   int packet_prefix_size()                 { return 5; }    // 2 byte size, 2 byte check sum, 1 byte packet order
-  unsigned short packet_size()             { unsigned short size=(*(unsigned short *)data); return lstl(size); }
-  unsigned char tick_received()            { return data[4]; }  
-  void set_tick_received(unsigned char x)  { data[4]=x; }
-  unsigned char *packet_data()             { return data+packet_prefix_size(); }
-  unsigned short get_checksum()            { unsigned short cs=*((unsigned short *)data+1); return lstl(cs); }
-  unsigned short calc_checksum()
+  uint16_t packet_size()             { uint16_t size=(*(uint16_t *)data); return lstl(size); }
+  uint8_t tick_received()            { return data[4]; }  
+  void set_tick_received(uint8_t x)  { data[4]=x; }
+  uint8_t *packet_data()             { return data+packet_prefix_size(); }
+  uint16_t get_checksum()            { uint16_t cs=*((uint16_t *)data+1); return lstl(cs); }
+  uint16_t calc_checksum()
   {
-    *((unsigned short *)data+1)=0;
+    *((uint16_t *)data+1)=0;
     int i,size=packet_prefix_size()+packet_size();
-    unsigned char c1=0,c2=0,*p=data;
+    uint8_t c1=0,c2=0,*p=data;
     for (i=0;i<size;i++,p++)
     {
@@ -113 +113 @@
       c2+=c1;
     }
-    unsigned short cs=( (((unsigned short)c1)<<8) | c2);
-    *((unsigned short *)data+1)=lstl(cs);
+    uint16_t cs=( (((uint16_t)c1)<<8) | c2);
+    *((uint16_t *)data+1)=lstl(cs);
     return cs;
   }
@@ -129 +129 @@
     }
   }
-  void write_byte(unsigned char x) { add_to_packet(&x,1); }
-  void write_short(unsigned short x) { x=lstl(x); add_to_packet(&x,2); }
-  void write_long(unsigned long x) { x=lltl(x); add_to_packet(&x,4); }
+  void write_uint8(uint8_t x) { add_to_packet(&x,1); }
+  void write_uint16(uint16_t x) { x=lstl(x); add_to_packet(&x,2); }
+  void write_uint32(uint32_t x) { x=lltl(x); add_to_packet(&x,4); }
 
-  void set_packet_size(unsigned short x) { *((unsigned short *)data)=lstl(x); }
+  void set_packet_size(uint16_t x) { *((uint16_t *)data)=lstl(x); }
 
 
@@ -143 +143 @@
              last_packet;                   // last tick data (in case a client misses input, we can resend)
 
-  short mem_lock;
-  short calc_crcs;
-  short get_lsf;
-  short wait_reload;
-  short need_reload;
-  short input_state;            // COLLECTING or PROCESSING
-  short current_tick;           // set by engine, used by driver to confirm packet is not left over
+  int16_t mem_lock;
+  int16_t calc_crcs;
+  int16_t get_lsf;
+  int16_t wait_reload;
+  int16_t need_reload;
+  int16_t input_state;          // COLLECTING or PROCESSING
+  int16_t current_tick;         // set by engine, used by driver to confirm packet is not left over
   
   join_struct *join_list;

abuse/trunk/src/include/particle.hpp

@@ -17 +17 @@
 {
   short x,y;
-  uchar color;
+  uint8_t color;
 } ;
 

abuse/trunk/src/include/transp.hpp

@@ -3 +3 @@
 #include "image.hpp"
 #include "macs.hpp"
-void transp_put(image *im, image *screen, uchar *table, int x, int y);
+void transp_put(image *im, image *screen, uint8_t *table, int x, int y);
 
 #endif

abuse/trunk/src/include/view.hpp

@@ -14 +14 @@
   int32_t cx1,cy1,cx2,cy2,shift_down,shift_right,pan_x,pan_y;
   int32_t new_weapon;
-  uchar send_view,send_weapon_change;
+  uint8_t send_view,send_weapon_change;
 } ;
 
@@ -23 +23 @@
 class view
 {
-  uchar keymap[512/8];
+  uint8_t keymap[512/8];
   char chat_buf[60];
   public : 
@@ -80 +80 @@
   view *next;                             // next viewable player (singly linked list)  
   void get_input();
-  int process_input(char cmd, uchar *&pk);
+  int process_input(char cmd, uint8_t *&pk);
 
   void add_ammo   (int weapon_type, int total);
@@ -115 +115 @@
 void recalc_local_view_space();
 
-void process_packet_commands(uchar *pk, int size);
+void process_packet_commands(uint8_t *pk, int size);
 
 object_node *make_player_onodes(int player_num=-1);

abuse/trunk/src/innet.cpp

@@ -210 +210 @@
 
     if (!sock) { printf("set_file_server::connect failed\n"); return 0; }
-    uchar cmd=CLIENT_CRC_WAITER;
+    uint8_t cmd=CLIENT_CRC_WAITER;
     if ( (sock->write(&cmd,1)!=1 && printf("set_file_server::writefailed\n")) ||
          (sock->read(&cmd,1)!=1  && printf("set_file_server::read failed\n")))        // wait for confirmation that crc's are written
@@ -291 +291 @@
                                 if (new_sock)
                                 {
-                                  uchar client_type;
+                                  uint8_t client_type;
                                   if (new_sock->read(&client_type,1)!=1)
                                   {
@@ -316 +316 @@
                                       case CLIENT_LSF_WAITER :          // wants to know which .lsp file to start with
                                       {
-                                                                uchar len=strlen(lsf);
+                                                                uint8_t len=strlen(lsf);
                                                                 new_sock->write(&len,1);
                                                                 new_sock->write(lsf,len);
@@ -352 +352 @@
     if (!sock) return 0;
 
-    uchar ctype=CLIENT_LSF_WAITER;
-    uchar len;
+    uint8_t ctype=CLIENT_LSF_WAITER;
+    uint8_t len;
 
     if (sock->write(&ctype,1)!=1 ||
@@ -391 +391 @@
     }
 
-    uchar ctype=CLIENT_ABUSE;
-    ushort port=lstl(main_net_cfg->port+1),cnum;
-
-    uchar reg;
+    uint8_t ctype=CLIENT_ABUSE;
+    uint16_t port=lstl(main_net_cfg->port+1),cnum;
+
+    uint8_t reg;
     if (sock->write(&ctype,1)!=1 ||   // send server out game port
                                 sock->read(&reg,1)!=1)        // is remote engine registered?
@@ -427 +427 @@
       strcpy(uname,get_login());
     else strcpy(uname,"unknown");
-    uchar len=strlen(uname)+1;
+    uint8_t len=strlen(uname)+1;
     short nkills;
 

abuse/trunk/src/items.cpp

@@ -18 +18 @@
     }
 
-    inside=(unsigned char *)jmalloc(tot,"Boundary point list");  
+    inside=(uint8_t *)jmalloc(tot,"Boundary point list");  
   }
 
-  unsigned char *point_on;
+  uint8_t *point_on;
   
   for (i=0,point_on=data;i<tot-1;i++)
@@ -34 +34 @@
 
     int j,xp1,yp1,xp2,yp2,maxx,maxy,minx,miny;    
-    unsigned char *point2,segs_left=0,segs_right=0,segs_down=0;    
+    uint8_t *point2,segs_left=0,segs_right=0,segs_down=0;    
     int skip_next=0;    
     int check_left=0,check_right=0,check_down=0;
@@ -101 +101 @@
 {
   int x1,y1,x2,y2,checkx,checky,i;  
-  unsigned char *point_on;  
+  uint8_t *point_on;  
   if (tot)
   {
-    inside=(unsigned char *)jmalloc(tot,"Boundary point list");  
+    inside=(uint8_t *)jmalloc(tot,"Boundary point list");  
   } else inside=NULL;
   for (i=0,point_on=data;i<tot-1;i++)
@@ -117 +117 @@
 
     int j,xp1,yp1,xp2,yp2,maxx,maxy,minx,miny;    
-    unsigned char *point2,segs_left=0,segs_right=0,segs_down=0;    
+    uint8_t *point2,segs_left=0,segs_right=0,segs_down=0;    
     int skip_next=0;    
     int check_left=0,check_right=0,check_down=0;
@@ -186 +186 @@
 {
   im=load_image(fp);
-  next=fp->read_short();
+  next=fp->read_uint16();
 }
 
@@ -192 +192 @@
 {
   im=load_image(e,fp);
-  next=fp->read_short();
+  next=fp->read_uint16();
 }
 
 foretile::foretile(bFILE *fp)
 {
-  unsigned char *sl; 
+  uint8_t *sl; 
   image *img=load_image(fp);
 
@@ -203 +203 @@
   // create the micro image of the fore tile by aveginging the color values in 2 x 2 space
   // and storeing teh closest match
-//  unsigned char *buffer=(unsigned char *)&micro_image;
+//  uint8_t *buffer=(uint8_t *)&micro_image;
   int x,y,w=img->width(),h=img->height(),l;
   int r[AUTOTILE_WIDTH*AUTOTILE_HEIGHT],
@@ -250 +250 @@
   delete img; 
 
-  next=fp->read_short();
+  next=fp->read_uint16();
   fp->read(&damage,1);
 
@@ -285 +285 @@
     point_list p(fp); 
     advance=0;
-  } else advance=fp->read_byte();
+  } else advance=fp->read_uint8();
   
   f_damage=new boundary(fp,"fig bound"); 
@@ -296 +296 @@
 {
   palette *p=new palette(fp);
-  uchar *t=data,*p_addr=(uchar *)p->addr();
+  uint8_t *t=data,*p_addr=(uint8_t *)p->addr();
   for (int i=0;i<256;i++,t++,p_addr+=3)  
     *t=pal->find_closest(*p_addr,p_addr[1],p_addr[2]);

abuse/trunk/src/lcache.cpp

@@ -48 +48 @@
 {
   int type=item_type(level);
-  fp->write_byte(type);
+  fp->write_uint8(type);
 
 
@@ -54 +54 @@
   {
     case L_NUMBER :
-    { fp->write_long(lnumber_value(level)); } break;
+    { fp->write_uint32(lnumber_value(level)); } break;
     case L_CHARACTER :
-    { fp->write_short(lcharacter_value(level)); } break;
+    { fp->write_uint16(lcharacter_value(level)); } break;
     case L_STRING :
     { long l=strlen(lstring_value(level))+1;
-      fp->write_long(l);
+      fp->write_uint32(l);
       fp->write(lstring_value(level),l); 
     } break;
     case L_SYMBOL :
-    { fp->write_long((long)level); } break;
+    { fp->write_uint32((long)level); } break;
     case L_CONS_CELL :
     {
-      if (!level) fp->write_long(0);
+      if (!level) fp->write_uint32(0);
       else
       {
@@ -74 +74 @@
         if (b) 
         {
-          fp->write_long(-t);      // negative number means dotted list
+          fp->write_uint32(-t);      // negative number means dotted list
           write_level(fp,b);       // save end of dotted list     
         }
-        else fp->write_long(t);
+        else fp->write_uint32(t);
 
         for (b=level;b && item_type(b)==L_CONS_CELL;b=CDR(b))    
@@ -88 +88 @@
 Cell *load_block(bFILE *fp)
 {
-  int type=fp->read_byte();
+  int type=fp->read_uint8();
   switch (type)
   {   
     case L_NUMBER :
-    { return new_lisp_number(fp->read_long()); } break;
+    { return new_lisp_number(fp->read_uint32()); } break;
     case L_CHARACTER :
-    { return new_lisp_character(fp->read_short()); } break;
+    { return new_lisp_character(fp->read_uint16()); } break;
     case L_STRING :
-    { long l=fp->read_long();
+    { long l=fp->read_uint32();
       lisp_string *s=new_lisp_string(l);
       fp->read(lstring_value(s),l);
@@ -102 +102 @@
     } break;
     case L_SYMBOL :
-    { return (void *)fp->read_long(); } break;
+    { return (void *)fp->read_uint32(); } break;
     case L_CONS_CELL :
     {
-      long t=fp->read_long();
+      long t=fp->read_uint32();
       if (!t) return NULL;
       else

abuse/trunk/src/level.cpp

@@ -608 +608 @@
   {
     if (!rcheck) rcheck=open_file("rcheck","rb");
-    int32_t x=rcheck->read_long();
+    int32_t x=rcheck->read_uint32();
     if (x!=rand_on)
       dprintf("off!\n");
@@ -618 +618 @@
       rcheck_lp=open_file("rcheck.lp","wb");
     }
-    rcheck->write_long(rand_on);
+    rcheck->write_uint32(rand_on);
   } else
   {
@@ -761 +761 @@
 }
 
-void level::set_tick_counter(ulong x) 
+void level::set_tick_counter(uint32_t x) 
 { 
   ctick=x; 
@@ -867 +867 @@
   {
     fp->seek(se->offset,0);
-    if (RC_type_size(fp->read_byte())!=size)
+    if (RC_type_size(fp->read_uint8())!=size)
       return 0;
     else return 1;
@@ -886 +886 @@
     fp->seek(se->offset,0);
     /******************************* Read debug info ******************************/
-    int16_t old_tot=fp->read_short();  
+    int16_t old_tot=fp->read_uint16();  
     uint16_t *o_remap=(uint16_t *)jmalloc(old_tot*2,"obj remap array");    
     char old_name[150];      
     for (i=0;i<old_tot;i++)
     {
-      fp->read(old_name,fp->read_byte());    // read the name
+      fp->read(old_name,fp->read_uint8());    // read the name
       for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
       {
@@ -901 +901 @@
 
     /***************************** Read state names *********************************/
-    int old_stot=fp->read_short();
+    int old_stot=fp->read_uint16();
     unsigned char *s_remap=(unsigned char *)jmalloc(old_stot,"state remap array");
     for (i=0;i<old_stot;i++)
     {
-      fp->read(old_name,fp->read_byte());
+      fp->read(old_name,fp->read_uint8());
       s_remap[i]=stopped;           // non exsitant states get mapped into stopped state
       for (j=0;j<MAX_STATE;j++)                  // see if old state exist now
@@ -911 +911 @@
          s_remap[i]=j;
     }
-    total_objs=fp->read_long();    
+    total_objs=fp->read_uint32();    
 
     se=sd->find("type");
@@ -918 +918 @@
       fp->seek(se->offset,0);
       last=NULL;
-      if (fp->read_byte()==RC_S)    //  read type array, this should be type RC_S
+      if (fp->read_uint8()==RC_S)    //  read type array, this should be type RC_S
       {
         for (i=0;i<total_objs;i++)
         {
-          ushort t=fp->read_short();
+          uint16_t t=fp->read_uint16();
           game_object *p=new game_object(o_remap[t],1);
           clear_tmp();
@@ -934 +934 @@
         {
           fp->seek(se->offset,0);
-          if (fp->read_byte()==RC_S)    //  read state array, this should be type RC_S
+          if (fp->read_uint8()==RC_S)    //  read state array, this should be type RC_S
           {
             game_object *l=first;
             for (i=0;i<total_objs;i++,l=l->next)
             {
-              character_state s=(character_state)s_remap[fp->read_short()];
+              character_state s=(character_state)s_remap[fp->read_uint16()];
               if (l->otype!=0xffff)
               {
@@ -965 +965 @@
             fp->seek(se->offset,0);
             int t=object_descriptions[j].type;
-            if (fp->read_byte()!=t)
+            if (fp->read_uint8()!=t)
               dprintf("Warning : load level -> var '%s' size changed\n");
             else
@@ -974 +974 @@
                 switch (t)
                 {
-                  case RC_C : f->set_var(j,fp->read_byte()); break;
-                  case RC_S : f->set_var(j,fp->read_short()); break;
-                  case RC_L : f->set_var(j,fp->read_long()); break;
+                  case RC_C : f->set_var(j,fp->read_uint8()); break;
+                  case RC_S : f->set_var(j,fp->read_uint16()); break;
+                  case RC_L : f->set_var(j,fp->read_uint32()); break;
                 }
 
@@ -1018 +1018 @@
   {
     fp->seek(se->offset,0);
-    int16_t old_tot=fp->read_short();
+    int16_t old_tot=fp->read_uint16();
     se=sd->find("describe_names");
     if (!se || !old_tot)
@@ -1029 +1029 @@
     for (i=0;i<old_tot;i++)
     {
-      fp->read(old_name,fp->read_byte());    // read the name
+      fp->read(old_name,fp->read_uint8());    // read the name
       for (o_remap[i]=0xffff,j=0;j<total_objects;j++)  // check for matching current name
       {
@@ -1048 +1048 @@
     for (;i<old_tot;i++)
     {
-      int16_t t=fp->read_short();
+      int16_t t=fp->read_uint16();
       s_remap_totals[i]=t;
       if (t)
@@ -1062 +1062 @@
       for (;j<t;j++)
       {
-        fp->read(old_name,fp->read_byte());
+        fp->read(old_name,fp->read_uint8());
         int new_type=o_remap[i];        
         if (new_type<total_objects)     // make sure old object still exsist
@@ -1090 +1090 @@
       for (;i<old_tot;i++)
       {
-        int16_t t=fp->read_short();
+        int16_t t=fp->read_uint16();
         v_remap_totals[i]=t;
         if (t)
@@ -1100 +1100 @@
         for (;j<t;j++)
         {
-          fp->read(old_name,fp->read_byte());
+          fp->read(old_name,fp->read_uint8());
           int new_type=o_remap[i];
           if (new_type!=0xffff)        // make sure old object still exsist
@@ -1122 +1122 @@
     if (se)
     {
-      total_objs=fp->read_long();    
+      total_objs=fp->read_uint32();    
 
       se=sd->find("type");
@@ -1129 +1129 @@
         fp->seek(se->offset,0);
         last=NULL;
-        if (fp->read_byte()==RC_S)    //  read type array, this should be type RC_S
+        if (fp->read_uint8()==RC_S)    //  read type array, this should be type RC_S
         {
           int i=0;
           for (;i<total_objs;i++)
           {
-            ushort t=fp->read_short();
+            uint16_t t=fp->read_uint16();
             game_object *p=new game_object(o_remap[t],1);
             clear_tmp();
@@ -1145 +1145 @@
           {
             fp->seek(se->offset,0);
-            if (fp->read_byte()==RC_S)    //  read state array, this should be type RC_S
+            if (fp->read_uint8()==RC_S)    //  read state array, this should be type RC_S
             {
               game_object *l=first;
               for (i=0;i<total_objs;i++,l=l->next)
               {
-                int st=fp->read_short();
+                int st=fp->read_uint16();
                 if (l->otype==0xffff)
                   l->state=stopped;
@@ -1173 +1173 @@
             for (;o && !abort;o=o->next)
             {
-              int16_t ot=fp->read_short();
+              int16_t ot=fp->read_uint16();
               int k=0;
               for (;k<ot;k++)
               {
-                if (fp->read_byte()!=RC_L) abort=1;
+                if (fp->read_uint8()!=RC_L) abort=1;
                 else
                 {
-                  int32_t v=fp->read_long();
+                  int32_t v=fp->read_uint32();
                   if (o->otype!=0xffff)     // non-exstant object
                   {
@@ -1208 +1208 @@
               fp->seek(se->offset,0);
               int t=object_descriptions[j].type;
-              if (fp->read_byte()!=t)
+              if (fp->read_uint8()!=t)
                 dprintf("Warning : load level -> var '%s' size changed\n");
               else
@@ -1218 +1218 @@
                   {
                     case RC_C : 
-                    { f->set_var(j,fp->read_byte()); } break;
+                    { f->set_var(j,fp->read_uint8()); } break;
                     case RC_S : 
-                    { f->set_var(j,fp->read_short()); } break;
+                    { f->set_var(j,fp->read_uint16()); } break;
                     case RC_L : 
-                    { f->set_var(j,fp->read_long()); } break;
+                    { f->set_var(j,fp->read_uint32()); } break;
                   }
                   
@@ -1293 +1293 @@
   {
     fp->seek(e->offset,0);
-    int len=fp->read_byte();   // read the length of the string
+    int len=fp->read_uint8();   // read the length of the string
     first_name=(char *)jmalloc(len,"level first name");
     fp->read(first_name,len);    // read the string
@@ -1308 +1308 @@
   {    
     fp->seek(e->offset,0);
-    fg_width=fp->read_long();
-    fg_height=fp->read_long();
+    fg_width=fp->read_uint32();
+    fg_height=fp->read_uint32();
     map_fg=(uint16_t *)jmalloc(2*fg_width*fg_height,"Map fg : loaded");
     fp->read((char *)map_fg,2*fg_width*fg_height);
@@ -1326 +1326 @@
   {
     fp->seek(e->offset,0);
-    bg_width=fp->read_long();
-    bg_height=fp->read_long();
+    bg_width=fp->read_uint32();
+    bg_height=fp->read_uint32();
     map_bg=(uint16_t *)jmalloc(2*bg_width*bg_height,"Map bg : loaded");
     fp->read((char *)map_bg,2*bg_width*bg_height);
@@ -1644 +1644 @@
   eh->font()->put_string(i,80-strlen(buf)*eh->font()->width()/2,100+eh->font()->height(),buf);
 
-  fp->write_short(i->width());
-  fp->write_short(i->height());
+  fp->write_uint16(i->width());
+  fp->write_uint16(i->height());
   int y=0;
   for (;y<i->height();y++)
@@ -1658 +1658 @@
   view *v=player_list;
   for (;v;v=v->next) t++; 
-  fp->write_long(t);
+  fp->write_uint32(t);
 
   for (v=player_list;v;v=v->next)
-    fp->write_long(object_to_number_in_list(v->focus,save_list));
+    fp->write_uint32(object_to_number_in_list(v->focus,save_list));
 
   int tv=total_view_vars();
@@ -1667 +1667 @@
   for (;i<tv;i++)
   {
-    fp->write_byte(RC_L);
+    fp->write_uint8(RC_L);
     for (v=player_list;v;v=v->next)
-      fp->write_long(v->get_view_var_value(i));
-  }
-
-  fp->write_byte(RC_L);
-  fp->write_long(rand_on);
-
-  fp->write_byte(RC_L);
-  fp->write_long(total_weapons);
+      fp->write_uint32(v->get_view_var_value(i));
+  }
+
+  fp->write_uint8(RC_L);
+  fp->write_uint32(rand_on);
+
+  fp->write_uint8(RC_L);
+  fp->write_uint32(total_weapons);
   for (v=player_list;v;v=v->next)
     for (i=0;i<total_weapons;i++)
-      fp->write_long(v->weapons[i]);
+      fp->write_uint32(v->weapons[i]);
 
   for (v=player_list;v;v=v->next)
   {
     int len=strlen(v->name)+1;
-    fp->write_byte(len);
+    fp->write_uint8(len);
     fp->write(v->name,len);
   }
@@ -1726 +1726 @@
     }
 
-    int32_t total_players=fp->read_long();
+    int32_t total_players=fp->read_uint32();
     view *last=NULL;
     int i=0;
     for (;i<total_players;i++)    
     {
-      game_object *o=number_to_object_in_list(fp->read_long(),save_list);
+      game_object *o=number_to_object_in_list(fp->read_uint32(),save_list);
       v=new view(o,NULL,0);
       if (o) o->set_controller(v);
@@ -1750 +1750 @@
       {
         fp->seek(se->offset,0);
-        if (fp->read_byte()==RC_L)
+        if (fp->read_uint8()==RC_L)
         {
           for (v=player_list;v;v=v->next)
-            v->set_view_var_value(i,fp->read_long());
+            v->set_view_var_value(i,fp->read_uint32());
         }
       } else 
@@ -1766 +1766 @@
     {
       fp->seek(se->offset,0);
-      if (fp->read_byte()==RC_L)
-        rand_on=fp->read_long();
+      if (fp->read_uint8()==RC_L)
+        rand_on=fp->read_uint32();
     } else rand_on=0;
 
@@ -1774 +1774 @@
     {
       fp->seek(se->offset,0);
-      if (fp->read_byte()==RC_L)
-      {
-        int32_t m=fp->read_long();  // read how many weapons exsisted when last saved
+      if (fp->read_uint8()==RC_L)
+      {
+        int32_t m=fp->read_uint32();  // read how many weapons exsisted when last saved
         int i;
         for (v=player_list;v;v=v->next)   
@@ -1782 +1782 @@
           for (i=0;i<m;i++)
           {
-            int32_t x=fp->read_long();
+            int32_t x=fp->read_uint32();
             if (i<total_weapons)
             {
@@ -1806 +1806 @@
       for (v=player_list;v;v=v->next)     
       {
-        uchar len=fp->read_byte();
+        uint8_t len=fp->read_uint8();
         fp->read(v->name,len);
       }
@@ -1854 +1854 @@
   // record information in the file about what the data structures look like
   // right now, so if they change later, they don't get get screwed up
-  fp->write_short(total_objects);   // mark how many objects we know about right now  
+  fp->write_uint16(total_objects);   // mark how many objects we know about right now  
 
   int i=0;
   for (;i<total_objects;i++)   // loop through all the object types we know of
   {    
-    fp->write_byte(strlen(object_names[i])+1);                    // sizeof name    
+    fp->write_uint8(strlen(object_names[i])+1);                    // sizeof name    
     fp->write(object_names[i],strlen(object_names[i])+1);      // write object name
   }
@@ -1871 +1871 @@
     for (;j<figures[i]->ts;j++)
       if (figures[i]->seq[j]) total++;
-    fp->write_short(total);
+    fp->write_uint16(total);
 
     for (j=0;j<figures[i]->ts;j++)
@@ -1877 +1877 @@
       {
         char *state_name=lstring_value(symbol_name(figures[i]->seq_syms[j]));
-        fp->write_byte(strlen(state_name)+1);
+        fp->write_uint8(strlen(state_name)+1);
         fp->write(state_name,strlen(state_name)+1);
       }
@@ -1886 +1886 @@
   for (i=0;i<total_objects;i++)
   {
-    fp->write_short(figures[i]->tv);
+    fp->write_uint16(figures[i]->tv);
     int j,x;
     
@@ -1896 +1896 @@
         {
           char *var_name=lstring_value(symbol_name(figures[i]->vars[j]));
-          fp->write_byte(strlen(var_name)+1);
+          fp->write_uint8(strlen(var_name)+1);
           fp->write(var_name,strlen(var_name)+1);
         }
@@ -1906 +1906 @@
   object_node *o=save_list;
   for (;o;o=o->next) t++;
-  fp->write_long(t);
-
-
-  fp->write_byte(RC_S);                                    // save type info for each record
-  for (o=save_list;o;o=o->next) fp->write_short(o->me->type());    
-
-  fp->write_byte(RC_S);                                    // save state info for each record
-  for (o=save_list;o;o=o->next) fp->write_short(o->me->reduced_state());
+  fp->write_uint32(t);
+
+
+  fp->write_uint8(RC_S);                                    // save type info for each record
+  for (o=save_list;o;o=o->next) fp->write_uint16(o->me->type());    
+
+  fp->write_uint8(RC_S);                                    // save state info for each record
+  for (o=save_list;o;o=o->next) fp->write_uint16(o->me->reduced_state());
 
   for (o=save_list;o;o=o->next)                            // save lvars
   {
-    fp->write_short(figures[o->me->otype]->tv);
+    fp->write_uint16(figures[o->me->otype]->tv);
     for (i=0;i<figures[o->me->otype]->tv;i++) 
     {
-      fp->write_byte(RC_L);                           // for now the only type allowed is int32_t
-      fp->write_long(o->me->lvars[i]);
+      fp->write_uint8(RC_L);                           // for now the only type allowed is int32_t
+      fp->write_uint32(o->me->lvars[i]);
     }
   }
@@ -1928 +1928 @@
   {
     int t=object_descriptions[i].type;
-    fp->write_byte(t);
+    fp->write_uint8(t);
     for (o=save_list;o;o=o->next)
     {
@@ -1934 +1934 @@
       {         
         case RC_C :
-        { fp->write_byte(o->me->get_var(i)); } break;
+        { fp->write_uint8(o->me->get_var(i)); } break;
         case RC_S :
-        { fp->write_short(o->me->get_var(i)); } break;
+        { fp->write_uint16(o->me->get_var(i)); } break;
         case RC_L :
-        { fp->write_long(o->me->get_var(i)); } break;
+        { fp->write_uint32(o->me->get_var(i)); } break;
       }
     }
@@ -1963 +1963 @@
 void level::write_links(bFILE *fp, object_node *save_list, object_node *exclude_list)
 {
-  fp->write_byte(RC_L);  
-  fp->write_long(total_object_links(save_list));
+  fp->write_uint8(RC_L);  
+  fp->write_uint32(total_object_links(save_list));
 
   int x=1;
@@ -1974 +1974 @@
     for (;i<o->me->total_objects();i++)
     {
-      fp->write_long(x);
+      fp->write_uint32(x);
       int32_t x=object_to_number_in_list(o->me->get_object(i),save_list); 
       if (x)
-        fp->write_long(x);
+        fp->write_uint32(x);
       else                            // save links to excluded items as negative
-        fp->write_long((int32_t)(-(object_to_number_in_list(o->me,exclude_list))));
-    }
-  }
-
-  fp->write_byte(RC_L);  
-  fp->write_long(total_light_links(save_list));
+        fp->write_uint32((int32_t)(-(object_to_number_in_list(o->me,exclude_list))));
+    }
+  }
+
+  fp->write_uint8(RC_L);  
+  fp->write_uint32(total_light_links(save_list));
 
   x=1;
@@ -1992 +1992 @@
     for (;i<o->me->total_lights();i++)
     {
-      fp->write_long(x);
-      fp->write_long(light_to_number(o->me->get_light(i)));
+      fp->write_uint32(x);
+      fp->write_uint32(light_to_number(o->me->get_light(i)));
     }
   }
@@ -2007 +2007 @@
   {
     fp->seek(se->offset,0);
-    if (fp->read_byte()==RC_L)
-    {
-      int32_t t=fp->read_long();
+    if (fp->read_uint8()==RC_L)
+    {
+      int32_t t=fp->read_uint32();
       while (t)
       {
-        int32_t x1=fp->read_long();
+        int32_t x1=fp->read_uint32();
         CONDITION(x1>=0,"expected x1 for object link to be > 0\n");
-        int32_t x2=fp->read_long();
+        int32_t x2=fp->read_uint32();
         game_object *p,*q=number_to_object_in_list(x1,save_list);
         if (x2>0)
@@ -2032 +2032 @@
   {
     fp->seek(se->offset,0);
-    if (fp->read_byte()==RC_L)
-    {
-      int32_t t=fp->read_long();
+    if (fp->read_uint8()==RC_L)
+    {
+      int32_t t=fp->read_uint32();
       while (t)
       {
-        int32_t x1=fp->read_long();
-        int32_t x2=fp->read_long();
+        int32_t x1=fp->read_uint32();
+        int32_t x2=fp->read_uint32();
         game_object *p=number_to_object_in_list(x1,save_list);
         if (p)
@@ -2054 +2054 @@
 {
   // save background scroll rate
-  fp->write_byte(RC_L);
-  fp->write_long(bg_xmul);
-  fp->write_long(bg_xdiv);
-  fp->write_long(bg_ymul);
-  fp->write_long(bg_ydiv);
-
-  fp->write_byte(RC_L);
+  fp->write_uint8(RC_L);
+  fp->write_uint32(bg_xmul);
+  fp->write_uint32(bg_xdiv);
+  fp->write_uint32(bg_ymul);
+  fp->write_uint32(bg_ydiv);
+
+  fp->write_uint8(RC_L);
   int ta=0;
   area_controller *a=area_list;
   for (;a;a=a->next) ta++;
-  fp->write_long(ta);
+  fp->write_uint32(ta);
   for (a=area_list;a;a=a->next)
   {
-    fp->write_long(a->x);
-    fp->write_long(a->y);
-    fp->write_long(a->w);
-    fp->write_long(a->h);
-    fp->write_long(a->active);
-
-    fp->write_long(a->ambient);
-    fp->write_long(a->view_xoff);
-    fp->write_long(a->view_yoff);
-    fp->write_long(a->ambient_speed);
-    fp->write_long(a->view_xoff_speed);
-    fp->write_long(a->view_yoff_speed);
-  }
-  fp->write_byte(RC_L);
-  fp->write_long(tick_counter());
+    fp->write_uint32(a->x);
+    fp->write_uint32(a->y);
+    fp->write_uint32(a->w);
+    fp->write_uint32(a->h);
+    fp->write_uint32(a->active);
+
+    fp->write_uint32(a->ambient);
+    fp->write_uint32(a->view_xoff);
+    fp->write_uint32(a->view_yoff);
+    fp->write_uint32(a->ambient_speed);
+    fp->write_uint32(a->view_xoff_speed);
+    fp->write_uint32(a->view_yoff_speed);
+  }
+  fp->write_uint8(RC_L);
+  fp->write_uint32(tick_counter());
 }
 
@@ -2090 +2090 @@
   {
     fp->seek(se->offset,0);
-    if (fp->read_byte()!=RC_L)
+    if (fp->read_uint8()!=RC_L)
     { bg_xmul=bg_ymul=1; bg_xdiv=bg_ydiv=8; }
     else
   &n