form/common/ty_enum.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*  Copyright (c) 1988 AT&T */
/*    All Rights Reserved   */


/*
 *      Copyright (c) 1997, by Sun Microsystems, Inc.
 *      All rights reserved.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"    /* SVr4.0 1.2   */

/*LINTLIBRARY*/

#include <sys/types.h>
#include <stdlib.h>
#include "utility.h"

/*
 *  TYPE_ENUM standard type
 *
 *  usage:
 *      set_field_type(f, TYPE_ENUM, list, checkcase, checkuniq);
 *
 *      char ** list;   list of acceptable strings
 *      int checkcase;  TRUE - upper/lower case is significant
 *      int checkuniq;  TRUE - unique match required
 *
 */
typedef struct {

    char ** list;
    int checkcase;
    int checkuniq;
    int count;
} ENUM;

static char * make_enum(va_list *);
static char * copy_enum(char *);
static void free_enum(char *);
static int fcheck_enum(FIELD *, char *);
static int next_enum(FIELD *, char *);
static int prev_enum(FIELD *, char *);

static FIELDTYPE typeENUM =
{
                ARGS | CHOICE,      /* status   */
                1,          /* ref      */
                (FIELDTYPE *) 0,    /* left     */
                (FIELDTYPE *) 0,    /* right    */
                make_enum,      /* makearg  */
                copy_enum,      /* copyarg  */
                free_enum,      /* freearg  */
                fcheck_enum,        /* fcheck   */
                (PTF_int) 0,        /* ccheck   */
                next_enum,      /* next     */
                prev_enum,      /* prev     */
};

FIELDTYPE * TYPE_ENUM = &typeENUM;

static char *
make_enum(va_list *ap)
{
    ENUM * n;

    if (Alloc(n, ENUM)) {
        char **     v;

        n -> list   = va_arg(*ap, char **);
        n -> checkcase  = va_arg(*ap, int);
        n -> checkuniq  = va_arg(*ap, int);

        for (v = n -> list; *v; ++v)
            ;
        n -> count = (int) (v - n -> list);
    }
    return ((char *) n);
}

static char *
copy_enum(char *arg)
{
    ENUM * n;

    if (Alloc(n, ENUM))
        *n = *((ENUM *) arg);
    return ((char *) n);
}

static void
free_enum(char *arg)
{
    Free(arg);
}

#define NO_MATCH        0
#define PARTIAL_MATCH       1
#define EXACT_MATCH     2

static int
cmp(char *x, char *v, int checkcase)
{
    while (*v && *v == ' ')         /* remove leading blanks */
        ++v;
    while (*x && *x == ' ')         /* remove leading blanks */
        ++x;

    if (*v == '\0')
        return (*x == '\0' ? EXACT_MATCH : NO_MATCH);

    if (checkcase) {            /* case is significant */
        while (*x++ == *v)
            if (*v++ == '\0')
                return (EXACT_MATCH);
    } else {                /* ignore case */
        while (toupper (*x++) == toupper (*v))
            if (*v++ == '\0')
                return (EXACT_MATCH);
    }
    while (*v && *v == ' ')         /* remove trailing blanks */
        ++v;
    if (*v)
        return (NO_MATCH);
    else
        return (*--x ? PARTIAL_MATCH : EXACT_MATCH);
}

static int
fcheck_enum(FIELD *f, char *arg)
{
    ENUM *      n       = (ENUM *) arg;
    char **     list        = n -> list;
    int     checkcase   = n -> checkcase;
    int     checkuniq   = n -> checkuniq;
    int     m;
    char *      v       = field_buffer(f, 0);
    char *      x;

    while (x = *list++)
        if (m = cmp(x, v, checkcase)) {
            char * value = x;

            if (checkuniq && m != EXACT_MATCH)
                while (x = *list++)
                    if (m = cmp(x, v, checkcase)) {
                        if (m == EXACT_MATCH) {
                            value = x;
                            break;
                        }
                        else
                            value = (char *) 0;
                    }
            if (! value)
                return (FALSE);

            (void) set_field_buffer(f, 0, value);
            return (TRUE);
        }

    return (FALSE);
}

static int
next_enum(FIELD *f, char *arg)
{
    ENUM *      n       = (ENUM *) arg;
    char **     list        = n -> list;
    int     checkcase   = n -> checkcase;
    int     count       = n -> count;
    char *      v       = field_buffer(f, 0);

    while (count--)
        if (cmp(*list++, v, checkcase) == EXACT_MATCH)
            break;
    if (count <= 0)
        list = n -> list;

    if (count >= 0 || cmp("", v, checkcase) == EXACT_MATCH) {
        (void) set_field_buffer(f, 0, *list);
        return (TRUE);
    }
    return (FALSE);
}

static int
prev_enum(FIELD *f, char *arg)
{
    ENUM *      n       = (ENUM *) arg;
    char **     list        = n -> list + n -> count - 1;
    int     checkcase   = n -> checkcase;
    int     count       = n -> count;
    char *      v       = field_buffer(f, 0);

    while (count--)
        if (cmp(*list--, v, checkcase) == EXACT_MATCH)
            break;
    if (count <= 0)
        list = n -> list + n -> count - 1;

    if (count >= 0 || cmp("", v, checkcase) == EXACT_MATCH) {
        (void) set_field_buffer(f, 0, *list);
        return (TRUE);
    }
    return (FALSE);
}