Line data    Source code

       1             : // implementation of generic tools
       2             : 
       3             : #include "../libprimis-headers/cube.h"
       4             : #include "stream.h"
       5             : 
       6             : ////////////////////////// strings ////////////////////////////////////////
       7             : 
       8           6 : char *tempformatstring(const char *fmt, ...)
       9             : {
      10             :     static string tmpstr[4];
      11             :     static int tmpidx = 0;
      12           6 :     tmpidx = (tmpidx+1)%4;
      13             : 
      14             :     va_list v;
      15           6 :     va_start(v, fmt);
      16           6 :     vformatstring(tmpstr[tmpidx], fmt, v);
      17           6 :     va_end(v);
      18             : 
      19           6 :     return tmpstr[tmpidx];
      20             : }
      21             : 
      22             : ////////////////////////// bit packing ////////////////////////////////////
      23             : 
      24             : // these functions are useful for packing ints/chars into smaller chunks, which
      25             : // is useful for reducing file save sizes
      26             : 
      27             : // note that the parent put*_ template functions is not defined here but in tools.h
      28             : 
      29             : //*             signed integers            *//
      30          13 : void putint(ucharbuf &p, int n)
      31             : {
      32          13 :     putint_(p, n);
      33          13 : }
      34             : 
      35             : //Stores the passed integer into a uchar array, by splitting it into four bytes.
      36           2 : void putint(std::vector<uchar> &p, int n)
      37             : {
      38           2 :     p.push_back((n >> 24) & 0xFF);
      39           2 :     p.push_back((n >> 16) & 0xFF);
      40           2 :     p.push_back((n >> 8 ) & 0xFF);
      41           2 :     p.push_back(n & 0xFF);
      42           2 : }
      43             : 
      44             : //Removes the last four values from the uchar array, returning its int representation.
      45           2 : int getint(std::vector<uchar> &p)
      46             : {
      47           2 :     int a = 0;
      48           2 :     a += static_cast<int>(p.back());
      49           2 :     p.pop_back();
      50           2 :     a += static_cast<int>(p.back()) << 8;
      51           2 :     p.pop_back();
      52           2 :     a += static_cast<int>(p.back()) << 16;
      53           2 :     p.pop_back();
      54           2 :     a += static_cast<int>(p.back()) << 24;
      55           2 :     p.pop_back();
      56           2 :     return a;
      57             : }
      58             : 
      59             : //Stores the passed float into a uchar array, by splitting it into four bytes.
      60           2 : void putfloat(std::vector<uchar> &p, float n)
      61             : {
      62             :     uchar arr[sizeof(float)];
      63           2 :     std::memcpy(arr, &n, sizeof(float));
      64          10 :     for(unsigned long i = 0; i < sizeof(float); ++i)
      65             :     {
      66           8 :         p.push_back(arr[sizeof(float)-i-1]);
      67             :     }
      68           2 : }
      69             : 
      70             : //Removes the last four values from the uchar array, returning its float representation.
      71           2 : float getfloat(std::vector<uchar> &p)
      72             : {
      73             :     uchar arr[sizeof(float)];
      74          10 :     for(unsigned long i = 0; i < sizeof(float); ++i)
      75             :     {
      76           8 :         arr[i] = p.back();
      77           8 :         p.pop_back();
      78             :     }
      79           2 :     float n = 0.f;
      80           2 :     std::memcpy(&n, arr, sizeof(float));
      81           2 :     return n;
      82             : }
      83             : 
      84             : 
      85          13 : int getint(ucharbuf &p)
      86             : {
      87          13 :     int c = static_cast<char>(p.get());
      88          13 :     if(c == -128)
      89             :     {
      90           1 :         int n = p.get();
      91           1 :         n |= static_cast<char>(p.get()) << 8;
      92           1 :         return n;
      93             :     }
      94          12 :     else if(c == -127)
      95             :     {
      96           1 :         int n = p.get();
      97           1 :         n |= p.get() << 8;
      98           1 :         n |= p.get() << 16;
      99           1 :         return n|(p.get()<<24);
     100             :     }
     101             :     else
     102             :     {
     103          11 :         return c;
     104             :     }
     105             : }
     106             : 
     107             : //*             unisigned integers            *//
     108             : // much smaller encoding for unsigned integers up to 28 bits, but can handle signed
     109             : 
     110           4 : void putuint(ucharbuf &p, int n)
     111             : {
     112           4 :     putuint_(p, n);
     113           4 : }
     114             : 
     115           4 : int getuint(ucharbuf &p)
     116             : {
     117           4 :     int n = p.get();
     118           4 :     if(n & 0x80)
     119             :     {
     120           3 :         n += (p.get() << 7) - 0x80;
     121           3 :         if(n & (1<<14))
     122             :         {
     123           2 :             n += (p.get() << 14) - (1<<14);
     124             :         }
     125           3 :         if(n & (1<<21))
     126             :         {
     127           1 :             n += (p.get() << 21) - (1<<21);
     128             :         }
     129           3 :         if(n & (1<<28))
     130             :         {
     131           1 :             n |= ~0U<<28;
     132             :         }
     133             :     }
     134           4 :     return n;
     135             : }
     136             : 
     137             : //*             floats            *//
     138           2 : void putfloat(ucharbuf &p, float f)
     139             : {
     140           2 :     putfloat_(p, f);
     141           2 : }
     142             : 
     143           2 : float getfloat(ucharbuf &p)
     144             : {
     145             :     float f;
     146           2 :     p.get(reinterpret_cast<uchar *>(&f), sizeof(float));
     147           2 :     return f;
     148             : }
     149             : 
     150             : //*             strings            *//
     151           2 : void sendstring(const char *t, ucharbuf &p)
     152             : {
     153           2 :     sendstring_(t, p);
     154           2 : }
     155           0 : void sendstring(const char *t, std::vector<uchar> &p)
     156             : {
     157           0 :     sendstring_(t, p);
     158           0 : }
     159             : 
     160           2 : void getstring(char *text, ucharbuf &p, size_t len)
     161             : {
     162           2 :     char *t = text;
     163             :     do
     164             :     {
     165          10 :         if(t >= &text[len])
     166             :         {
     167           0 :             text[len-1] = 0;
     168           0 :             return;
     169             :         }
     170          10 :         if(!p.remaining())
     171             :         {
     172           0 :             *t = 0;
     173           0 :             return;
     174             :         }
     175          10 :         *t = getint(p);
     176          10 :     } while(*t++);
     177             : }
     178             : 
     179           5 : void filtertext(char *dst, const char *src, bool whitespace, bool forcespace, size_t len)
     180             : {
     181          37 :     for(int c = static_cast<uchar>(*src); c; c = static_cast<uchar>(*++src))
     182             :     {
     183          33 :         if(c == '\f')
     184             :         {
     185           3 :             if(!*++src)
     186             :             {
     187           0 :                 break;
     188             :             }
     189           3 :             continue;
     190             :         }
     191          30 :         if(!iscubeprint(c))
     192             :         {
     193           0 :             if(!iscubespace(c) || !whitespace)
     194             :             {
     195           0 :                 continue;
     196             :             }
     197           0 :             if(forcespace)
     198             :             {
     199           0 :                 c = ' ';
     200             :             }
     201             :         }
     202          30 :         *dst++ = c;
     203          30 :         if(!--len)
     204             :         {
     205           1 :             break;
     206             :         }
     207             :     }
     208           5 :     *dst = '\0';
     209           5 : }