test/uae/types.h

   1 #ifndef EXEC_TYPES_H
   2 #define EXEC_TYPES_H
   3
   4 #include <netinet/in.h>
   5
   6 typedef char BYTE;
   7 typedef unsigned char UBYTE;
   8
   9 class WORD
  10 {
  11 /* This is the data. It's defined in protected mode so the child classes
  12    can directly access it. Note that the value is encoded in *big endian*. */
  13 protected:
  14     short data;
  15
  16 /* Now the initializations and the conversions. They are defined in public
  17    mode because everyone must be able to access them. */
  18 public:
  19     /* Convert the data to int in host-endianess */
  20     inline operator int ()
  21     {
  22         return (int) ntohs (data);
  23     }
  24
  25     /* Same for short */
  26     inline operator short ()
  27     {
  28         return ntohs (data);
  29     }
  30
  31     /* Create a variable of type WORD from a short */
  32     inline WORD (short v)
  33     {
  34         data = htons (v);
  35     }
  36
  37     /* Same but from an int */
  38     inline WORD (int v)
  39     {
  40         //printf ("WORD(int): v=%d\n", v);
  41         data = htons (((short)v));
  42         //printf ("WORD(int): data=%d\n", data);
  43     }
  44
  45     /* How to copy a variable of type WORD */
  46     inline WORD (const WORD& v)
  47     {
  48         data = v.data;
  49     }
  50
  51     /* How to create an uninitilized WORD variable */
  52     inline WORD ()
  53     {
  54         return;
  55     }
  56 };
  57
  58 /* This is pretty much the same but different types */
  59 class APTR
  60 {
  61 protected:
  62     long data;
  63
  64 public:
  65     inline operator int ()
  66     {
  67         return (int) ntohl (data);
  68     }
  69
  70     inline operator void * ()
  71     {
  72         return (void *) ntohl (data);
  73     }
  74
  75     inline APTR (int v)
  76     {
  77         data = htonl (v);
  78     }
  79
  80     inline APTR (void * v)
  81     {
  82         data = htonl (((long)v));
  83     }
  84
  85     inline APTR (const APTR& v)
  86     {
  87         data = v.data;
  88     }
  89
  90     inline APTR ()
  91     {
  92         return;
  93     }
  94
  95 #ifdef DEBUG
  96     /* Debugging */
  97     inline void print ()
  98     {
  99         printf ("%08lx", data);
 100     }
 101 #endif
 102 };
 103
 104 /* This is an example how to inhert the functionality for other
 105    pointers. */
 106 class STRPTR : APTR
 107 {
 108 public:
 109     inline operator char * ()
 110     {
 111         return (char *) ntohl (data);
 112     }
 113
 114     inline operator const char * ()
 115     {
 116         return (const char *) ntohl (data);
 117     }
 118
 119     inline STRPTR ()
 120     {
 121         return;
 122     }
 123
 124     inline STRPTR (char * v)
 125     {
 126         data = htonl ((long)v);
 127     }
 128 };
 129
 130 #endif /* EXEC_TYPES_H */
 131