Changeset 3477 for trunk/src

Timestamp:

Sep 17, 2020, 11:52:16 PM (5 years ago)

Author:

bird

Message:

kash: Use kHlpAssert instead of assert.h (debugger stops on the assertion rather than at exit process code).

Location:

trunk/src/kash

Files:

• Makefile.kmk (modified) (1 diff)
• error.c (modified) (1 diff)
• eval.c (modified) (3 diffs)
• exec.c (modified) (2 diffs)
• expand.c (modified) (1 diff)
• main.c (modified) (1 diff)
• memalloc.c (modified) (14 diffs)
• memalloc.h (modified) (3 diffs)
• options.c (modified) (6 diffs)
• parser.c (modified) (1 diff)
• redir.c (modified) (3 diffs)
• setmode.c (modified) (2 diffs)
• shfile.c (modified) (22 diffs)
• shfork-win.c (modified) (3 diffs)
• shheap.c (modified) (2 diffs)
• shinstance.c (modified) (20 diffs)
• show.c (modified) (2 diffs)
• shthread.c (modified) (3 diffs)
• shtypes.h (modified) (1 diff)
• var.c (modified) (3 diffs)

trunk/src/kash/Makefile.kmk

@@ -42 +42 @@
 kash_DEFS += KASH_SEPARATE_PARSER_ALLOCATOR KASH_ASYNC_CLOSE_HANDLE
 endif
-kash_DEFS.debug = DEBUG=2
+kash_DEFS.debug = DEBUG=2 K_STRICT
 kash_DEFS.haiku = BSD
 kash_DEFS.linux = BSD

trunk/src/kash/error.c

@@ -371 +371 @@
         return psh->errmsg_buf;
 }
+
+
+#ifdef K_STRICT
+
+KHLP_DECL(void) kHlpAssertMsg1(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction)
+{
+        shinstance *psh = shthread_get_shell();
+
+        TRACE((psh,  "Assertion failed in %s --- %s --- %s(%u)\n", pszFunction, pszExpr, pszFile, iLine));
+        dprintf(psh, "Assertion failed in %s --- %s --- %s(%u)\n", pszFunction, pszExpr, pszFile, iLine);
+}
+
+KHLP_DECL(void) kHlpAssertMsg2(const char *pszFormat, ...)
+{
+        shinstance *psh = shthread_get_shell();
+        va_list va;
+        va_start(va, pszFormat);
+        doformat(psh->out2, pszFormat, va);
+        va_end(va);
+}
+
+#endif /* K_STRICT */

trunk/src/kash/eval.c

@@ -41 +41 @@
 #endif
 
-#include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -528 +527 @@
                         break;
                 default:
-                        assert(redir->type == NHERE || redir->type == NXHERE);
+                        kHlpAssert(redir->type == NHERE || redir->type == NXHERE);
                         expfnames->names[i] = NULL;
                         break;
                 }
         }
-        assert(i == expfnames->count);
+        kHlpAssert(i == expfnames->count);
 
         /* Do the linking at the end, as nesting happens when we expand backtick arguments. */
@@ -545 +544 @@
 {
         redirexpfnames *expfnames = psh->expfnames;
-        assert(expfnames == NULL ? depth == 0 : expfnames->depth == depth || expfnames->depth + 1 == depth);
+        kHlpAssert(expfnames == NULL ? depth == 0 : expfnames->depth == depth || expfnames->depth + 1 == depth);
         while (expfnames && expfnames->depth >= depth)
             expfnames = psh->expfnames = expfnames->prev;

trunk/src/kash/exec.c

@@ -46 +46 @@
 #include <stdlib.h>
 #include <stddef.h>
-#include <assert.h>
 
 /*
@@ -307 +306 @@
                 int suffix;
                 int isreg = stat_pc_exec_exts(psh, cmd, 0, &suffix);
-                assert(isreg > 0);
+                kHlpAssert(isreg > 0);
         }
 #endif

trunk/src/kash/expand.c

@@ -45 +45 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include <assert.h>
 
 /*

trunk/src/kash/main.c

@@ -45 +45 @@
 #endif
 
-#include <assert.h>
 #include <errno.h>
 #include <stdio.h>

trunk/src/kash/memalloc.c

@@ -43 +43 @@
 #include <stdlib.h>
 #include <stddef.h>
-#include <assert.h>
 
 #include "shell.h"
@@ -332 +331 @@
         size_t nbytes = (size_t)(end - pstart);
 
-        assert((uintptr_t)end >= (uintptr_t)pstart);
-        /*assert(end[-1] == '\0'); - not if it's followed by ungrabstrackstr(), sigh. */
-        assert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
-        assert(stackblocksize(psh) - psh->sstrnleft >= nbytes);
+        kHlpAssert((uintptr_t)end >= (uintptr_t)pstart);
+        /*kHlpAssert(end[-1] == '\0'); - not if it's followed by ungrabstrackstr(), sigh. */
+        kHlpAssert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
+        kHlpAssert(stackblocksize(psh) - psh->sstrnleft >= nbytes);
 
         nbytes = SHELL_ALIGN(nbytes);
         psh->stacknxt += nbytes;
         psh->stacknleft -= (int)nbytes;
-        assert(psh->stacknleft >= 0);
+        kHlpAssert(psh->stacknleft >= 0);
 
         return pstart;
@@ -348 +347 @@
 ungrabstackstr(shinstance *psh, char *s, char *p)
 {
-        assert((size_t)(psh->stacknxt - p) <= SHELL_SIZE);
-        assert((uintptr_t)s >= (uintptr_t)&psh->stackp->space[0]);
-        assert((uintptr_t)p >= (uintptr_t)s);
+        kHlpAssert((size_t)(psh->stacknxt - p) <= SHELL_SIZE);
+        kHlpAssert((uintptr_t)s >= (uintptr_t)&psh->stackp->space[0]);
+        kHlpAssert((uintptr_t)p >= (uintptr_t)s);
 
         psh->stacknleft += (int)(psh->stacknxt - s);
@@ -374 +373 @@
                         while ((top = pst->top) != &pst->first) {
                                 pst->top = top->prev;
-                                assert(pst->top);
+                                kHlpAssert(pst->top);
                                 top->prev = NULL;
                                 sh_free(psh, top);
@@ -393 +392 @@
 void pstackpop(shinstance *psh, unsigned target)
 {
-        assert(target <= psh->pstacksize);
+        kHlpAssert(target <= psh->pstacksize);
         while (target < psh->pstacksize) {
                 unsigned idx = --psh->pstacksize;
@@ -414 +413 @@
                         if (psh->curpstack == psh->pstack[i])
                                 break;
-                assert(i < psh->pstacksize);
+                kHlpAssert(i < psh->pstacksize);
         }
 # endif
@@ -423 +422 @@
 {
         unsigned refs = sh_atomic_inc(&pst->refs);
-        assert(refs > 1);
-        assert(refs < 256 /* bogus, but useful */);
+        kHlpAssert(refs > 1);
+        kHlpAssert(refs < 256 /* bogus, but useful */);
         return refs;
 }
@@ -533 +532 @@
         size_t blocksize;
 
-        assert(pst->avail < nbytes); /* only called when we need more space */
-        assert(tocopy <= pst->avail);
+        kHlpAssert(pst->avail < nbytes); /* only called when we need more space */
+        kHlpAssert(tocopy <= pst->avail);
 
         /* Double the size used thus far and add some fudge and alignment.  Make
@@ -562 +561 @@
                 char const * const copysrc = pst->nextbyte;
                 pstallocnewblock(psh, pst, nbytes);
-                assert(pst->avail >= nbytes);
-                assert(pst->avail >= tocopy);
+                kHlpAssert(pst->avail >= nbytes);
+                kHlpAssert(pst->avail >= tocopy);
                 memcpy(pst->nextbyte, copysrc, tocopy);
         }
@@ -646 +645 @@
         size_t const len = end - pst->nextbyte;
 
-        assert(pst->avail - pst->strleft == len);
+        kHlpAssert(pst->avail - pst->strleft == len);
         TRACE2((psh, "pstmakestrspace: len=%u minbytes=%u (=> %u)\n", len, minbytes, len + minbytes));
 
@@ -657 +656 @@
         size_t const len = end - stackblock(psh);
 
-        assert(stackblocksize(psh) - psh->sstrnleft == len);
+        kHlpAssert(stackblocksize(psh) - psh->sstrnleft == len);
         TRACE2((psh, "pstmakestrspace: len=%u minbytes=%u (=> %u)\n", len, minbytes, len + minbytes));
 
@@ -676 +675 @@
         pst->strleft++;         /* PSTPUTC() already incremented it. */
         end = pstmakestrspace(psh, 1, end);
-        assert(pst->strleft > 0);
+        kHlpAssert(pst->strleft > 0);
         pst->strleft--;
 #else
         psh->sstrnleft++;       /* PSTPUTC() already incremented it. */
         end = pstmakestrspace(psh, 1, end);
-        assert(psh->sstrnleft > 0);
+        kHlpAssert(psh->sstrnleft > 0);
         psh->sstrnleft--;
 #endif
@@ -696 +695 @@
         size_t nbytes = (size_t)(end - pstart);
 
-        assert((uintptr_t)end > (uintptr_t)pstart);
-        assert(end[-1] == '\0');
-        assert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
-        assert(pst->avail - pst->strleft >= nbytes);
+        kHlpAssert((uintptr_t)end > (uintptr_t)pstart);
+        kHlpAssert(end[-1] == '\0');
+        kHlpAssert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
+        kHlpAssert(pst->avail - pst->strleft >= nbytes);
 
         nbytes = SHELL_ALIGN(nbytes); /** @todo don't align strings, align the other allocations. */
@@ -712 +711 @@
         size_t nbytes = (size_t)(end - pstart);
 
-        assert((uintptr_t)end > (uintptr_t)pstart);
-        assert(end[-1] == '\0');
-        assert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
-        assert(stackblocksize(psh) - psh->sstrnleft >= nbytes);
+        kHlpAssert((uintptr_t)end > (uintptr_t)pstart);
+        kHlpAssert(end[-1] == '\0');
+        kHlpAssert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
+        kHlpAssert(stackblocksize(psh) - psh->sstrnleft >= nbytes);
 
         nbytes = SHELL_ALIGN(nbytes); /** @todo don't align strings, align the other allocations. */

trunk/src/kash/memalloc.h

@@ -74 +74 @@
 #define STPUTC(psh, c, p)           (--(psh)->sstrnleft >= 0? (*p++ = (c)) : (p = growstackstr(psh), *p++ = (c)))
 #define CHECKSTRSPACE(psh, n, p)    { if ((psh)->sstrnleft < n) p = makestrspace(psh); }
-#define USTPUTC(psh, c, p)          do { assert((psh)->sstrnleft > 0); \
-                                         assert(p - (char *)stackblock(psh) == stackblocksize(psh) - (psh)->sstrnleft); \
+#define USTPUTC(psh, c, p)          do { kHlpAssert((psh)->sstrnleft > 0); \
+                                         kHlpAssert(p - (char *)stackblock(psh) == stackblocksize(psh) - (psh)->sstrnleft); \
                                          --(psh)->sstrnleft; *p++ = (c); } while (0)
 #define STACKSTRNUL(psh, p)         ((psh)->sstrnleft == 0? (p = growstackstr(psh), *p = '\0') : (*p = '\0'))
@@ -114 +114 @@
 # define PSTCHECKSTRSPACE(psh, n, p) do { \
         if ((psh)->curpstack->strleft >= (n)) {/*likely*/} \
-        else { (p) = pstmakestrspace(psh, (n), (p)); assert((psh)->curpstack->strleft >= (n)); } \
+        else { (p) = pstmakestrspace(psh, (n), (p)); kHlpAssert((psh)->curpstack->strleft >= (n)); } \
     } while (0)
 # define PSTUPUTC(psh, c, p) do { \
-        assert((psh)->curpstack->strleft > 0); \
+        kHlpAssert((psh)->curpstack->strleft > 0); \
         (psh)->curpstack->strleft -= 1; \
         *(p)++ = (c); \
@@ -137 +137 @@
 # define PSTARTSTACKSTR(psh, p)      do { (p) = (psh)->stacknxt; (psh)->sstrnleft = (psh)->stacknleft; } while (0)
 # define PSTCHECKSTRSPACE(psh, n, p) do { if ((psh)->sstrnleft >= (n)) {/*likely*/} \
-                                         else { (p) = pstmakestrspace(psh, (n), (p)); assert((psh)->sstrnleft >= (n)); } } while (0)
-# define PSTUPUTC(psh, c, p)         do { assert((psh)->sstrnleft > 0); --(psh)->sstrnleft; *(p)++ = (c); } while (0)
+                                         else { (p) = pstmakestrspace(psh, (n), (p)); kHlpAssert((psh)->sstrnleft >= (n)); } } while (0)
+# define PSTUPUTC(psh, c, p)         do { kHlpAssert((psh)->sstrnleft > 0); --(psh)->sstrnleft; *(p)++ = (c); } while (0)
 # define PSTPUTC(psh, c, p)          do { if (--(psh)->sstrnleft >= 0) *(p)++ = (c); else (p) = pstputcgrow(psh, (p), (c)); } while (0)
 # define PSTPUTSTRN(psh, str, n, p)  do { if ((psh)->sstrnleft >= (n)) {/*likely?*/} else (p) = pstmakestrspace(psh, (n), (p)); \

trunk/src/kash/options.c

@@ -41 +41 @@
 #endif
 
-#include <assert.h>
 #include <stdlib.h>
 
@@ -109 +108 @@
             i++;
         }
-        assert(psh->arg0 != NULL);
+        kHlpAssert(psh->arg0 != NULL);
     }
 
@@ -131 +130 @@
     psh->shellparam.reset  = inherit->shellparam.reset;
     psh->shellparam.nparam = left = inherit->shellparam.nparam;
-    assert(left >= 0);
+    kHlpAssert(left >= 0);
     psh->shellparam.p = (char **)ckmalloc(psh, (left + 1) * sizeof(psh->shellparam.p[0]));
     psh->shellparam.p[left] = NULL;
@@ -142 +141 @@
     if (inherit->shellparam.optnext) {
         size_t idx = (size_t)(inherit->shellparam.optnext - inherit->shellparam.p);
-        assert(idx <= inherit->shellparam.nparam);
+        kHlpAssert(idx <= inherit->shellparam.nparam);
         if (idx <= inherit->shellparam.nparam)
             psh->shellparam.optnext = &psh->shellparam.p[idx];
@@ -169 +168 @@
             off--;
         }
-        assert(psh->shellparam.optptr != NULL);
+        kHlpAssert(psh->shellparam.optptr != NULL);
     }
 
@@ -225 +224 @@
         psh->shellparam.p = psh->argptr;
         psh->shellparam.reset = 1;
-        /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
+        /* kHlpAssert(shellparam.malloc == 0 && shellparam.nparam == 0); */
         while (*psh->argptr) {
                 psh->shellparam.nparam++;

trunk/src/kash/parser.c

@@ -43 +43 @@
 #define SH_MEMALLOC_NO_STACK
 #include <stdlib.h>
-#include <assert.h>
 
 #include "shell.h"

trunk/src/kash/redir.c

@@ -43 +43 @@
 #include <sys/types.h>
 #include <limits.h>         /* PIPE_BUF */
-#include <assert.h>
 #include <string.h>
 #include <errno.h>
@@ -158 +157 @@
         idxexpfname = 0;
         for (n = redir, idxexpfname = 0 ; n ; n = n->nfile.next, idxexpfname++) {
-                assert(idxexpfname < psh->expfnames->count);
+                kHlpAssert(idxexpfname < psh->expfnames->count);
                 fd = n->nfile.fd;
                 try = 0;
@@ -196 +195 @@
                         openredirect(psh, n, memory, flags, psh->expfnames->names[idxexpfname]);
         }
-        assert(!redir || idxexpfname == psh->expfnames->count);
+        kHlpAssert(!redir || idxexpfname == psh->expfnames->count);
         if (memory[1])
                 psh->out1 = &psh->memout;

trunk/src/kash/setmode.c

@@ -44 +44 @@
 #include <sys/stat.h>
 
-#include <assert.h>
 #include <ctype.h>
 #include <errno.h>
@@ -76 +75 @@
 
 #ifndef _DIAGASSERT
-# define _DIAGASSERT assert
+# define _DIAGASSERT kHlpAssert
 #endif
 

trunk/src/kash/shfile.c

@@ -33 +33 @@
 #include <stdio.h>
 #include <string.h>
-#include <assert.h>
 
 #if K_OS == K_OS_WINDOWS
@@ -235 +234 @@
         if (decrement_pending)
         {
-            assert(g_shfile_async_close.num_pending > 0);
+            kHlpAssert(g_shfile_async_close.num_pending > 0);
             g_shfile_async_close.num_pending -= 1;
         }
@@ -242 +241 @@
         if (idx != g_shfile_async_close.idx_write % K_ELEMENTS(g_shfile_async_close.handles))
         {
-            assert(g_shfile_async_close.num_pending > 0);
+            kHlpAssert(g_shfile_async_close.num_pending > 0);
             toclose = g_shfile_async_close.handles[idx];
-            assert(toclose);
+            kHlpAssert(toclose);
             g_shfile_async_close.handles[idx] = NULL;
             g_shfile_async_close.idx_read = (idx + 1) % K_ELEMENTS(g_shfile_async_close.handles);
@@ -254 +253 @@
             {
                 BOOL rc = SetEvent(g_shfile_async_close.evt_sync);
-                assert(rc);
+                kHlpAssert(rc);
                 g_shfile_async_close.signal_sync = FALSE;
             }
@@ -265 +264 @@
         {
             BOOL rc = CloseHandle(toclose);
-            assert(rc);
+            kHlpAssert(rc);
             decrement_pending = K_TRUE;
         }
@@ -271 +270 @@
         {
             DWORD dwRet = WaitForSingleObject(g_shfile_async_close.evt_workers, 10000 /*ms*/);
-            assert(dwRet == WAIT_OBJECT_0 || dwRet == WAIT_TIMEOUT);
+            kHlpAssert(dwRet == WAIT_OBJECT_0 || dwRet == WAIT_TIMEOUT);
             decrement_pending = K_FALSE;
         }
@@ -303 +302 @@
     {
         /* Write the handle to the ring buffer: */
-        assert(g_shfile_async_close.handles[idx] == NULL);
+        kHlpAssert(g_shfile_async_close.handles[idx] == NULL);
         g_shfile_async_close.handles[idx] = toclose;
         g_shfile_async_close.idx_write    = idx_next;
@@ -311 +310 @@
 
         ret = SetEvent(g_shfile_async_close.evt_workers);
-        assert(ret);
+        kHlpAssert(ret);
         if (ret)
         {
@@ -322 +321 @@
                 intptr_t hThread = _beginthreadex(NULL /*security*/, 0 /*stack_size*/, shfile_async_close_handle_thread,
                                                   NULL /*arg*/, 0 /*initflags*/, &tid);
-                assert(hThread != -1);
+                kHlpAssert(hThread != -1);
                 if (hThread != -1)
                 {
@@ -375 +374 @@
         {
             BOOL rc = ResetEvent(g_shfile_async_close.evt_sync);
-            assert(rc); K_NOREF(rc);
+            kHlpAssert(rc); K_NOREF(rc);
 
             g_shfile_async_close.signal_sync = K_TRUE;
@@ -384 +383 @@
         TRACE2((NULL, "shfile_async_close_sync: Calling WaitForSingleObject...\n"));
         dwRet = WaitForSingleObject(g_shfile_async_close.evt_sync, 10000 /*ms*/);
-        assert(dwRet == WAIT_OBJECT_0);
-        assert(g_shfile_async_close.num_pending == 0);
+        kHlpAssert(dwRet == WAIT_OBJECT_0);
+        kHlpAssert(g_shfile_async_close.num_pending == 0);
         TRACE2((NULL, "shfile_async_close_sync: WaitForSingleObject returned %u...\n", dwRet));
     }
@@ -441 +440 @@
     KU64 ns = shfile_nano_ts();
     BOOL fRc = CloseHandle((HANDLE)native);
-    assert(fRc); K_NOREF(fRc);
+    kHlpAssert(fRc); K_NOREF(fRc);
     ns = shfile_nano_ts() - ns;
     if (ns > 1000000)
@@ -448 +447 @@
 #  else
     BOOL fRc = CloseHandle((HANDLE)native);
-    assert(fRc); K_NOREF(fRc);
+    kHlpAssert(fRc); K_NOREF(fRc);
 #  endif
     }
@@ -656 +655 @@
 {
     shmtx_leave(&pfdtab->mtx, ptmp);
-    assert(file);
+    kHlpAssert(file);
     (void)file;
 }
@@ -1069 +1068 @@
 
                             fd2 = shfile_insert(pfdtab, (intptr_t)h, fFlags, fFlags2, i, "shtab_init", NULL);
-                            assert(fd2 == i); (void)fd2;
+                            kHlpAssert(fd2 == i); (void)fd2;
                             if (fd2 != i)
                                 rc = -1;
@@ -1095 +1094 @@
                                 fFlags2 = SHFILE_FLAGS_FILE;
                             fd2 = shfile_insert(pfdtab, (intptr_t)hFile, fFlags, fFlags2, i, "shtab_init", NULL);
-                            assert(fd2 == i); (void)fd2;
+                            kHlpAssert(fd2 == i); (void)fd2;
                             if (fd2 != i)
                                 rc = -1;
@@ -1136 +1135 @@
                                 native = fd;
                             fd2 = shfile_insert(pfdtab, native, oflags, fFlags2, fd, "shtab_init", NULL);
-                            assert(fd2 == fd); (void)fd2;
+                            kHlpAssert(fd2 == fd); (void)fd2;
                             if (fd2 != fd)
                                 rc = -1;
@@ -1268 +1267 @@
 #if K_OS == K_OS_WINDOWS
                     BOOL rc = CloseHandle((HANDLE)pfd->native);
-                    assert(rc == TRUE); K_NOREF(rc);
+                    kHlpAssert(rc == TRUE); K_NOREF(rc);
 #else
                     int rc = close((int)pfd->native);
-                    assert(rc == 0); K_NOREF(rc);
+                    kHlpAssert(rc == 0); K_NOREF(rc);
 #endif
                     pfd->fd     = -1;
@@ -1330 +1329 @@
             TRACE2((NULL, "shfile_set_inherit_win: %p -> %p (set=%d)\n", pfd->native, hFile, set));
             if (!CloseHandle((HANDLE)pfd->native))
-                assert(0);
+                kHlpAssert(0);
             pfd->native = (intptr_t)hFile;
         }
@@ -1336 +1335 @@
         {
             err = GetLastError();
-            assert(0);
+            kHlpAssert(0);
             hFile = (HANDLE)pfd->native;
         }
@@ -2043 +2042 @@
     {
 # if K_OS == K_OS_WINDOWS
-        assert(SEEK_SET == FILE_BEGIN);
-        assert(SEEK_CUR == FILE_CURRENT);
-        assert(SEEK_END == FILE_END);
+        kHlpAssert(SEEK_SET == FILE_BEGIN);
+        kHlpAssert(SEEK_CUR == FILE_CURRENT);
+        kHlpAssert(SEEK_END == FILE_END);
         rc = SetFilePointer((HANDLE)file->native, off, NULL, whench);
         if (rc == INVALID_SET_FILE_POINTER)
@@ -2096 +2095 @@
                 {
 # if K_OS == K_OS_WINDOWS
-                    assert(0);
+                    kHlpAssert(0);
                     errno = EINVAL;
                     rc = -1;

trunk/src/kash/shfork-win.c

@@ -6 +6 @@
 #include <string.h>
 #include <locale.h>
-#include <assert.h>
 #include "shinstance.h"
 #include <Windows.h>
@@ -85 +84 @@
     g_stack_base  = shfork_string_to_ptr(argv[5], argv[0], "--stack-base");
     g_stack_limit = shfork_string_to_ptr(argv[7], argv[0], "--stack-limit");
-    assert((uintptr_t)stack_ptr < (uintptr_t)g_stack_base);
-    assert((uintptr_t)stack_ptr > (uintptr_t)g_stack_limit);
+    kHlpAssert((uintptr_t)stack_ptr < (uintptr_t)g_stack_base);
+    kHlpAssert((uintptr_t)stack_ptr > (uintptr_t)g_stack_limit);
 
     /*
@@ -183 +182 @@
     int rc = 0;
 
-    assert((uintptr_t)stack_ptr < (uintptr_t)g_stack_base);
-    assert((uintptr_t)stack_ptr > (uintptr_t)g_stack_limit);
+    kHlpAssert((uintptr_t)stack_ptr < (uintptr_t)g_stack_base);
+    kHlpAssert((uintptr_t)stack_ptr > (uintptr_t)g_stack_limit);
 
     /*

trunk/src/kash/shheap.c

@@ -32 +32 @@
 #include <string.h>
 #include <stdlib.h>
-#include <assert.h>
 #include "shinstance.h"
 
@@ -105 +104 @@
 # define SHHEAP_CHECK()         shheap_check()
 # define SHHEAP_CHECK_2()       shheap_check()
-# define SHHEAP_ASSERT(expr)    assert(expr)
+# define SHHEAP_ASSERT(expr)    kHlpAssert(expr)
 # define SHHEAP_POISON_PSH(p,v) ((shinstance *)(v))
 # define SHHEAP_POISON_NULL(v)  ((void *)(v))

trunk/src/kash/shinstance.c

@@ -32 +32 @@
 #include <string.h>
 #include <stdlib.h>
-#include <assert.h>
 #ifdef _MSC_VER
 # include <process.h>
@@ -174 +173 @@
 {
 #if K_OS == K_OS_WINDOWS
-    assert(ptmp->i == 0x42);
+    kHlpAssert(ptmp->i == 0x42);
     LeaveCriticalSection((CRITICAL_SECTION *)pmtx);
     ptmp->i = 0x21;
@@ -190 +189 @@
 void sh_init_globals(void)
 {
-    assert(g_sh_mtx.au64[SHMTX_MAGIC_IDX] != SHMTX_MAGIC);
+    kHlpAssert(g_sh_mtx.au64[SHMTX_MAGIC_IDX] != SHMTX_MAGIC);
     shmtx_init(&g_sh_mtx);
 #ifndef SH_FORKED_MODE
@@ -317 +316 @@
     sh_free(psh, psh->threadarg);
     psh->threadarg = NULL;
-    assert(!psh->subshellstatus);
+    kHlpAssert(!psh->subshellstatus);
     if (psh->subshellstatus)
     {
@@ -910 +909 @@
                 else
                 {
-                    assert(old.sa_handler == SIG_IGN);
+                    kHlpAssert(old.sa_handler == SIG_IGN);
                     shold.sh_handler = SH_SIG_IGN;
                 }
@@ -919 +918 @@
                 /* fake */
 #ifndef _MSC_VER
-                assert(0);
+                kHlpAssert(0);
                 old.sa_handler = SIG_DFL;
                 old.sa_flags = 0;
@@ -945 +944 @@
             for (cur = g_sh_head; cur; cur = cur->next)
             {
-                assert(cur->sigactions[signo].sh_handler == SH_SIG_UNK);
+                kHlpAssert(cur->sigactions[signo].sh_handler == SH_SIG_UNK);
                 cur->sigactions[signo] = shold;
             }
@@ -988 +987 @@
     else
     {
-        assert(pfn != SH_SIG_ERR);
+        kHlpAssert(pfn != SH_SIG_ERR);
         pfn(pshDst, signo);
     }
@@ -1125 +1124 @@
                 && signo != SIGTTOU
                 && signo != SIGCONT)
-                assert(0);
+                kHlpAssert(0);
         }
 #else
         if (sigaction(signo, &g_sig_state[signo].sa, NULL))
-            assert(0);
+            kHlpAssert(0);
 #endif
 
@@ -1417 +1416 @@
 {
     unsigned refs = sh_atomic_dec(&sts->refs);
-    assert(refs > 1);
-    assert(refs < 16);
+    kHlpAssert(refs > 1);
+    kHlpAssert(refs < 16);
     return refs;
 }
@@ -1428 +1427 @@
 {
     unsigned refs = sh_atomic_dec(&sts->refs);
-    assert(refs < ~(unsigned)0/4);
+    kHlpAssert(refs < ~(unsigned)0/4);
     if (refs == 0)
     {
@@ -1463 +1462 @@
 # if K_OS == K_OS_WINDOWS
         BOOL rc = ResetEvent((HANDLE)sts->towaiton);
-        assert(rc); K_NOREF(rc);
+        kHlpAssert(rc); K_NOREF(rc);
 # endif
     }
@@ -1477 +1476 @@
         if (!sts->towaiton)
         {
-            assert(0);
+            kHlpAssert(0);
             sh_free(psh, sts);
             return NULL;
@@ -1508 +1507 @@
         sts->status = W_EXITCODE(iExit, 0);
         sts->done   = K_TRUE;
-        rc = SetEvent((HANDLE)sts->towaiton); assert(rc); K_NOREF(rc);
+        rc = SetEvent((HANDLE)sts->towaiton); kHlpAssert(rc); K_NOREF(rc);
 
         hThread = (HANDLE)sts->hThread;
         sts->hThread = 0;
-        rc = CloseHandle(hThread); assert(rc);
+        rc = CloseHandle(hThread); kHlpAssert(rc);
 
         shsubshellstatus_release(psh, sts);
@@ -1781 +1780 @@
             {
                 rc = psh->children[i].subshellstatus->done;
-                assert(rc);
+                kHlpAssert(rc);
                 if (rc)
                 {
@@ -1812 +1811 @@
         {
             rc = CloseHandle(psh->children[i].hChild);
-            assert(rc);
+            kHlpAssert(rc);
         }
 
@@ -2115 +2114 @@
                  */
                 dwErr = WaitForSingleObject(ProcInfo.hProcess, INFINITE);
-                assert(dwErr == WAIT_OBJECT_0);
+                kHlpAssert(dwErr == WAIT_OBJECT_0);
 
                 if (GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
@@ -2129 +2128 @@
                 /* this shouldn't happen... */
                 TRACE2((psh, "sh_execve: GetExitCodeProcess failed: %u\n", GetLastError()));
-                assert(0);
+                kHlpAssert(0);
                 errno = EINVAL;
             }
@@ -2226 +2225 @@
     shpid pgid = psh->pgid;
 #ifndef _MSC_VER
-    assert(pgid == getpgrp());
+    kHlpAssert(pgid == getpgrp());
 #endif
 
@@ -2244 +2243 @@
         shpid pgid = psh->pgid;
 #ifndef _MSC_VER
-        assert(pgid == getpgrp());
+        kHlpAssert(pgid == getpgrp());
 #endif
     }
     else
     {
-        assert(0);
+        kHlpAssert(0);
         errno = ESRCH;
         pgid = -1;

trunk/src/kash/show.c

@@ -44 +44 @@
 #include <stdarg.h>
 #include <stdlib.h>
-#include <assert.h>
 
 #include "shell.h"
@@ -293 +292 @@
         if (pos > sizeof(psh->tracebuf)) {
                 char *end;
-                assert(0);
+                kHlpAssert(0);
                 end = memchr(psh->tracebuf, '\0', sizeof(psh->tracebuf));
                 pos = end ? end - &psh->tracebuf[0] : 0;

trunk/src/kash/shthread.c

@@ -27 +27 @@
 #include "shthread.h"
 #include "shinstance.h"
-#include <assert.h>
 
 #if K_OS == K_OS_WINDOWS
@@ -66 +65 @@
     {
         sh_tls = TlsAlloc();
-        assert(sh_tls != TLS_OUT_OF_INDEXES);
+        kHlpAssert(sh_tls != TLS_OUT_OF_INDEXES);
     }
     if (!TlsSetValue(sh_tls, psh))
-        assert(0);
+        kHlpAssert(0);
 
 #elif K_OS == K_OS_OS2
@@ -75 +74 @@
     {
         sh_tls = __libc_TLSAlloc();
-        assert(sh_tls != -1);
+        kHlpAssert(sh_tls != -1);
     }
     if (__libc_TLSSet(sh_tls, psh) == -1)
-        assert(0);
+        kHlpAssert(0);
 #else
     if (!sh_tls_inited)
     {
         if (pthread_key_create(&sh_tls, NULL) != 0)
-            assert(0);
+            kHlpAssert(0);
         sh_tls_inited = 1;
     }
     if (pthread_setspecific(sh_tls, psh) != 0)
-        assert(0);
+        kHlpAssert(0);
 #endif
 }

trunk/src/kash/shtypes.h

@@ -30 +30 @@
 
 #include "k/kTypes.h" /* Use these, not the ones below. */
+#include "k/kHlpAssert.h"
 
 #include <sys/types.h>

trunk/src/kash/var.c

@@ -41 +41 @@
 #endif
 
-#include <assert.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -303 +302 @@
                                                 } else
                                                         break;
-                                        assert(left < 256 /*whatever, just no rollover*/);
+                                        kHlpAssert(left < 256 /*whatever, just no rollover*/);
                                 }
                                 *dst = *vsrc;
@@ -336 +335 @@
 
                         dst->vp = find_var(psh, vsrc->vp->text, NULL, NULL);
-                        assert(dst->vp);
+                        kHlpAssert(dst->vp);
 
                         *ppdst = dst;