ghc/interpreter/nHandle.c

   1
   2 /* This is a hack.  I totally deny writing it.  If this code breaks,
   3  * you get to keep all the pieces.  JRS, 23 feb 99.
   4  */
   5
   6 #include <stdio.h>
   7 #include <errno.h>
   8 #include <assert.h>
   9 #include <malloc.h>
  10 #include <stdlib.h>
  11 #include <ctype.h>
  12 #include <sys/times.h>
  13 #include <sys/resource.h>
  14 #include <sys/stat.h>
  15 #include <time.h>
  16 #include <unistd.h>
  17
  18 double nh_getCPUtime ( void )
  19 {
  20    double usertime;
  21    struct rusage usage;
  22    getrusage ( RUSAGE_SELF, &usage );
  23    usertime = (double)usage.ru_utime.tv_sec +
  24               (double)usage.ru_utime.tv_usec / 1000000.0;
  25    return usertime;
  26 }
  27
  28 double nh_getCPUprec ( void )
  29 {
  30    /* or perhaps CLOCKS_PER_SEC ? */
  31    return 1.0 / (double)(CLK_TCK);
  32 }
  33
  34 int nh_getPID ( void )
  35 {
  36    return (int) getpid();
  37 }
  38
  39 void nh_exitwith ( int code )
  40 {
  41    exit(code);
  42 }
  43
  44 int nh_system ( char* cmd )
  45 {
  46    return system ( cmd );
  47 }
  48
  49 int nh_iseof ( FILE* f )
  50 {
  51    int c;
  52    errno = 0;
  53    c = fgetc ( f );
  54    if (c == EOF) return 1;
  55    ungetc ( c, f );
  56    return 0;
  57 }
  58
  59 int nh_filesize ( FILE* f )
  60 {
  61    struct stat buf;
  62    errno = 0;
  63    fstat ( fileno(f), &buf );
  64    return buf.st_size;
  65 }
  66
  67 int nh_stdin ( void )
  68 {
  69    errno = 0;
  70    return (int)stdin;
  71 }
  72
  73 int nh_stdout ( void )
  74 {
  75    errno = 0;
  76    return (int)stdout;
  77 }
  78
  79 int nh_stderr ( void )
  80 {
  81    errno = 0;
  82    return (int)stderr;
  83 }
  84
  85 int nh_open ( char* fname, int wr )
  86 {
  87    FILE* f;
  88    errno = 0;
  89    f = fopen ( fname, (wr==0) ? "r":  ((wr==1) ? "w" : "a") );
  90    return (int)f;
  91 }
  92
  93 void nh_close ( FILE* f )
  94 {
  95    errno = 0;
  96    fflush ( f );
  97    fclose ( f );
  98 }
  99
 100 void nh_flush ( FILE* f )
 101 {
 102    errno = 0;
 103    fflush ( f );
 104 }
 105
 106 void nh_write ( FILE* f, int c )
 107 {
 108    errno = 0;
 109    fputc(c,f);
 110    if (f==stderr) { fflush(f); }
 111    if (f==stdout) { fflush(f); }
 112 }
 113
 114 int nh_read ( FILE* f )
 115 {
 116    errno = 0;
 117    return fgetc(f);
 118 }
 119
 120 int nh_errno ( void )
 121 {
 122    int t = errno;
 123    errno = 0;
 124    return t;
 125 }
 126
 127 int nh_malloc ( int n )
 128 {
 129    char* p = malloc(n);
 130    return (int)p;
 131 }
 132
 133 void nh_free ( int n )
 134 {
 135    free ( (char*)n );
 136 }
 137
 138 void nh_store ( int p, int ch )
 139 {
 140    *(char*)p = (char)ch;
 141 }
 142
 143 int nh_load ( int p )
 144 {
 145    return (int)(*(char*)p);
 146 }
 147
 148 int nh_getenv ( int p )
 149 {
 150    return (int)getenv ( (const char *)p );
 151 }
 152
 153 #if 0
 154 int prog_argc;
 155 char** prog_argv;
 156
 157 int nh_init_args ( int  argc, char *argv[] )
 158 {
 159   prog_argc = argc;
 160   prog_argv = argv;
 161 }
 162
 163 int nh_argc ( void )
 164 {
 165   return prog_argc;
 166 }
 167
 168 int nh_argvb ( int argno, int offset )
 169 {
 170   return prog_argv[argno][offset];
 171 }
 172 #endif