home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #1 / monster.zip / monster / OS2 / SSAVER2X.ZIP / MINIRTL.C < prev    next >
C/C++ Source or Header  |  1993-12-13  |  4KB  |  199 lines
  1. /*
  2.     minirtl.c
  3.     mini run time library for use with
  4.     ScreenSaver modules with Borland C++
  5. */
  6. #define INCL_DOS
  7. #define INCL_WIN
  8. #include <os2.h>
  9. #include <string.h>
  10. #include <malloc.h>
  11. #include <memory.h>
  12. #include <process.h>
  13.  
  14. /*
  15.     this part of the file was taken from emx 0.8g
  16.     -- Copyright (c) 1990-1993 by Eberhard Mattes
  17. */
  18.  
  19. void    *memcpy (void *s1, const void *s2, size_t n)
  20. {
  21.     size_t i;
  22.   
  23.     for (i = 0; i < n; ++i)
  24.         ((char *)s1)[i] = ((char *)s2)[i];
  25.     return (s1);
  26. }
  27. void    *memset (void *s, int c, size_t n)
  28. {
  29.     size_t i;
  30.     for (i = 0; i < n; ++i)
  31.         ((char *)s)[i] = (char)c;
  32.     return (s);
  33. }
  34. char    *strcat (char *string1, const char *string2)
  35. {
  36.     char *dst;
  37.     dst = string1;
  38.     while (*dst != 0)
  39.         ++dst;
  40.     while ((*dst = *string2) != 0)
  41.         ++dst, ++string2;
  42.     return (string1);
  43. }
  44. char    *strcpy (char *string1, const char *string2)
  45. {
  46.     char *dst;
  47.     dst = string1;
  48.     while ((*dst = *string2) != 0)
  49.         ++dst, ++string2;
  50.     return (string1);
  51. }
  52. size_t    strlen (const char *string)
  53. {
  54.     size_t i;
  55.     i = 0;
  56.     while (string[i] != 0) ++i;
  57.     return (i);
  58. }
  59.  
  60. static unsigned int __rand = 1;
  61. int    rand()
  62. {
  63.     __rand = __rand * 69069 + 5;
  64.     return ((__rand >> 16) & 0x7fff);
  65. }
  66. void    srand(unsigned int seed)
  67. {
  68.     __rand = seed;
  69. }
  70.  
  71. /*
  72.     the rest of the file is
  73.     (C) 1993 Siegfried Hanisch
  74. */
  75.  
  76. // if 1MB is not enough, increase this value
  77. // the memory is not commited, so it does not use physical memory
  78. #define MEMPOOLSIZE        (1024L*1024L)
  79. static    void    *mempool = NULL;
  80.  
  81. void    *malloc(size_t size)
  82. {
  83.     APIRET    rc;
  84.     size_t    *mem;
  85.     rc = DosSubAllocMem(mempool, (PVOID *)&mem, size+sizeof(size_t));
  86.     if(rc){
  87.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  88.         return NULL;
  89.     }
  90.     mem[0] = size;
  91.     return (void *)(&mem[1]);
  92. }
  93.  
  94. void    free(void *mem)
  95. {
  96.     APIRET    rc;
  97.     size_t    *m;
  98.     m = (size_t *)mem;
  99.     rc = DosSubFreeMem(mempool, &m[-1], m[-1]+sizeof(size_t));
  100.     if(rc){
  101.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  102.     }
  103. }
  104.  
  105. void    *realloc(void *mem, size_t size)
  106. {
  107.     void    *new_mem;
  108.     size_t    *m;
  109.     size_t    old_size;
  110.     m = (size_t *)mem;
  111.     old_size = m[-1];
  112.  
  113.     new_mem = malloc(size);
  114.     memcpy(new_mem, mem, old_size);
  115.     memset(((char *)new_mem)+old_size, 0 , size-old_size);
  116.     free(mem);
  117.     return new_mem;
  118. }
  119.  
  120. char    *strdup(const char *string)
  121. {
  122.     return strcpy(malloc(strlen(string)+1), string);
  123. }
  124.  
  125. BOOL    alloc_heap()
  126. {
  127.     APIRET    rc;
  128.     rc = DosAllocMem((PVOID *)&mempool, MEMPOOLSIZE, PAG_READ|PAG_WRITE);
  129.     if(rc){
  130.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  131.         mempool = NULL;
  132.         return FALSE;
  133.     }
  134.  
  135.     rc = DosSubSetMem(mempool, DOSSUB_INIT|DOSSUB_SPARSE_OBJ, MEMPOOLSIZE);
  136.     if(rc){
  137.         DosFreeMem(mempool);
  138.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  139.         return FALSE;
  140.     }
  141.     return TRUE;
  142. }
  143.  
  144. void    free_heap()
  145. {
  146.     APIRET    rc;
  147.     rc = DosSubUnsetMem(mempool);
  148.     if(rc){
  149.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  150.     }
  151.     rc = DosFreeMem(mempool);
  152.     if(rc){
  153.         WinAlarm(HWND_DESKTOP, WA_ERROR);
  154.     }
  155. }
  156.  
  157. #if defined(__BORLANDC__)
  158. int _beginthread(void (_USERENTRY *__start)(void *), unsigned __stksize, void *__arg)
  159. {
  160.     TID    tid;
  161.     if(DosCreateThread(&tid, (PFNTHREAD)__start, (ULONG)__arg, 2L, __stksize) != 0)
  162.         return -1;
  163.     return tid;
  164. }
  165.  
  166. void    _endthread(void)
  167. {
  168.     DosExit(EXIT_THREAD, 0);
  169. }
  170. #elif defined(__IBMC__)
  171. int    _Optlink beginthread( void(* _Optlink __thread)(void *),
  172.   void *stack, unsigned stack_size, void *arg_list);
  173. {
  174.     TID    tid;
  175.     if(DosCreateThread(&tid, (PFNTHREAD)__thread, (ULONG)arg_list, 2L, stack_size) != 0)
  176.         return -1;
  177.     return tid;
  178. }
  179.  
  180. void    _endthread()
  181. {
  182.     DosExit(EXIT_THREAD, 0);
  183. }
  184. #elif defined(__EMX__)
  185. int    _beginthread(void (*start)(void *arg), void *stack,
  186.   unsigned stack_size, void *arg_list)
  187. {
  188.     TID    tid;
  189.     if(DosCreateThread(&tid, (PFNTHREAD)start, (ULONG)arg_list, 2L, stack_size) != 0)
  190.         return -1;
  191.     return tid;
  192. }
  193.  
  194. void    _endthread()
  195. {
  196.     DosExit(EXIT_THREAD, 0);
  197. }
  198. #endif
  199.