src/urasm-new.c

   1 // UrForth/C standalone
   2 // coded by Ketmar // Invisible Vector
   3 // GPLv3 ONLY
   4 //
   5 #ifndef _GNU_SOURCE
   6 # define _GNU_SOURCE
   7 #endif
   8
   9 #include <setjmp.h>
  10 #include <stdarg.h>
  11 #include <stddef.h>
  12 #include <stdint.h>
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <unistd.h>
  21
  22 #ifdef WIN32
  23 # include <windows.h>
  24 #else
  25 # include <signal.h>
  26 #endif
  27
  28 #include "liburforth/urforth.h"
  29
  30
  31 #define UR_FORCE_INLINE static inline __attribute__((always_inline))
  32 #define UR_INLINE static inline
  33
  34
  35 #define VERSION_HI  2
  36 #define VERSION_MID 0
  37 #define VERSION_LO  1
  38
  39
  40 #define MAYBE_UNUSED __attribute__((unused))
  41
  42
  43 // ////////////////////////////////////////////////////////////////////////// //
  44 __attribute((unused))
  45 static const char *ur_assert_failure (const char *cond, const char *fname, int fline,
  46                                       const char *func)
  47 {
  48   for (const char *t = fname; *t; ++t) {
  49     #ifdef WIN32
  50     if (*t == '/' || *t == '\\') fname = t+1;
  51     #else
  52     if (*t == '/') fname = t+1;
  53     #endif
  54   }
  55   fflush(stdout);
  56   fprintf(stderr, "\n%s:%d: Assertion in `%s` failed: %s\n", fname, fline, func, cond);
  57   fflush(stderr);
  58   abort();
  59 }
  60
  61 #define ur_assert(cond_)  do { if (__builtin_expect((!(cond_)), 0)) { ur_assert_failure(#cond_, __FILE__, __LINE__, __PRETTY_FUNCTION__); } } while (0)
  62
  63
  64 // ////////////////////////////////////////////////////////////////////////// //
  65 static char *ufoIncludeDir = NULL;
  66
  67
  68 //==========================================================================
  69 //
  70 //  initUFEInclideDir
  71 //
  72 //==========================================================================
  73 static void initUFEInclideDir (void) {
  74   const char *id = getenv("URASM_URFORTH_INCLUDE_DIR");
  75   if (id && id[0]) {
  76     ufoIncludeDir = strdup(id);
  77   } else {
  78     char myDir[4096];
  79     memset(myDir, 0, sizeof(myDir));
  80     #ifndef WIN32
  81     if (readlink("/proc/self/exe", myDir, sizeof(myDir)-1) < 0) {
  82       strcpy(myDir, ".");
  83     } else {
  84       char *p = (char *)strrchr(myDir, '/');
  85       if (!p) strcpy(myDir, "."); else *p = '\0';
  86     }
  87     #else
  88     GetModuleFileName(GetModuleHandle(NULL), myDir, sizeof(myDir)-1);
  89     char *p = strrchr(myDir, '\\');
  90     if (!p) strcpy(myDir, "."); else *p = '\0';
  91     #endif
  92     strcat(myDir, "/urflibs");
  93     ur_assert(ufoIncludeDir == NULL);
  94     ufoIncludeDir = strdup(myDir);
  95   }
  96   while (ufoIncludeDir[0] && ufoIncludeDir[strlen(ufoIncludeDir)-1] == '/') ufoIncludeDir[strlen(ufoIncludeDir)-1] = '\0';
  97   if (!ufoIncludeDir[0]) strcpy(ufoIncludeDir, ".");
  98 }
  99
 100
 101 static jmp_buf errJP;
 102 static int g_argc;
 103 static char **g_argv;
 104
 105
 106 //==========================================================================
 107 //
 108 //  ufoFatalError
 109 //
 110 //==========================================================================
 111 __attribute__((noreturn))
 112 void ufoFatalError (void) {
 113   longjmp(errJP, 666);
 114 }
 115
 116
 117 //==========================================================================
 118 //
 119 //  strprintfVA
 120 //
 121 //==========================================================================
 122 static char *strprintfVA (const char *fmt, va_list vaorig) {
 123   char *buf = NULL;
 124   int olen, len = 128;
 125   //
 126   buf = malloc(len);
 127   if (buf == NULL) { fprintf(stderr, "\nFATAL: out of memory!\n"); abort(); }
 128   for (;;) {
 129     char *nb;
 130     va_list va;
 131     //
 132     va_copy(va, vaorig);
 133     olen = vsnprintf(buf, len, fmt, va);
 134     va_end(va);
 135     if (olen >= 0 && olen < len) return buf;
 136     if (olen < 0) olen = len*2-1;
 137     nb = realloc(buf, olen+1);
 138     if (nb == NULL) { fprintf(stderr, "\nFATAL: out of memory!\n"); abort(); }
 139     buf = nb;
 140     len = olen+1;
 141   }
 142 }
 143
 144
 145 //==========================================================================
 146 //
 147 //  strprintf
 148 //
 149 //==========================================================================
 150 static __attribute__((format(printf,1,2))) char *strprintf (const char *fmt, ...) {
 151   char *buf = NULL;
 152   va_list va;
 153   va_start(va, fmt);
 154   buf = strprintfVA(fmt, va);
 155   va_end(va);
 156   return buf;
 157 }
 158
 159
 160 //==========================================================================
 161 //
 162 //  findMain
 163 //
 164 //  return NULL or new path
 165 //
 166 //==========================================================================
 167 static char *findMain (const char *path, const char **mainList) {
 168   struct stat st;
 169   while (*mainList != NULL) {
 170     char *newpath = strprintf("%s/%s", path, *mainList);
 171     if (stat(newpath, &st) == 0) {
 172       if (!S_ISDIR(st.st_mode)) {
 173         return newpath;
 174       }
 175     }
 176     free(newpath);
 177     mainList += 1u;
 178   }
 179   return NULL;
 180 }
 181
 182
 183 static const char *sysMains[] = {
 184   "00-main-loader.f",
 185   NULL
 186 };
 187
 188
 189 static const char *userMains[] = {
 190   "zzmain.f",
 191   "main.f",
 192   "00-main-loader.f",
 193   "zzmain.zas",
 194   "main.zas",
 195   NULL,
 196 };
 197
 198
 199 //==========================================================================
 200 //
 201 //  createIncludeName
 202 //
 203 //  return malloced string
 204 //
 205 //==========================================================================
 206 static char *createIncludeName (const char *fname, int assystem, const char *lastIncPathUFO) {
 207   struct stat st;
 208   char *res;
 209   char *newpath;
 210
 211   if (!fname || !fname[0]) return NULL;
 212
 213   if (fname[0] != '/') {
 214     const char *incdir = lastIncPathUFO;
 215     if (assystem && (!incdir || !incdir[0])) incdir = ufoIncludeDir;
 216     if (incdir == NULL || incdir[0] == 0) incdir = ".";
 217     res = strprintf("%s/%s", incdir, fname);
 218   } else {
 219     res = strprintf("%s", fname);
 220   }
 221
 222   if (stat(res, &st) == 0) {
 223     if (S_ISDIR(st.st_mode)) {
 224       newpath = findMain(res, (assystem ? sysMains : userMains));
 225       if (newpath != NULL) {
 226         free(res);
 227         res = newpath;
 228       }
 229     }
 230   } else if (assystem && fname[0] != '/' && ufoIncludeDir != NULL && ufoIncludeDir[0] != 0) {
 231     // if it is a system include, try from system root
 232     newpath = strprintf("%s/%s", ufoIncludeDir, fname);
 233     if (stat(newpath, &st) == 0) {
 234       free(res);
 235       res = newpath;
 236       if (S_ISDIR(st.st_mode)) {
 237         newpath = findMain(res, sysMains);
 238         if (newpath != NULL) {
 239           free(res);
 240           res = newpath;
 241         }
 242       }
 243     } else {
 244       free(newpath);
 245     }
 246   }
 247
 248   //fprintf(stderr, "inc: fname=<%s>; sys=%d; def=<%s>; res=<%s>\n", fname, assystem, defaultmain, res);
 249   return res;
 250 }
 251
 252
 253 //==========================================================================
 254 //
 255 //  ufoCreateIncludeName
 256 //
 257 //==========================================================================
 258 char *ufoCreateIncludeName (const char *fname, int assystem, const char *lastIncPath) {
 259   #if 0
 260   fprintf(stderr, "ICIN: fname=<%s>; lastinc=<%s>; assystem=%d\n",
 261           fname, lastIncPath, assystem);
 262   #endif
 263   if (lastIncPath == NULL && assystem) lastIncPath = ufoIncludeDir;
 264   return createIncludeName(fname, assystem, lastIncPath);
 265 }
 266
 267
 268 #ifndef WIN32
 269 //==========================================================================
 270 //
 271 //  sigCtrlC
 272 //
 273 //==========================================================================
 274 static void sigCtrlC (int sig) {
 275   ufoSetUserAbort();
 276 }
 277 #endif
 278
 279
 280 //==========================================================================
 281 //
 282 //  ufcWord_N_BYE
 283 //
 284 //==========================================================================
 285 static void ufcWord_N_BYE (uint32_t pfa) {
 286   uint32_t ec = ufoPopData();
 287   exit((int)ec);
 288 }
 289
 290
 291 //==========================================================================
 292 //
 293 //  ufcWord_BYE
 294 //
 295 //==========================================================================
 296 static void ufcWord_BYE (uint32_t pfa) {
 297   exit(0);
 298 }
 299
 300
 301 //==========================================================================
 302 //
 303 //  ufcWord_ARGC
 304 //
 305 //==========================================================================
 306 static void ufcWord_ARGC (uint32_t pfa) {
 307   int rest = g_argc;
 308   if (rest <= 0) ufoPushData(0); else ufoPushData((uint32_t)rest);
 309 }
 310
 311
 312 //==========================================================================
 313 //
 314 //  ufcWord_ARGV
 315 //
 316 //  ARGV ( idx -- addr count )
 317 //  copy CLI arg to PAD+4, and set counter to PAD.
 318 //  0 is first arg, not program name!
 319 //
 320 //==========================================================================
 321 static void ufcWord_ARGV (uint32_t pfa) {
 322   uint32_t idx = ufoPopData();
 323   int rest = g_argc;
 324   const uint32_t addr = ufoGetPAD() + 4u;
 325   uint32_t count = 0;
 326   if (rest > 0 || idx < rest) {
 327     const unsigned char *arg = (const unsigned char *)(g_argv[(int)idx]);
 328     while (*arg) {
 329       ufoPokeByte(addr + count, *arg);
 330       count += 1u; arg += 1u;
 331     }
 332   }
 333   ufoPokeCell(addr - 4u, count);
 334   ufoPushData(addr);
 335   ufoPushData(count);
 336 }
 337
 338
 339 //==========================================================================
 340 //
 341 //  initUrForth
 342 //
 343 //==========================================================================
 344 static void initUrForth (void) {
 345   #ifdef WIN32
 346   ufoCondDefine("SHITDOZE");
 347   #else
 348   ufoCondDefine("NIX");
 349   #endif
 350   ufoCondDefine("URASM-NEW");
 351   if (ufoSStepAllowed()) ufoCondDefine("DEBUGGER");
 352   ufoRegisterWord("N-BYE", &ufcWord_N_BYE, UFW_FLAG_PROTECTED);
 353   ufoRegisterWord("BYE", &ufcWord_BYE, UFW_FLAG_PROTECTED);
 354   ufoRegisterWord("ARGC", &ufcWord_ARGC, UFW_FLAG_PROTECTED);
 355   ufoRegisterWord("ARGV", &ufcWord_ARGV, UFW_FLAG_PROTECTED);
 356 }
 357
 358
 359 //==========================================================================
 360 //
 361 //  urcShutdown
 362 //
 363 //==========================================================================
 364 static void urcShutdown (void) {
 365   ufoDeinit();
 366   if (ufoIncludeDir) free(ufoIncludeDir);
 367 }
 368
 369
 370 //==========================================================================
 371 //
 372 //  main
 373 //
 374 //==========================================================================
 375 int main (int argc, char *argv[]) {
 376   int res = 0;
 377   int dorepl = 0;
 378   int allowDebug = 0;
 379
 380   ufoSetUserPostInit(&initUrForth);
 381
 382   initUFEInclideDir();
 383
 384   printf("UrForth/C & UrAsm v%d.%d.%d, compile date: %s %s\n",
 385          VERSION_HI, VERSION_MID, VERSION_LO, __DATE__, __TIME__);
 386
 387   g_argc = argc - 1;
 388   g_argv = argv + 1;
 389
 390   if (g_argc > 0 && strcmp(g_argv[0], "--repl") == 0) {
 391     dorepl = 1;
 392     g_argc -= 1; g_argv += 1;
 393   }
 394
 395   if (g_argc > 0 && strcmp(g_argv[0], "--debug") == 0) {
 396     if (!ufoIsMTaskEnabled()) {
 397       fflush(NULL); fprintf(stderr, "FATAL: cannot enable debugger, no multitask support!\n");
 398       exit(1);
 399     }
 400     allowDebug = 1;
 401     g_argc -= 1; g_argv += 1;
 402   }
 403
 404   #ifndef WIN32
 405   signal(SIGINT, &sigCtrlC);
 406   #endif
 407
 408   atexit(&urcShutdown);
 409
 410   if (setjmp(errJP) == 0) {
 411     ufoInit();
 412   } else {
 413     fprintf(stderr, "FATAL: INITILIZATION FAILED!\n");
 414     exit(1);
 415   }
 416
 417   ufoSetSStepAllowed(allowDebug);
 418
 419   if (dorepl) {
 420     for (;;) {
 421       if (setjmp(errJP) == 0) {
 422         uint32_t cfa;
 423         cfa = ufoFindWordInVocabulary("UFO-RUN-REPL", ufoGetForthVocId());
 424         if (cfa == 0) {
 425           fprintf(stderr, "FATAL: REPL is not available.\n");
 426           exit(1);
 427         } else {
 428           ufoRunWord(cfa);
 429         }
 430       }
 431     }
 432   } else {
 433     uint32_t cfa = ufoFindWordInVocabulary("RUN-URASM", ufoGetForthVocId());
 434     if (cfa == 0) {
 435       fprintf(stderr, "FATAL: cannot find main URASM loop word.\n");
 436       exit(1);
 437     }
 438     if (setjmp(errJP) == 0) {
 439       ufoRunWord(cfa);
 440     } else {
 441       res = 1;
 442     }
 443   }
 444
 445   return (res ? 1 : 0);
 446 }