AmigActive 13/AACD13.ISO/AACD/Resources/System/BoingBag1/Contributions/Workbench/RexxArpLib3p6/src/util.c

C/C++ Source or Header | 1998-06-21 | 4KB | 247 lines

/**    Util.c
  *
  *    Implement some basic utility functions for rexxarplib.library.
  *
  *   AUTHOR/DATE:  W.G.J. Langeveld, November 1987.
  *   ============
  *
  *    CURRENT VERSION:
  *
  *    This version has been converted to SAS C 6.5 format. It has been modified
  *    for modern definition sequences for ANSI compilation. This no longer works
  *    with OS versions prior to 2.04.
  *
  *    SC 6.5 #define's "index" and "rindex" to be aliased to strchr and strrchr
  *    respectively. This rather destroyed the behavior of the subroutines below.
  *    Hence the conditional undefs for index and rindex.
  *
  *   AUTHOR/DATE:  Joanne Dow, [e-mail], June 1998.
  *   ============
  *
  **/
#include <functions.h>
#include "ralprotos.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <simpreq.h>
#include <proto/rexxsyslib.h>

/**
 *
 *   Case insensitive compare
 *
**/
strcmpu( char *s, char *t )
{
    for ( ; toupper(*s) == toupper(*t); s++, t++)
    if (*s == '\0')
        return(0);

    return(toupper(*s) - toupper(*t));
}

strncmpu( char *s, char *t, int n)
{
    n--;
    for ( ; (toupper(*s) == toupper(*t)) && n; s++, t++, n--)
    if (*s == '\0')
        return(0);

    return(toupper(*s) - toupper(*t));
}

/*
 *   index and rindex    == strchr and strrchr via defines in 6.5 strings.h
 *        Since these two provide a NULL return on testing for '\0' we have
 *        to undefine index and rindex to that these compiled versions work.
 */
#ifdef index
#undef index
#endif

char *index( const char *s, int c )
{
    if (c == 0)
        return(NULL);
    return(strchr(s, c));
}

#ifdef rindex
#undef rindex
#endif

char *rindex( const char *s, int c )
{
    if (c == 0)
        return(NULL);
    return(strrchr(s, c));
}

/**
 *
 *   Convert a long to an ascii string. sprintf is too much...
 *
**/
#define BASE 10

char *ltoa( char *str, long n )
{
    static char nums[] = "0123456789ABCDEF";
    int i, j, s = 0, c;

    if (n < 0L)
    {
        s = 1;
        n = - n;
    }
    j = -1;
    if (n == 0L)
    {
        j++;
        str[0] = '0';
    }
    while (n)
    {
        j++;
        i = n % BASE;
        str[j] = nums[i];
        n /= BASE;
    }
    if (s)
    {
        j++;
        str[j] = '-';
    }
    str[j + 1] = '\0';
    for (i = 0; i < j; i++, j--)
    {
        c = str[i];
        str[i] = str[j];
        str[j] = c;
    }

    return(str);
}

/**
 *
 *   Find index of t in s (K&R index function, K&R page 67).
 *   Modifications: returns pointer to position in s, not numeric index.
 *                  This makes it compatible with ANSI strstr(), but this one is
 *                  case insensitive.
 *
**/
char *strstr( const char s[], const char t[] )
{
    int i,j,k;

    for (i = 0; s[i] != '\0'; i++)
    {
        for (j = i, k = 0;
            t[k] != '\0' && tolower(s[j]) == tolower(t[k]); j++, k++)
        ;
        if (t[k] == '\0')
            return(&s[i]);
    }
    return(0L);
}


/**
 *
 *   Interface to CreateArgstring()
 *   Note, that this can't be a macro since "a" may be an expression and the
 *   order of evaluation wouldn't be guaranteed.
 *
**/
char *CAS( char *a )
{
    char *CreateArgstring();

    return((char *) CreateArgstring( a, (long) strlen(a)) );
}

/**
 *
 *   Check whether the specified number of arguments are non-null
 *
**/
long checkargs( int n, char *args[] )
{
    int i;

    if (args == 0L)
        return(17L);

    for (i = 0; i < n; i++)
    {
        if (args[i] == 0L)
            return(12L);
    }

    return(0);
}

/**
 *
 *   Function to decode a string into substrings using \ as newline.
 *
**/
DecodeAutoText( char *s, char *t[], char *ps )
{
    int i;
    char *ind;

    if (s == 0L)
        return;
    if (t == 0L)
        return;
    if (ps == 0L)
        return;

    strcpy(ps, s);
    ind = ps;
    for (i = 0; i < SR_MAXPROMPTS; i++)
    {
        t[i] = ind;
        ind = index(ind, '\\');
        if (ind == 0L)
            break;
        else
            *ind = '\0';
        ind++;
    }

    return;
}

/**
 *
 *   Make a stem variable out of parts
 *
**/
MakeStem(char *s, char *name, int n)
{
    char numbuff[10];

    if (s && name)
    {
        ltoa(numbuff, (long) n);
        strcpy(s, name);
        strcat(s, ".");
        strcat(s, numbuff);
    }
}

MakeStemS( char *s, char *name, char *field )
{
    if (s && name && field)
    {
        strcpy(s, name);
        strcat(s, ".");
        strcat(s, field);
    }
}