libs/iovm/source/IoSystem.c

   1 /*#io
   2 System ioDoc(
   3         docCopyright("Steve Dekorte", 2002)
   4         docLicense("BSD revised")
   5         docObject("System")
   6         docDescription("Contains methods related to the IoVM.")
   7         docCategory("Core")
   8 */
   9
  10 #include "IoSystem.h"
  11 #include "IoNumber.h"
  12 #include "IoMessage_parser.h"
  13
  14 #if defined(linux)
  15 #include <unistd.h>
  16 #endif
  17
  18 #if defined(unix) || defined(__APPLE__) || defined(__NetBSD__)
  19 #include <sys/utsname.h>
  20 #ifdef __NetBSD__
  21 # include <sys/param.h>
  22 #endif
  23 #ifndef __CYGWIN__
  24 # include <sys/sysctl.h>
  25 #endif
  26 #endif
  27
  28 #ifdef WIN32
  29 #include <windows.h>
  30
  31 static void setenv(const char *varName, const char* value, int force)
  32 {
  33         const char *safeValue;
  34         char *buf;
  35
  36         if (!varName)
  37         {
  38                 return;
  39         }
  40
  41         if (!value)
  42         {
  43                 safeValue = "";
  44         }
  45         else
  46         {
  47                 safeValue = value;
  48         }
  49
  50         // buffer for var and value plus '=' and the \0
  51         buf = (char*)io_calloc(1, strlen(varName) + strlen(safeValue) + 2);
  52
  53         if (!buf)
  54         {
  55                 return;
  56         }
  57
  58         strcpy(buf, varName);
  59         strcat(buf, "=");
  60         strcat(buf, safeValue);
  61
  62         _putenv(buf);
  63         io_free(buf);
  64 }
  65
  66 //#define setenv(k, v, o) SetEnvironmentVariable((k), (v))
  67 #endif
  68
  69 #if defined(__CYGWIN__) || defined(_WIN32)
  70 #include <windows.h>
  71 #endif
  72
  73 IoObject *IoSystem_proto(void *state)
  74 {
  75         IoMethodTable methodTable[] = {
  76 #if defined(_WIN32)
  77         {"shellExecute", IoObject_shellExecute},
  78 #endif
  79         {"errorNumber", IoObject_errorNumberDescription},
  80         {"exit", IoObject_exit},
  81         {"getEnvironmentVariable", IoObject_getEnvironmentVariable},
  82         {"setEnvironmentVariable", IoObject_setEnvironmentVariable},
  83         {"system", IoObject_system},
  84         //{"memorySizeOfState", IoObject_memorySizeOfState},
  85         //{"compactState", IoObject_compactState},
  86         {"platform", IoObject_platform},
  87         {"platformVersion", IoObject_platformVersion},
  88         {"sleep", IoObject_sleep},
  89         {"activeCpus", IoObject_activeCpus},
  90         {"recycledObjectCount", IoObject_recycledObjectCount},
  91         {"maxRecycledObjects", IoObject_maxRecycledObjects},
  92         {"setMaxRecycledObjects", IoObject_setMaxRecycledObjects},
  93         {"symbols", IoObject_symbols},
  94         {"setLobby", IoObject_setLobby},
  95         {NULL, NULL},
  96         };
  97
  98         IoObject *self = IoObject_new(state);
  99         IoObject_addMethodTable_(self, methodTable);
 100
 101         /*#io
 102                 docSlot("version", "Returns the Io version number.")
 103         */
 104         IoObject_setSlot_to_(self, IOSYMBOL("version"), IONUMBER(IO_VERSION_NUMBER));
 105
 106         //IoObject_setSlot_to_(self, IOSYMBOL("distribution"), IOSYMBOL("Io"));
 107         IoObject_setSlot_to_(self, IOSYMBOL("type"), IOSYMBOL("System"));
 108
 109         #ifndef INSTALL_PREFIX
 110         #define INSTALL_PREFIX "/usr/local"
 111         #endif
 112
 113
 114         /*#io
 115                 docSlot("installPrefix", "Returns the root path where io was install. The default is /usr/local.")
 116         */
 117         IoObject_setSlot_to_(self, IOSYMBOL("installPrefix"), IOSYMBOL(INSTALL_PREFIX));
 118
 119         return self;
 120 }
 121
 122 /*#io
 123         docSlot("args", "Returns the list of command line argument strings the program was run with.")
 124 */
 125
 126 /*
 127 IoObject *IoObject_errorNumber(IoObject *self, IoObject *locals, IoMessage *m)
 128 {
 129         return IONUMBER(errno);
 130 }
 131 */
 132
 133 #include <stdio.h>
 134 #include <errno.h>
 135
 136 #if defined(_WIN32)
 137 #include <shellapi.h>
 138 IoObject *IoObject_shellExecute(IoObject *self, IoObject *locals, IoMessage *m)
 139 {
 140         return IONUMBER((int) ShellExecute(NULL, "open", CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0)), NULL, NULL, SW_SHOWNORMAL));
 141 }
 142 #endif
 143
 144 IoObject *IoObject_errorNumberDescription(IoObject *self, IoObject *locals, IoMessage *m)
 145 {
 146         /*#io
 147         docSlot("errorNumber", "Returns the C errno string.")
 148         */
 149         return errno ? IOSYMBOL(strerror(errno)) : IONIL(self);
 150 }
 151
 152 IoObject *IoObject_exit(IoObject *self, IoObject *locals, IoMessage *m)
 153 {
 154         /*#io
 155         docSlot("exit(optionalReturnCodeNumber)",
 156                         "Shutdown the IoState (io_free all objects) and return
 157 control to the calling program (if any). ")
 158         */
 159
 160         int returnCode = 0;
 161
 162         if (IoMessage_argCount(m))
 163         {
 164                 returnCode = IoMessage_locals_intArgAt_(m, locals, 0);
 165         }
 166
 167         IoState_exit(IOSTATE, returnCode);
 168         return self;
 169 }
 170
 171 IoObject *IoObject_getEnvironmentVariable(IoObject *self, IoObject *locals, IoMessage *m)
 172 {
 173         /*#io
 174         docSlot("getEnvironmentVariable(nameString)",
 175                    "Returns a string with the value of the environment variable whose name is specified by nameString.")
 176         */
 177
 178         IoSymbol *key = IoMessage_locals_symbolArgAt_(m, locals, 0);
 179         char *s = getenv(CSTRING(key));
 180
 181         if (!s)
 182         {
 183                 return ((IoState *)IOSTATE)->ioNil;
 184         }
 185
 186         return IoState_symbolWithCString_(IOSTATE, s);
 187 }
 188
 189 IoObject *IoObject_system(IoObject *self, IoObject *locals, IoMessage *m)
 190 {
 191         /*#io
 192         docSlot("system(aString)",
 193                         "Makes a system call and returns a Number for the return value.")
 194         */
 195
 196         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 197         int result = system(CSTRING(s))/ 256;
 198         //printf("system result = %i\n", result);
 199         return IONUMBER(result);
 200 }
 201
 202 IoObject *IoObject_memorySizeOfState(IoObject *self, IoObject *locals, IoMessage *m)
 203 {
 204         /*
 205         docSlot("memorySizeOfState",
 206                         "Returns the number of bytes in the IoState
 207         (this may not include memory allocated by C libraries).")
 208         */
 209
 210         return IONUMBER(0);
 211         //return IONUMBER(IoState_memorySize(IOSTATE));
 212 }
 213
 214 IoObject *IoObject_compactState(IoObject *self, IoObject *locals, IoMessage *m)
 215 {
 216         /*
 217         docSlot("compactState",
 218                         "Attempt to compact the memory of the IoState if possible.")
 219         */
 220
 221         //IoState_compact(IOSTATE);
 222         return self;
 223 }
 224
 225 IoObject *IoObject_setEnvironmentVariable(IoObject *self, IoObject *locals, IoMessage *m)
 226 {
 227         /*#io
 228         docSlot("setEnvironmentVariable(keyString, valueString)", "Sets the environment variable keyString to the value valueString.")
 229         */
 230
 231         // setenv() takes different args in different implementations
 232         IoSymbol *key = IoMessage_locals_symbolArgAt_(m, locals, 0);
 233         IoSymbol *value = IoMessage_locals_symbolArgAt_(m, locals, 1);
 234         setenv(CSTRING(key), CSTRING(value), 1);
 235         return self;
 236 }
 237
 238 IoObject *IoObject_platform(IoObject *self, IoObject *locals, IoMessage *m)
 239 {
 240         /*#io
 241         docSlot("platform", "Returns a string description of the platform.")
 242         */
 243
 244         char *platform = "Unknown";
 245
 246 #if defined(__CYGWIN__)
 247
 248         platform = "cygwin";
 249
 250 #elif defined(__MINGW32__)
 251
 252         platform = "mingw";
 253
 254 #elif defined(_WIN32)
 255
 256         OSVERSIONINFO os;
 257
 258         os.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
 259         GetVersionEx(&os);
 260
 261         switch(os.dwPlatformId)
 262         {
 263                 case VER_PLATFORM_WIN32_WINDOWS:
 264                         switch(os.dwMinorVersion)
 265                         {
 266                                 case 0:
 267                                         platform = "Windows 95";
 268                                         break;
 269                                 case 10:
 270                                         platform = "Windows 98";
 271                                         break;
 272                                 case 90:
 273                                         platform = "Windows ME";
 274                                         break;
 275                                 default:
 276                                         platform = "Windows 9X";
 277                                         break;
 278                         }
 279                         break;
 280
 281                 case VER_PLATFORM_WIN32_NT:
 282                         if (os.dwMajorVersion == 3 || os.dwMajorVersion == 4)
 283                         {
 284                                 platform = "Windows NT";
 285                         }
 286                         else if (os.dwMajorVersion == 5)
 287                         {
 288                                 switch(os.dwMinorVersion)
 289                                 {
 290                                         case 0:
 291                                                 platform = "Windows 2000";
 292                                                 break;
 293                                         case 1:
 294                                                 platform = "Windows XP";
 295                                                 break;
 296                                         default:
 297                                                 platform = "Windows";
 298                                                 break;
 299                                 }
 300                         }
 301                         else
 302                         {
 303                                 platform = "Windows";
 304                         }
 305                         break;
 306
 307                 default: platform = "Windows";
 308         }
 309
 310 #elif defined(unix) || defined(__APPLE__) || defined(__NetBSD__)
 311         /* Why Apple and NetBSD don't define 'unix' I'll never know. */
 312         struct utsname os;
 313         int ret = uname(&os);
 314
 315         if (ret == 0)
 316         {
 317                 platform = os.sysname;
 318         }
 319 #endif
 320
 321         return IoState_symbolWithCString_(IOSTATE, platform);
 322 }
 323
 324 IoObject *IoObject_platformVersion(IoObject *self, IoObject *locals, IoMessage *m)
 325 {
 326         char platformVersion[256];
 327
 328         /*#io
 329         docSlot("platformVersion", "Returns the version id of the OS.")
 330         */
 331
 332 #if defined(_WIN32)
 333
 334         OSVERSIONINFO os;
 335
 336         os.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
 337         GetVersionEx(&os);
 338
 339         snprintf(platformVersion, sizeof(platformVersion) - 1, "%d.%d",
 340                 os.dwMajorVersion, os.dwMinorVersion);
 341
 342 #elif defined(unix) || defined(__APPLE__) || defined(__NetBSD__)
 343         /* Why Apple and NetBSD don't define 'unix' I'll never know. */
 344         struct utsname os;
 345         int ret = uname(&os);
 346
 347         if (ret == 0)
 348         {
 349                 snprintf(platformVersion, sizeof(platformVersion) - 1, os.release);
 350         }
 351 #endif
 352
 353         return IoState_symbolWithCString_(IOSTATE, platformVersion);
 354 }
 355
 356 IoObject *IoObject_activeCpus(IoObject *self, IoObject *locals, IoMessage *m)
 357 {
 358         /*#io
 359         docSlot("activeCpus", "Returns the number of active CPUs.")
 360         */
 361         int cpus = 1;
 362 #if defined(CTL_HW)
 363         int mib[2];
 364         size_t len = sizeof(cpus);
 365         mib[0] = CTL_HW;
 366 #if defined(HW_AVAILCPU)
 367         mib[1] = HW_AVAILCPU;
 368 #elif defined(HW_NCPU)
 369         mib[1] = HW_NCPU;
 370 #else
 371 #error
 372 #endif
 373         sysctl(mib, 2, &cpus, &len, NULL, 0);
 374 #elif defined(_SC_NPROCESSORS_ONLN)
 375         cpus = sysconf(_SC_NPROCESSORS_ONLN);
 376 #elif defined(_SC_NPROC_ONLN)
 377         cpus = sysconf(_SC_NPROC_ONLN);
 378 #elif defined(WIN32)
 379         SYSTEM_INFO si;
 380         GetSystemInfo(&si);
 381         cpus = si.dwNumberOfProcessors;
 382 #else
 383 #error
 384 #endif
 385         return IONUMBER(cpus);
 386 }
 387
 388 #include "PortableUsleep.h"
 389
 390 IoObject *IoObject_sleep(IoObject *self, IoObject *locals, IoMessage *m)
 391 {
 392         /*#io
 393         docSlot("sleep(secondsNumber)", "Performs a *blocking* sleep call for specified number of seconds.")
 394         */
 395
 396         double seconds = IoMessage_locals_doubleArgAt_(m, locals, 0);
 397         unsigned int microseconds = (seconds * 1000000);
 398         usleep(microseconds);
 399         return self;
 400 }
 401
 402 IoObject *IoObject_maxRecycledObjects(IoObject *self, IoObject *locals, IoMessage *m)
 403 {
 404         /*#io
 405         docSlot("maxRecycledObjects", "Returns the max number of recycled objects used.")
 406         */
 407
 408         return IONUMBER(IOSTATE->maxRecycledObjects);
 409 }
 410
 411 IoObject *IoObject_setMaxRecycledObjects(IoObject *self, IoObject *locals, IoMessage *m)
 412 {
 413         /*#io
 414         docSlot("setMaxRecycledObjects(aNumber)", "Sets the max number of recycled objects used.")
 415         */
 416
 417         size_t max = IoMessage_locals_sizetArgAt_(m, locals, 0);
 418         IOSTATE->maxRecycledObjects = max;
 419         return self;
 420 }
 421
 422 IoObject *IoObject_recycledObjectCount(IoObject *self, IoObject *locals, IoMessage *m)
 423 {
 424         /*#io
 425         docSlot("recycledObjectCount", "Returns the current number of objects being held for recycling.")
 426         */
 427
 428         return IONUMBER(List_size(IOSTATE->recycledObjects));
 429 }
 430
 431 #include "IoList.h"
 432
 433 IoObject *IoObject_symbols(IoObject *self, IoObject *locals, IoMessage *m)
 434 {
 435         /*#io
 436         docSlot("symbols", "Returns a List containing all Symbols currently in the system.")
 437         */
 438         IoList *list = IoList_new(IOSTATE);
 439         SHASH_FOREACH(IOSTATE->symbols, i, v, IoList_rawAppend_(list, v));
 440         return list;
 441 }
 442
 443 IoObject *IoObject_setLobby(IoObject *self, IoObject *locals, IoMessage *m)
 444 {
 445         /*#io
 446         docSlot("setLobby", "Sets the root object of the garbage collector.")
 447         */
 448
 449         IoObject *v = IoMessage_locals_valueArgAt_(m, locals, 0);
 450         IoState_setLobby_(IOSTATE, v);
 451         return self;
 452 }
 453
 454 /*#io
 455 docSlot("version", "Returns a version number for Io.")
 456 */
 457
 458 /*#io
 459 docSlot("distribution", "Returns the Io distribution name as a string.")
 460 */
 461
 462 // save ----------------------
 463
 464 /*
 465 IoObject *IoObject_setStateFile(IoObject *self, IoObject *locals, IoMessage *m)
 466 {
 467         IoSeq *fileName = IoMessage_locals_seqArgAt_(m, locals, 0);
 468 }
 469
 470 IoObject *IoObject_saveState(IoObject *self, IoObject *locals, IoMessage *m)
 471 {
 472         IoState_saveState(IOSTATE);
 473 }
 474
 475 int IoState_saveState(IoState *self)
 476 {
 477         Collector *collector = IOSTATE->collector;
 478         self->store->open();
 479         Collector_collect(collect);
 480         COLLECTOR_FOREACH(collector, v, IoState_storeObject_(state, v));
 481         self->store->close();
 482         return 1;
 483 }
 484
 485 int IoState_syncState(IoState *self)
 486 {
 487         Collector *collector = IOSTATE->collector;
 488         self->store->open();
 489         Collector_collect(collect);
 490         COLLECTOR_FOREACH(collector, v,
 491                 if (!IoObject_persistentId(v) || IoObject_isDirty(v))
 492                 IoState_storeObject_(state, v)
 493         );
 494         self->store->close();
 495         return 1;
 496 }
 497
 498 PID_TYPE IoObject_pid(IoObject *self)
 499 {
 500         if (!IoObject_persistentId(self))
 501         {
 502                 IoObject_persistentId_(self, IoState_newPid(IOSTATE));
 503         }
 504
 505         return IoObject_persistentId(self);
 506 }
 507
 508 PID_TYPE IoState_newPid(IoState *self)
 509 {
 510         return self->store->newPid();
 511 }
 512
 513 int IoState_storeObject_(IoState *self, IoObject *v)
 514 {
 515         // IoObject_pid will request new pid from the state if needed
 516
 517         UArray *u = IoObject_asStorable(v);
 518         self->store->atPut(state, IoObject_pid(v), UArray_bytes(u), UArray_sizeInBytes(u));
 519         return 1;
 520 }
 521
 522 // load ----------------------
 523
 524 int IoState_loadState(IoState *self, IoObject *v)
 525 {
 526         IoObject *lobby;
 527         self->store->open();
 528         Datum *d = self->store->at(state, 1); // pid of lobby
 529         lobby = IoObject_fromDatum(self, d)
 530         IoState_setLobby_(self, PObject_newWithPid(state, 1));
 531         return 1;
 532 }
 533 */