src/lib/16_head.c

   1 /* Project 16 Source Code~
   2  * Copyright (C) 2012-2015 sparky4 & pngwen & andrius4669
   3  *
   4  * This file is part of Project 16.
   5  *
   6  * Project 16 is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Project 16 is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>, or
  18  * write to the Free Software Foundation, Inc., 51 Franklin Street,
  19  * Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 #include "src/lib/16_head.h"
  24
  25 /* Function: Wait **********************************************************\r
  26 *\r
  27 *     Parameters:    wait - time in microseconds\r
  28 *\r
  29 *     Description:    pauses for a specified number of microseconds.\r
  30 *\r
  31 */\r
  32 void wait(clock_t wait){\r
  33         clock_t goal;\r
  34 \r
  35         if(!wait) return;\r
  36 \r
  37         goal = wait + clock();\r
  38         while((goal > clock()) && !kbhit()) ;\r
  39 } /* End of wait */
  40
  41 void* AllocateLargestFreeBlock(size_t* Size)
  42 {
  43   size_t s0, s1;
  44   void* p;
  45
  46   s0 = ~(size_t)0 ^ (~(size_t)0 >> 1);
  47
  48   while (s0 && (p = malloc(s0)) == NULL)
  49     s0 >>= 1;
  50
  51   if (p)
  52     free(p);
  53
  54   s1 = s0 >> 1;
  55
  56   while (s1)
  57   {
  58     if ((p = malloc(s0 + s1)) != NULL)
  59     {
  60       s0 += s1;
  61       free(p);
  62     }
  63     s1 >>= 1;
  64   }
  65
  66   while (s0 && (p = malloc(s0)) == NULL)
  67     s0 ^= s0 & -s0;
  68
  69   *Size = s0;
  70   return p;
  71 }
  72
  73 size_t GetFreeSize(void)
  74 {
  75   size_t total = 0;
  76   void* pFirst = NULL;
  77   void* pLast = NULL;
  78
  79   for (;;)
  80   {
  81     size_t largest;
  82     void* p = AllocateLargestFreeBlock(&largest);
  83
  84     if (largest < sizeof(void*))
  85     {
  86       if (p != NULL)
  87         free(p);
  88       break;
  89     }
  90
  91     *(void**)p = NULL;
  92
  93     total += largest;
  94
  95     if (pFirst == NULL)
  96       pFirst = p;
  97
  98     if (pLast != NULL)
  99       *(void**)pLast = p;
 100
 101     pLast = p;
 102   }
 103
 104   while (pFirst != NULL)
 105   {
 106     void* p = *(void**)pFirst;
 107     free(pFirst);
 108     pFirst = p;
 109   }
 110
 111   return total;
 112 }
 113
 114 void far* AllocateLargestFarFreeBlock(size_t far* Size)
 115 {
 116         size_t s0, s1;
 117         void far* p;
 118
 119         s0 = ~(size_t)0 ^ (~(size_t)0 >> 1);
 120         while (s0 && (p = _fmalloc(s0)) == NULL)
 121                 s0 >>= 1;
 122
 123         if (p)
 124                 _ffree(p);
 125
 126         s1 = s0 >> 1;
 127         while (s1)
 128         {
 129                 if ((p = _fmalloc(s0 + s1)) != NULL)
 130                 {
 131                         s0 += s1;
 132                         _ffree(p);
 133                 }
 134         s1 >>= 1;
 135         }
 136         while (s0 && (p = _fmalloc(s0)) == NULL)
 137                 s0 ^= s0 & -s0;
 138
 139         *Size = s0;
 140         return p;
 141 }
 142
 143 size_t GetFarFreeSize(void)
 144 {
 145         size_t total = 0;
 146         void far* pFirst = NULL;
 147         void far* pLast = NULL;
 148         for(;;)
 149         {
 150                 size_t largest;
 151                 void far* p = AllocateLargestFarFreeBlock(&largest);
 152                 if (largest < sizeof(void far*))
 153                 {
 154                         if (p != NULL)
 155                         _ffree(p);
 156                         break;
 157                 }
 158                 *(void far* far*)p = NULL;
 159                 total += largest;
 160                 if (pFirst == NULL)
 161                         pFirst = p;
 162
 163                 if (pLast != NULL)
 164                         *(void far* far*)pLast = p;
 165                 pLast = p;
 166         }
 167
 168         while (pFirst != NULL)
 169         {
 170                 void far* p = *(void far* far*)pFirst;
 171                 _ffree(pFirst);
 172                 pFirst = p;
 173         }
 174         return total;
 175 }
 176
 177 //near versions
 178 void __near* AllocateLargestNearFreeBlock(size_t* Size)
 179 {
 180         size_t s0, s1;
 181         void __near* p;
 182
 183         s0 = ~(size_t)0 ^ (~(size_t)0 >> 1);
 184         while (s0 && (p = _nmalloc(s0)) == NULL)
 185                 s0 >>= 1;
 186
 187         if (p)
 188                 _nfree(p);
 189
 190         s1 = s0 >> 1;
 191         while (s1)
 192         {
 193                 if ((p = _nmalloc(s0 + s1)) != NULL)
 194                 {
 195                         s0 += s1;
 196                         _nfree(p);
 197                 }
 198         s1 >>= 1;
 199         }
 200         while (s0 && (p = _nmalloc(s0)) == NULL)
 201                 s0 ^= s0 & -s0;
 202
 203         *Size = s0;
 204         return p;
 205 }
 206
 207 size_t GetNearFreeSize(void)
 208 {
 209         size_t total = 0;
 210         void __near* pFirst = NULL;
 211         void __near* pLast = NULL;
 212         for(;;)
 213         {
 214                 size_t largest;
 215                 void __near* p = AllocateLargestNearFreeBlock(&largest);
 216                 if (largest < sizeof(void __near*))
 217                 {
 218                         if (p != NULL)
 219                         _nfree(p);
 220                         break;
 221                 }
 222                 *(void __near* __near*)p = NULL;
 223                 total += largest;
 224                 if (pFirst == NULL)
 225                         pFirst = p;
 226
 227                 if (pLast != NULL)
 228                         *(void __near* __near*)pLast = p;
 229                 pLast = p;
 230         }
 231
 232         while (pFirst != NULL)
 233         {
 234                 void __near* p = *(void __near* __near*)pFirst;
 235                 _nfree(pFirst);
 236                 pFirst = p;
 237         }
 238         return total;
 239 }
 240
 241 long int
 242 filesize(FILE *fp)\r
 243 {\r
 244         long int save_pos, size_of_file;\r
 245 \r
 246         save_pos = ftell(fp);\r
 247         fseek(fp, 0L, SEEK_END);\r
 248         size_of_file = ftell(fp);\r
 249         fseek(fp, save_pos, SEEK_SET);\r
 250         return(size_of_file);\r
 251 }
 252
 253 ///////////////////////////////////////////////////////////////////////////\r
 254 //\r
 255 //      US_CheckParm() - checks to see if a string matches one of a set of\r
 256 //              strings. The check is case insensitive. The routine returns the\r
 257 //              index of the string that matched, or -1 if no matches were found\r
 258 //\r
 259 ///////////////////////////////////////////////////////////////////////////\r
 260 int\r
 261 US_CheckParm(char *parm,char **strings)\r
 262 {\r
 263         char    cp,cs,\r
 264                         *p,*s;\r
 265         int             i;\r
 266 \r
 267         while (!isalpha(*parm)) // Skip non-alphas\r
 268                 parm++;\r
 269 \r
 270         for (i = 0;*strings && **strings;i++)\r
 271         {\r
 272                 for (s = *strings++,p = parm,cs = cp = 0;cs == cp;)\r
 273                 {\r
 274                         cs = *s++;\r
 275                         if (!cs)\r
 276                                 return(i);\r
 277                         cp = *p++;\r
 278 \r
 279                         if (isupper(cs))\r
 280                                 cs = tolower(cs);\r
 281                         if (isupper(cp))\r
 282                                 cp = tolower(cp);\r
 283                 }\r
 284         }\r
 285         return(-1);\r
 286 }
 287
 288 /*\r
 289 ==========================\r
 290 =\r
 291 = Quit\r
 292 =\r
 293 ==========================\r
 294 */\r
 295 \r
 296 /*void Quit(char *error, ...)\r
 297 {\r
 298         short exit_code=0;\r
 299         unsigned        finscreen;\r
 300 \r
 301         va_list ap;\r
 302 \r
 303         va_start(ap,error);\r
 304 \r
 305 #ifndef CATALOG\r
 306         if (!error)\r
 307         {\r
 308                 CA_SetAllPurge ();\r
 309                 CA_CacheGrChunk (PIRACY);\r
 310                 finscreen = (unsigned)grsegs[PIRACY];\r
 311         }\r
 312 #endif\r
 313 \r
 314         //ShutdownId ();\r
 315 \r
 316         if (error && *error)\r
 317         {\r
 318                 vprintf(error,ap);\r
 319                 exit_code = 1;\r
 320         }\r
 321 #ifndef CATALOG\r
 322         else\r
 323         if (!NoWait)\r
 324         {\r
 325                 movedata (finscreen,0,0xb800,0,4000);\r
 326                 bioskey (0);\r
 327         }\r
 328 #endif\r
 329 \r
 330         va_end(ap);\r
 331 \r
 332 #ifndef CATALOG\r
 333         if (!error)\r
 334         {\r
 335                 _argc = 2;\r
 336                 _argv[1] = "LAST.SHL";\r
 337                 _argv[2] = "ENDSCN.SCN";\r
 338                 _argv[3] = NULL;\r
 339                 if (execv("LOADSCN.EXE", _argv) == -1)\r
 340                 {\r
 341                         clrscr();\r
 342                         puts("Couldn't find executable LOADSCN.EXE.\n");\r
 343                         exit(1);\r
 344                 }\r
 345         }\r
 346 #endif\r
 347 \r
 348         exit(exit_code);\r
 349 }*/