No Fragments Archive 12: Textmags & Docs/nf_archive_12.iso/MAGS/SOURCES/ATARI_SRC.ZIP/atari source/AHDI/TSTDRIVE/FUNCTION.C

C/C++ Source or Header | 2001-02-09 | 4.7 KB | 318 lines

/*    Function.c        11/2/88 - 2/23/89    D.Mui        */
/*    Fix the scandisk    5/1/89    - 5/3/89    D.Mui        */

#include "define.h"



/*
 * This routine convert binary number to ascii value
 */
itoa(inword, buffer)
UWORD    inword;
BYTE    *buffer;
{
    UWORD        temp1, value;
    REG WORD    i, j;
    BYTE        tmpbuf[10];
    REG BYTE    *ascbuf;

    ascbuf = buffer;

    i = 0;                /* if the value is non zero  */

    if (!inword) {
        *ascbuf++ = '0';
    } else {
        value = inword;
        while(value) {
            temp1 = value % 10;    /*  find the remainder    */
            temp1 += 0x0030;    /*  convert to ASCII    */
            tmpbuf[i++] = temp1;    /*  buffer is reverse    */
              value = value / 10;
        }

        for (j = i-1; j >= 0; j--)     /* reverse it back    */
            *ascbuf++ = tmpbuf[j];
    }

    *ascbuf = 0;            /* end of string mark    */
    return;
}



/*
 * This routine convert binary number to ASCII hex
 */
itoh(inword, buffer)
UWORD        inword;
BYTE        *buffer;
{
    UWORD        temp1, value;
    REG WORD    i, j;
    BYTE        tmpbuf[12];
    REG BYTE    *ascbuf;

    ascbuf = buffer;
    i = 0;                /* if the value is non zero  */

    if (!inword) {
        *ascbuf++ = '0';
    } else {
        value = inword;
        while(value) {
            temp1 = value % 16;    /*  find the remainder    */
            if (temp1 > 9)
                temp1 += 0x37;
            else
                temp1 += 0x30;    /*  convert to ASCII    */
            tmpbuf[i++] = temp1;    /*  buffer is reverse    */
            value = value / 16;
        }

        for (j = i-1; j >= 0; j--)     /* reverse it back    */
            *ascbuf++ = tmpbuf[j];
    }
    *ascbuf = 0;            /* end of string mark    */
    return;
}



/*
 * This routine convert binary number to ascii value
 */
ltoa(longval, buffer)
LONG    longval;
BYTE    buffer[];
{
    UWORD    digit;
    WORD    i, j, k;
    LONG    divten;
    BYTE    buf1[12];

    i = 0;
    k = 0;

    if (!longval) {
        buffer[k++] = '0';
    } else {
      while(longval) {
        divten = longval / 10;
        digit = (int)(longval - (divten * 0x0AL));
        buf1[i++] = '0' + digit;
        longval = divten;
      }

      for (j = i-1; j >= 0; j--)
          buffer[k++] = buf1[j];
    }
    buffer[k] = 0;
}



/*
 * This routine convert long binary number to ASCII hex
 */
ltoh(longval, buffer)
LONG    longval;
BYTE    buffer[];
{
    WORD    i, j, k;
    LONG    value;
    BYTE    digit;
    BYTE    buf1[12];

    for (i = 0, j = 0; j < 8; j++) {
        value = longval & 0x0000000FL;
        longval >>= 4;

        if ((value >= 0) && (value <= 9))
            digit = (BYTE)(value) + '0';
        else
            digit = (BYTE)(value) + 0x37;

        buf1[i++] = digit;

        if (!longval)
            break;
    }

    k = 0;
    for (j = i - 1; j >= 0; j--)
        buffer[k++] = buf1[j];

    buffer[k] = 0;
}


/*
 * Change from ASCII to a binary word
 */
atoi(ptr)
char *ptr;
{
    REG WORD n;

    for (n = 0; (*ptr >= '0' && *ptr <= '9'); ptr++)
    n = (10 * n) + *ptr - '0';

    return (n);
}


/*
 * Change from ASCII hex to a binary word
 */
htoi(ptr)
BYTE *ptr;
{
    REG WORD n;
    BYTE t;

    for (n = 0; *ptr; ptr++) {
        t = toupper(*ptr);

            if (t >= '0' && t <= '9')
            n = (16 * n) + t - '0';
            else if (t >= 'A' && t <= 'F')
            n = (16 * n) + (t - 0x37);
    }

    return (n);
}


/*
 * Change from ASCII to a binary long
 *    TRUE is OK otherwise it is FALSE
 */
atol(ptr, value)
BYTE    *ptr;
LONG    *value;
{
    LONG    n, n1;
    UWORD    i;

    for (n = 0L, i = 0, n1 = 0L; *ptr; ptr++) {
        if (*ptr >= '0' && *ptr <= '9') {
            n1 = (10 * n1) + (*ptr - '0');
            if (n1 >= n)
                n = n1;
            else
                return(FALSE);
        } else
            return(FALSE);
    }
    *value = n;
    return (TRUE);
}



/*
 * Change from ASCII hex to a long binary value
 *    TRUE is OK , FALSE is overflow
 */
htol(ptr, value)
BYTE    *ptr;
LONG    *value;
{
    LONG    n;
    WORD    i;
    BYTE    t, toupper();

    for (n = 0L; *ptr; ptr++) {
        t = toupper(*ptr);

        if (t >= '0' && t <= '9') {
            n = (16 * n) + (t - '0');
        } else {
            if (t >= 'A' && t <= 'F')
                n = (16 * n) + (t - 0x37);
            else
                return(FALSE);
        }
    }
    *value = n;
    return (TRUE);
}



/*
 * Do a byte comparsion
 */
bcmp(source, dest, size)
BYTE    *source;
BYTE    *dest;
UWORD    size;
{
    UWORD    i;

    for (i = 0; i < size; i++) {
        if (source[i] != dest[i])
        return(FALSE);
    }
    return(TRUE);
}


/*
 * Return uppercase of `c'
 *
 */
BYTE
toupper(c)
BYTE c;
{
    if(c >= 'a' && c <= 'z')
    c -= 0x20;
    return c;
}



bfill(source, input, size)
REG BYTE    *source;
REG BYTE    input;
REG UWORD    size;
{
    REG UWORD    i;

    for(i = 0; i < size; i++)
      *source++ = input;
}



llfill(source, input, size)
REG LONG    *source;
REG LONG    input;
REG LONG    size;
{
    REG LONG    i;

    for(i = 0; i < size; i++)
      *source++ = input;
}



lbfill(source, input, size)
REG BYTE    *source;
REG BYTE    input;
REG LONG    size;
{
    REG LONG    i;

    for(i = 0; i < size; i++)
      *source++ = input;
}