OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [or1ksim/] [or1ksim-0.5.0rc1/] [argtable2/] [arg_rex.c] - Diff between revs 19 and 347

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 19 Rev 347
/*********************************************************************
/*********************************************************************
This file is part of the argtable2 library.
This file is part of the argtable2 library.
Copyright (C) 1998-2001,2003-2008 Stewart Heitmann
Copyright (C) 1998-2001,2003-2008 Stewart Heitmann
sheitmann@users.sourceforge.net
sheitmann@users.sourceforge.net
 
 
The argtable2 library is free software; you can redistribute it and/or
The argtable2 library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
License, or (at your option) any later version.
 
 
This software is distributed in the hope that it will be useful,
This software is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.
Library General Public License for more details.
 
 
You should have received a copy of the GNU Library General Public
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free Software
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA.
USA.
**********************************************************************/
**********************************************************************/
 
 
/* config.h must be included before anything else */
/* config.h must be included before anything else */
#ifdef HAVE_CONFIG_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#include "config.h"
#endif
#endif
 
 
#ifdef HAVE_STDLIB_H
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#include <stdlib.h>
#endif
#endif
 
 
#include "argtable2.h"
#include "argtable2.h"
#include <sys/types.h>
#include <sys/types.h>
#include <regex.h>
#include <regex.h>
 
 
 
 
/* local error codes (these must not conflict with reg_error codes) */
/* local error codes (these must not conflict with reg_error codes) */
enum {EMINCOUNT=200,EMAXCOUNT=201};
enum {EMINCOUNT=200,EMAXCOUNT=201};
 
 
struct privhdr
struct privhdr
    {
    {
    const char *pattern;
    const char *pattern;
    int flags;
    int flags;
    regex_t regex;
    regex_t regex;
    };
    };
 
 
 
 
static void resetfn(struct arg_rex *parent)
static void resetfn(struct arg_rex *parent)
    {
    {
    struct privhdr *priv = (struct privhdr*)(parent->hdr.priv);
    struct privhdr *priv = (struct privhdr*)(parent->hdr.priv);
 
 
    /*printf("%s:resetfn(%p)\n",__FILE__,parent);*/
    /*printf("%s:resetfn(%p)\n",__FILE__,parent);*/
    parent->count=0;
    parent->count=0;
 
 
    /* construct the regex representation of the given pattern string. */
    /* construct the regex representation of the given pattern string. */
    /* Dont bother checking for errors as we already did that earlier (in the constructor) */
    /* Dont bother checking for errors as we already did that earlier (in the constructor) */
    regcomp(&(priv->regex), priv->pattern, priv->flags);
    regcomp(&(priv->regex), priv->pattern, priv->flags);
    }
    }
 
 
static int scanfn(struct arg_rex *parent, const char *argval)
static int scanfn(struct arg_rex *parent, const char *argval)
    {
    {
    int errorcode = 0;
    int errorcode = 0;
 
 
    if (parent->count == parent->hdr.maxcount )
    if (parent->count == parent->hdr.maxcount )
        {
        {
        /* maximum number of arguments exceeded */
        /* maximum number of arguments exceeded */
        errorcode = EMAXCOUNT;
        errorcode = EMAXCOUNT;
        }
        }
    else if (!argval)
    else if (!argval)
        {
        {
        /* a valid argument with no argument value was given. */
        /* a valid argument with no argument value was given. */
        /* This happens when an optional argument value was invoked. */
        /* This happens when an optional argument value was invoked. */
        /* leave parent arguiment value unaltered but still count the argument. */
        /* leave parent arguiment value unaltered but still count the argument. */
        parent->count++;
        parent->count++;
        }
        }
    else
    else
        {
        {
        struct privhdr *priv = (struct privhdr*)parent->hdr.priv;
        struct privhdr *priv = (struct privhdr*)parent->hdr.priv;
 
 
       /* test the current argument value for a match with the regular expression */
       /* test the current argument value for a match with the regular expression */
        /* if a match is detected, record the argument value in the arg_rex struct */
        /* if a match is detected, record the argument value in the arg_rex struct */
        errorcode = regexec(&(priv->regex), argval, 0, NULL, 0);
        errorcode = regexec(&(priv->regex), argval, 0, NULL, 0);
        if (errorcode==0)
        if (errorcode==0)
            parent->sval[parent->count++] = argval;
            parent->sval[parent->count++] = argval;
        }
        }
 
 
    /*printf("%s:scanfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
    /*printf("%s:scanfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
    return errorcode;
    return errorcode;
    }
    }
 
 
static int checkfn(struct arg_rex *parent)
static int checkfn(struct arg_rex *parent)
    {
    {
    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
    int errorcode = (parent->count < parent->hdr.mincount) ? EMINCOUNT : 0;
    struct privhdr *priv = (struct privhdr*)parent->hdr.priv;
    struct privhdr *priv = (struct privhdr*)parent->hdr.priv;
 
 
    /* free the regex "program" we constructed in resetfn */
    /* free the regex "program" we constructed in resetfn */
    regfree(&(priv->regex));
    regfree(&(priv->regex));
 
 
    /*printf("%s:checkfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
    /*printf("%s:checkfn(%p) returns %d\n",__FILE__,parent,errorcode);*/
    return errorcode;
    return errorcode;
    }
    }
 
 
static void errorfn(struct arg_rex *parent, FILE *fp, int errorcode, const char *argval, const char *progname)
static void errorfn(struct arg_rex *parent, FILE *fp, int errorcode, const char *argval, const char *progname)
    {
    {
    const char *shortopts = parent->hdr.shortopts;
    const char *shortopts = parent->hdr.shortopts;
    const char *longopts  = parent->hdr.longopts;
    const char *longopts  = parent->hdr.longopts;
    const char *datatype  = parent->hdr.datatype;
    const char *datatype  = parent->hdr.datatype;
 
 
    /* make argval NULL safe */
    /* make argval NULL safe */
    argval = argval ? argval : "";
    argval = argval ? argval : "";
 
 
    fprintf(fp,"%s: ",progname);
    fprintf(fp,"%s: ",progname);
    switch(errorcode)
    switch(errorcode)
        {
        {
        case EMINCOUNT:
        case EMINCOUNT:
            fputs("missing option ",fp);
            fputs("missing option ",fp);
            arg_print_option(fp,shortopts,longopts,datatype,"\n");
            arg_print_option(fp,shortopts,longopts,datatype,"\n");
            break;
            break;
 
 
        case EMAXCOUNT:
        case EMAXCOUNT:
            fputs("excess option ",fp);
            fputs("excess option ",fp);
            arg_print_option(fp,shortopts,longopts,argval,"\n");
            arg_print_option(fp,shortopts,longopts,argval,"\n");
            break;
            break;
 
 
        case REG_NOMATCH:
        case REG_NOMATCH:
            fputs("illegal value  ",fp);
            fputs("illegal value  ",fp);
            arg_print_option(fp,shortopts,longopts,argval,"\n");
            arg_print_option(fp,shortopts,longopts,argval,"\n");
            break;
            break;
 
 
        default:
        default:
            {
            {
            char errbuff[256];
            char errbuff[256];
            regerror(errorcode, NULL, errbuff, sizeof(errbuff));
            regerror(errorcode, NULL, errbuff, sizeof(errbuff));
            printf("%s\n", errbuff);
            printf("%s\n", errbuff);
            }
            }
            break;
            break;
        }
        }
    }
    }
 
 
 
 
struct arg_rex* arg_rex0(const char* shortopts,
struct arg_rex* arg_rex0(const char* shortopts,
                         const char* longopts,
                         const char* longopts,
                         const char* pattern,
                         const char* pattern,
                         const char *datatype,
                         const char *datatype,
                         int flags,
                         int flags,
                         const char *glossary)
                         const char *glossary)
    {
    {
    return arg_rexn(shortopts,longopts,pattern,datatype,0,1,flags,glossary);
    return arg_rexn(shortopts,longopts,pattern,datatype,0,1,flags,glossary);
    }
    }
 
 
struct arg_rex* arg_rex1(const char* shortopts,
struct arg_rex* arg_rex1(const char* shortopts,
                         const char* longopts,
                         const char* longopts,
                         const char* pattern,
                         const char* pattern,
                         const char *datatype,
                         const char *datatype,
                         int flags,
                         int flags,
                         const char *glossary)
                         const char *glossary)
    {
    {
    return arg_rexn(shortopts,longopts,pattern,datatype,1,1,flags,glossary);
    return arg_rexn(shortopts,longopts,pattern,datatype,1,1,flags,glossary);
    }
    }
 
 
 
 
struct arg_rex* arg_rexn(const char* shortopts,
struct arg_rex* arg_rexn(const char* shortopts,
                         const char* longopts,
                         const char* longopts,
                         const char* pattern,
                         const char* pattern,
                         const char *datatype,
                         const char *datatype,
                         int mincount,
                         int mincount,
                         int maxcount,
                         int maxcount,
                         int flags,
                         int flags,
                         const char *glossary)
                         const char *glossary)
    {
    {
    size_t nbytes;
    size_t nbytes;
    struct arg_rex *result;
    struct arg_rex *result;
    struct privhdr *priv;
    struct privhdr *priv;
 
 
    if (!pattern)
    if (!pattern)
        {
        {
        printf("argtable: ERROR - illegal regular expression pattern \"(NULL)\"\n");
        printf("argtable: ERROR - illegal regular expression pattern \"(NULL)\"\n");
        printf("argtable: Bad argument table.\n");
        printf("argtable: Bad argument table.\n");
        return NULL;
        return NULL;
        }
        }
 
 
        /* foolproof things by ensuring maxcount is not less than mincount */
        /* foolproof things by ensuring maxcount is not less than mincount */
        maxcount = (maxcount<mincount) ? mincount : maxcount;
        maxcount = (maxcount<mincount) ? mincount : maxcount;
 
 
    nbytes = sizeof(struct arg_rex)       /* storage for struct arg_rex */
    nbytes = sizeof(struct arg_rex)       /* storage for struct arg_rex */
           + sizeof(struct privhdr)       /* storage for private arg_rex data */
           + sizeof(struct privhdr)       /* storage for private arg_rex data */
           + maxcount * sizeof(char*);    /* storage for sval[maxcount] array */
           + maxcount * sizeof(char*);    /* storage for sval[maxcount] array */
 
 
    result = (struct arg_rex*)malloc(nbytes);
    result = (struct arg_rex*)malloc(nbytes);
    if (result)
    if (result)
        {
        {
        int errorcode, i;
        int errorcode, i;
 
 
        /* init the arg_hdr struct */
        /* init the arg_hdr struct */
        result->hdr.flag      = ARG_HASVALUE;
        result->hdr.flag      = ARG_HASVALUE;
        result->hdr.shortopts = shortopts;
        result->hdr.shortopts = shortopts;
        result->hdr.longopts  = longopts;
        result->hdr.longopts  = longopts;
        result->hdr.datatype  = datatype ? datatype : pattern;
        result->hdr.datatype  = datatype ? datatype : pattern;
        result->hdr.glossary  = glossary;
        result->hdr.glossary  = glossary;
        result->hdr.mincount  = mincount;
        result->hdr.mincount  = mincount;
        result->hdr.maxcount  = maxcount;
        result->hdr.maxcount  = maxcount;
        result->hdr.parent    = result;
        result->hdr.parent    = result;
        result->hdr.resetfn   = (arg_resetfn*)resetfn;
        result->hdr.resetfn   = (arg_resetfn*)resetfn;
        result->hdr.scanfn    = (arg_scanfn*)scanfn;
        result->hdr.scanfn    = (arg_scanfn*)scanfn;
        result->hdr.checkfn   = (arg_checkfn*)checkfn;
        result->hdr.checkfn   = (arg_checkfn*)checkfn;
        result->hdr.errorfn   = (arg_errorfn*)errorfn;
        result->hdr.errorfn   = (arg_errorfn*)errorfn;
 
 
        /* store the arg_rex_priv struct immediately after the arg_rex struct */
        /* store the arg_rex_priv struct immediately after the arg_rex struct */
        result->hdr.priv  = (const char**)(result+1);
        result->hdr.priv  = (const char**)(result+1);
        priv = (struct privhdr*)(result->hdr.priv);
        priv = (struct privhdr*)(result->hdr.priv);
        priv->pattern = pattern;
        priv->pattern = pattern;
        priv->flags = flags | REG_NOSUB;
        priv->flags = flags | REG_NOSUB;
 
 
        /* store the sval[maxcount] array immediately after the arg_rex_priv struct */
        /* store the sval[maxcount] array immediately after the arg_rex_priv struct */
        result->sval  = (const char**)(priv+1);
        result->sval  = (const char**)(priv+1);
        result->count = 0;
        result->count = 0;
 
 
        /* foolproof the string pointers by initialising them to reference empty strings */
        /* foolproof the string pointers by initialising them to reference empty strings */
        for (i=0; i<maxcount; i++)
        for (i=0; i<maxcount; i++)
            { result->sval[i] = ""; }
            { result->sval[i] = ""; }
 
 
        /* here we construct and destroy a regex representation of the regular expression
        /* here we construct and destroy a regex representation of the regular expression
           for no other reason than to force any regex errors to be trapped now rather
           for no other reason than to force any regex errors to be trapped now rather
           than later. If we dont, then errors may go undetected until an argument is
           than later. If we dont, then errors may go undetected until an argument is
           actually parsed. */
           actually parsed. */
        errorcode = regcomp(&(priv->regex), priv->pattern, priv->flags);
        errorcode = regcomp(&(priv->regex), priv->pattern, priv->flags);
        if (errorcode)
        if (errorcode)
            {
            {
            char errbuff[256];
            char errbuff[256];
            regerror(errorcode, &(priv->regex), errbuff, sizeof(errbuff));
            regerror(errorcode, &(priv->regex), errbuff, sizeof(errbuff));
            printf("argtable: %s \"%s\"\n", errbuff, priv->pattern);
            printf("argtable: %s \"%s\"\n", errbuff, priv->pattern);
            printf("argtable: Bad argument table.\n");
            printf("argtable: Bad argument table.\n");
            }
            }
        else
        else
            regfree(&(priv->regex));
            regfree(&(priv->regex));
        }
        }
 
 
    /*printf("arg_rexn() returns %p\n",result);*/
    /*printf("arg_rexn() returns %p\n",result);*/
    return result;
    return result;
    }
    }
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.