/*      $NetBSD: subr.c,v 1.26 2023/08/26 15:18:27 rillig Exp $ */

/*
* Copyright (c) 1980, 1993
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)subr.c      8.1 (Berkeley) 6/6/93";
#endif
__RCSID("$NetBSD: subr.c,v 1.26 2023/08/26 15:18:27 rillig Exp $");
#endif /* not lint */

#include <ctype.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "error.h"

/*
* Arrayify a list of rules
*/
void
arrayify(int *e_length, Eptr **e_array, Eptr header)
{
       Eptr errorp;
       Eptr *array;
       int listlength;
       int listindex;

       for (errorp = header, listlength = 0;
            errorp != NULL; errorp = errorp->error_next, listlength++)
               continue;
       array = Calloc(listlength+1, sizeof (Eptr));
       for (listindex = 0, errorp = header;
           listindex < listlength;
           listindex++, errorp = errorp->error_next) {
               array[listindex] = errorp;
               errorp->error_position = listindex;
       }
       array[listindex] = NULL;
       *e_length = listlength;
       *e_array = array;
}

void *
Calloc(size_t nelements, size_t size)
{
       void *back;

       back = calloc(nelements, size);
       if (back == NULL)
               errx(1, "Ran out of memory.");
       return back;
}

char *
Strdup(const char *s)
{
       char *ret;

       ret = strdup(s);
       if (ret == NULL) {
               errx(1, "Ran out of memory.");
       }
       return ret;
}

/*
* find the position of a given character in a string
* (one based)
*/
int
position(const char *string, char ch)
{
       if (string != NULL)
               for (int i = 1; *string != '\0'; string++, i++)
                       if (*string == ch)
                               return i;
       return -1;
}

/*
* clobber the first occurrence of ch in string by the new character
*/
char *
substitute(char *string, char chold, char chnew)
{
       char *cp = string;

       if (cp != NULL)
               while (*cp != '\0') {
                       if (*cp == chold) {
                               *cp = chnew;
                               break;
                       }
                       cp++;
               }
       return string;
}

char
lastchar(const char *string)
{
       size_t length;

       if (string == NULL)
               return '\0';
       length = strlen(string);
       if (length >= 1)
               return string[length-1];
       else
               return '\0';
}

char
firstchar(const char *string)
{
       if (string != NULL)
               return string[0];
       else
               return '\0';
}

char
next_lastchar(const char *string)
{
       size_t length;

       if (string == NULL)
               return '\0';
       length = strlen(string);
       if (length >= 2)
               return string[length - 2];
       else
               return '\0';
}

void
clob_last(char *string, char newstuff)
{
       if (string != NULL && string[0] != '\0')
               string[strlen(string) - 1] = newstuff;
}

/*
* parse a string that is the result of a format %s(%d)
* return TRUE if this is of the proper format
*/
bool
persperdexplode(char *string, char **r_perd, char **r_pers)
{
       char *cp;
       size_t length = string != NULL ? strlen(string) : 0;

       if (length >= 4 && string[length - 1] == ')') {
               for (cp = &string[length - 2];
                    isdigit((unsigned char)*cp) && *cp != '(';
                    --cp)
                       continue;
               if (*cp == '(') {
                       string[length - 1] = '\0';      /* clobber the ) */
                       *r_perd = strdup(cp+1);
                       string[length - 1] = ')';
                       *cp = '\0';                     /* clobber the ( */
                       *r_pers = strdup(string);
                       *cp = '(';
                       return true;
               }
       }
       return false;
}

#if 0 /* unused */
/*
* parse a quoted string that is the result of a format \"%s\"(%d)
* return TRUE if this is of the proper format
*/
static bool
qpersperdexplode(char *string, char **r_perd, char **r_pers)
{
       char *cp;
       int length = 0;

       if (string)
               length = strlen(string);
       if (length >= 4 && string[length - 1] == ')') {
               for (cp = &string[length - 2];
                    isdigit((unsigned char)*cp) && *cp != '(';
                    --cp)
                       continue;
               if (*cp == '(' && *(cp - 1) == '"') {
                       string[length - 1] = '\0';
                       *r_perd = strdup(cp+1);
                       string[length - 1] = ')';
                       *(cp - 1) = '\0';               /* clobber the " */
                       *r_pers = strdup(string + 1);
                       *(cp - 1) = '"';
                       return true;
               }
       }
       return false;
}
#endif /* 0 - unused */

static char cincomment[] = CINCOMMENT;
static char coutcomment[] = COUTCOMMENT;
static char fincomment[] = FINCOMMENT;
static char foutcomment[] = FOUTCOMMENT;
static char newline[] = NEWLINE;
static char piincomment[] = PIINCOMMENT;
static char pioutcomment[] = PIOUTCOMMENT;
static char lispincomment[] = LISPINCOMMENT;
static char riincomment[] = RIINCOMMENT;
static char rioutcomment[] = RIOUTCOMMENT;
static char troffincomment[] = TROFFINCOMMENT;
static char troffoutcomment[] = TROFFOUTCOMMENT;
static char mod2incomment[] = MOD2INCOMMENT;
static char mod2outcomment[] = MOD2OUTCOMMENT;

struct lang_desc lang_table[] = {
       { /*INUNKNOWN   0*/     "unknown", cincomment,     coutcomment },
       { /*INCPP       1*/     "cpp",     cincomment,     coutcomment },
       { /*INCC        2*/     "cc",      cincomment,     coutcomment },
       { /*INAS        3*/     "as",      ASINCOMMENT,    newline },
       { /*INLD        4*/     "ld",      cincomment,     coutcomment },
       { /*INLINT      5*/     "lint",    cincomment,     coutcomment },
       { /*INF77       6*/     "f77",     fincomment,     foutcomment },
       { /*INPI        7*/     "pi",      piincomment,    pioutcomment },
       { /*INPC        8*/     "pc",      piincomment,    pioutcomment },
       { /*INFRANZ     9*/     "franz",   lispincomment,  newline },
       { /*INLISP      10*/    "lisp",    lispincomment,  newline },
       { /*INVAXIMA    11*/    "vaxima",  lispincomment,  newline },
       { /*INRATFOR    12*/    "ratfor",  fincomment,     foutcomment },
       { /*INLEX       13*/    "lex",     cincomment,     coutcomment },
       { /*INYACC      14*/    "yacc",    cincomment,     coutcomment },
       { /*INAPL       15*/    "apl",     ".lm",          newline },
       { /*INMAKE      16*/    "make",    ASINCOMMENT,    newline },
       { /*INRI        17*/    "ri",      riincomment,    rioutcomment },
       { /*INTROFF     18*/    "troff",   troffincomment, troffoutcomment },
       { /*INMOD2      19*/    "mod2",    mod2incomment,  mod2outcomment },
       {                       NULL,      NULL,           NULL }
};

void
printerrors(bool look_at_subclass, int errorc, Eptr errorv[])
{
       int i;
       Eptr errorp;

       for (errorp = errorv[i = 0]; i < errorc; errorp = errorv[++i]) {
               if (errorp->error_e_class == C_IGNORE)
                       continue;
               if (look_at_subclass && errorp->error_s_class == C_DUPL)
                       continue;
               printf("Error %d, (%s error) [%s], text = \"",
                       i,
                       class_table[errorp->error_e_class],
                       lang_table[errorp->error_language].lang_name);
               wordvprint(stdout,errorp->error_lgtext,errorp->error_text);
               printf("\"\n");
       }
}

void
wordvprint(FILE *fyle, int wordc, char **wordv)
{
       const char *sep = "";

       for (int i = 0; i < wordc; i++)
               if (wordv[i] != NULL) {
                       fprintf(fyle, "%s%s",sep,wordv[i]);
                       sep = " ";
               }
}

/*
* Given a string, parse it into a number of words, and build
* a wordc wordv combination pointing into it.
*/
void
wordvbuild(char *string, int *r_wordc, char ***r_wordv)
{
       char *cp;
       char **wordv;
       int wordcount;
       int wordindex;

       for (wordcount = 0, cp = string; *cp != '\0'; wordcount++) {
               while (isspace((unsigned char)*cp))
                       cp++;
               if (*cp == '\0')
                       break;
               while (*cp != '\0' && !isspace((unsigned char)*cp))
                       cp++;
       }
       wordv = Calloc(wordcount + 1, sizeof (char *));
       for (cp=string, wordindex=0; wordcount > 0; wordindex++, --wordcount) {
               while (isspace((unsigned char)*cp))
                       cp++;
               if (*cp == '\0')
                       break;
               wordv[wordindex] = cp;
               while (*cp != '\0' && !isspace((unsigned char)*cp))
                       cp++;
               *cp++ = '\0';
       }
       if (wordcount != 0)
               errx(6, "Initial miscount of the number of words in a line");
       wordv[wordindex] = NULL;
#ifdef FULLDEBUG
       for (wordcount = 0; wordcount < wordindex; wordcount++)
               printf("Word %d = \"%s\"\n", wordcount, wordv[wordcount]);
       printf("\n");
#endif
       *r_wordc = wordindex;
       *r_wordv = wordv;
}

/*
* Compare two 0 based wordvectors
*/
bool
wordv_eq(char **wordv1, int wordc, char **wordv2)
{
       for (int i = 0; i < wordc; i++)
               if (wordv1[i] == NULL || wordv2[i] == NULL
                   || strcmp(wordv1[i], wordv2[i]) != 0)
                       return false;
       return true;
}

/*
* splice a 0 based word vector onto the tail of a
* new wordv, allowing the first emptyhead slots to be empty
*/
char **
wordvsplice(int emptyhead, int wordc, char **wordv)
{
       char **nwordv;
       int nwordc = emptyhead + wordc;
       int i;

       nwordv = Calloc(nwordc, sizeof (char *));
       for (i = 0; i < emptyhead; i++)
               nwordv[i] = NULL;
       for (i = emptyhead; i < nwordc; i++)
               nwordv[i] = wordv[i-emptyhead];
       return nwordv;
}

const char *
plural(int n)
{
       return n > 1 ? "s" : "";
}

const char *
verbform(int n)
{
       return n > 1 ? "" : "s";
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.