Garbo/Garbo.cdr/pc/unix/dgrep.arc/CLIB.C

C/C++ Source or Header | 1990-03-16 | 5.4 KB | 243 lines

/************************************************************************\
 *
 *    CLIB.C
 *
 * This file defines some ANSI C and SYSTEM V compatible library
 * routines for BSD UNIX, input buffer allocating and some system
 * dependant routines.
\************************************************************************/

#include "system.h"

unsigned    maxbuf;
uchar*        buffer;

/**********************************************************************
 *
 *    d_free
 */
void d_free(void* ptr)
{
    REG1 void** p = (void**)ptr;

    if (*p != NULL) {
        free(*p);
        *p = NULL;
    }
}

/**********************************************************************
 *
 *    alloc_buffer
 *
 * Allocate I/O-buffer.
 */
void alloc_buffer(void)
#if defined(__TURBOC__) || defined(M_I86)
{
    buffer = sbrk(0);
    if ((int)buffer == -1)
        error("Input buffer allocation failed", 3);
    /* Calculate largest input buffer that doesn't cause pointer
       wraparound in boyer-moore. */
    maxbuf = ((unsigned)(-((int)buffer)) >> 1) - MAXREGMUST;
    /* Starting from maxbuf, try to allocate input buffer. If allocation
       fails, cut the buffer size to half until we reach minimum
       buffer size. */
    while (maxbuf >= 2*MAXREGMUST) {
        if (buffer == sbrk(maxbuf + 1))
            return;
        maxbuf /= 2;
    }
    error("Out of memory when allocating input buffer", 3);

}
#else
{
    maxbuf = MAXBUF;
    buffer = malloc(MAXBUF);
    if (buffer == NULL)
        error("Out of memory when allocating input buffer", 3);
}
#endif    /* defined(__TURBOC__) || defined(M_I86) */

#if defined(__TURBOC__)

#include    <dos.h>

/* time structure for a pseudo-random number */
static struct time    tc_time;

/**********************************************************************
 *
 *    get_sec
 */
unsigned get_sec(void)
{
    gettime(&tc_time);
    return (unsigned)tc_time.ti_sec;
}

/**********************************************************************
 *
 *    putch
 */
#define putch(c) \
{ \
    _DL = (c); \
    _AH = 2; \
    geninterrupt(0x21); \
}

/* Dummy function to save little code size */
void cdecl _setenvp (void)
{
}
#endif    /* defined(__TURBOC__) */

#if defined(__TURBOC__) || (defined(M_I86) && defined(MSDOS))
/**********************************************************************
 *
 *    putstr
 */
void putstr(REG1 uchar* str)
{
    REG2 int    c;

    while ((c = *str++) != '\0') {
        if (c == '\n')
            putch('\r');
        putch(c);
    }
}
#endif    /* defined(__TURBOC__) || (defined(M_I86) && defined(MSDOS)) */

/**********************************************************************
 *
 *    error
 */
void error(char* errmsg, int exit_value)
{
    fputs("Error: ", stderr);
    fputs(errmsg, stderr);
    fputs("\n", stderr);
    exit(exit_value);
}

/**********************************************************************
 *
 *    assertion_failure
 *
 * Own assert exit routine because many system asserts will link
 * fprintf. We don't want fprintf bacause we have worked hard to keep
 * the program as small as possible.
 */
void assertion_failure(char* file, int line)
{
    char buf[10];

    fputs("Internal error: ", stderr);
    fputs(file, stderr);
    fputs(", ", stderr);
    fputs(ultoa((ulong)line, buf, 10), stderr);
    fputs("\n", stderr);
    exit(3);
}

#ifdef TOUCH
/**********************************************************************
 *
 *    set_file_time
 */
#if defined(__TURBOC__)
bool set_file_time(char* fname, int h)
{
    struct date        d;
    static struct ftime    ft;
    static int        first_time = TRUE;

    if (first_time) {
        first_time = FALSE;
        getdate(&d);
        gettime(&tc_time);
        ft.ft_tsec = tc_time.ti_sec;
        ft.ft_min = tc_time.ti_min;
        ft.ft_hour = tc_time.ti_hour;
        ft.ft_day = d.da_day;
        ft.ft_month = d.da_mon;
        ft.ft_year = d.da_year - 1980;
    }
    return setftime(h, &ft) != -1;
}
#else
bool set_file_time(char* fname, int h)
{
    static int    first_time = TRUE;
    static utime_t    u;

    if (first_time) {
        first_time = FALSE;
        u.modtime = time(NULL);
        u.actime = u.modtime;
        }
    return utime(fname, &u) == 0;
}
#endif
#endif    /* TOUCH */

#ifdef BSD    /* BSD UNIX lacks mem(set|chr) */
/**********************************************************************
 *
 *    memset
 */
void* memset(void* b, REG3 char ch, REG2 unsigned n)
{
    REG1 uchar* s = (uchar*)b;

    while (n--)
        *s++ = ch;
    return b;
}

/************************************************************************
 *
 *    memchr
 */
void* memchr(void* b, REG3 char ch, REG2 unsigned n)
{
    REG1 uchar* s = (uchar*)b;

    while (n--)
        if (*s++ == ch)
            return s - 1;
    return NULL;
}
#endif /* BSD */

/************************************************************************
 *    ultoa
 *
 * Even if the ultoa() were already defined in the library, redefinition
 * does not matter, because this version is excatly compatible with
 * it and this is also well fast enough.
 */
char*    ultoa(ulong n, char* s, int radix)
{
    static char    itoc_xlate[] = {
        '0','1','2','3','4','5','6','7','8','9','A','B',
        'C','D','E','F','G','H','I','J','K','L','M','N',
        'O','P','Q','R','S','T','U','V','W','X','Y','Z'
    };
    register char*    s1;
    register char*    s2;

    s1 = s2 = s;
    if ((unsigned)(radix - 2) <= (unsigned)(sizeof(itoc_xlate) - 2))
        do {
            *s1++ = itoc_xlate[n % (ulong)radix];
        } while (n /= (unsigned)radix);
    for (*s1 = '\0'; --s1 > s2; ++s2)
        *s1 ^= *s2 ^= *s1 ^= *s2;    /* what on earth ??? */
    return (s);
}