diff options
Diffstat (limited to 'text-utils')
-rw-r--r-- | text-utils/display.c | 64 | ||||
-rw-r--r-- | text-utils/hexdump.c | 21 | ||||
-rw-r--r-- | text-utils/hexdump.h | 14 | ||||
-rw-r--r-- | text-utils/hexsyntax.c | 2 | ||||
-rw-r--r-- | text-utils/parse.c | 144 |
5 files changed, 141 insertions, 104 deletions
diff --git a/text-utils/display.c b/text-utils/display.c index 11303667e..1800f2a10 100644 --- a/text-utils/display.c +++ b/text-utils/display.c @@ -169,35 +169,47 @@ static void bpad(PR *pr) void display(void) { - register FS *fs; + struct list_head *fs; + register FS *fss; register FU *fu; register PR *pr; register int cnt; register unsigned char *bp; off_t saveaddress; unsigned char savech = 0, *savebp; + struct list_head *p, *q, *r; - while ((bp = get()) != NULL) - for (fs = fshead, savebp = bp, saveaddress = address; fs; - fs = fs->nextfs, bp = savebp, address = saveaddress) - for (fu = fs->nextfu; fu; fu = fu->nextfu) { - if (fu->flags&F_IGNORE) - break; - for (cnt = fu->reps; cnt; --cnt) - for (pr = fu->nextpr; pr; address += pr->bcnt, - bp += pr->bcnt, pr = pr->nextpr) { - if (eaddress && address >= eaddress && - !(pr->flags&(F_TEXT|F_BPAD))) - bpad(pr); - if (cnt == 1 && pr->nospace) { - savech = *pr->nospace; - *pr->nospace = '\0'; - } - print(pr, bp); - if (cnt == 1 && pr->nospace) - *pr->nospace = savech; - } - } + while ((bp = get()) != NULL) { + fs = &fshead; savebp = bp; saveaddress = address; + list_for_each(p, fs) { + fss = list_entry(p, FS, nextfs); + list_for_each(q, &fss->nextfu) { + fu = list_entry(q, FU, nextfu); + if (fu->flags&F_IGNORE) + break; + cnt = fu->reps; + while (cnt) { + list_for_each(r, &fu->nextpr) { + pr = list_entry(r, PR, nextpr); + if (eaddress && address >= eaddress && + !(pr->flags&(F_TEXT|F_BPAD))) + bpad(pr); + if (cnt == 1 && pr->nospace) { + savech = *pr->nospace; + *pr->nospace = '\0'; + } + print(pr, bp); + if (cnt == 1 && pr->nospace) + *pr->nospace = savech; + address += pr->bcnt; + bp += pr->bcnt; + } + --cnt; + } + } + bp = savebp; address = saveaddress; + } + } if (endfu) { /* * if eaddress not set, error or file size was multiple of @@ -208,15 +220,17 @@ void display(void) return; eaddress = address; } - for (pr = endfu->nextpr; pr; pr = pr->nextpr) + list_for_each (p, &endfu->nextpr) { + pr = list_entry(p, PR, nextpr); switch(pr->flags) { case F_ADDRESS: - (void)printf(pr->fmt, (int64_t)eaddress); + printf(pr->fmt, (int64_t)eaddress); break; case F_TEXT: - (void)printf("%s", pr->fmt); + printf("%s", pr->fmt); break; } + } } } diff --git a/text-utils/hexdump.c b/text-utils/hexdump.c index e966cc313..18b3ec23f 100644 --- a/text-utils/hexdump.c +++ b/text-utils/hexdump.c @@ -41,40 +41,47 @@ #include <stdlib.h> #include "hexdump.h" +#include "list.h" #include "nls.h" #include "c.h" #include "closestream.h" -FS *fshead; /* head of format strings */ +struct list_head fshead; /* head of format strings */ ssize_t blocksize; /* data block size */ int exitval; /* final exit value */ ssize_t length = -1; /* max bytes to read */ int main(int argc, char **argv) { + struct list_head *p; FS *tfs; - char *p; + char *c; + INIT_LIST_HEAD(&fshead); setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); - if (!(p = strrchr(argv[0], 'o')) || strcmp(p, "od")) { + if (!(c = strrchr(argv[0], 'o')) || strcmp(c, "od")) { newsyntax(argc, &argv); } else errx(EXIT_FAILURE, _("calling hexdump as od has been deprecated " "in favour to GNU coreutils od.")); /* figure out the data block size */ - for (blocksize = 0, tfs = fshead; tfs; tfs = tfs->nextfs) { - tfs->bcnt = block_size(tfs); - if (blocksize < tfs->bcnt) + blocksize = 0; + list_for_each(p, &fshead) { + tfs = list_entry(p, FS, nextfs); + if ((tfs->bcnt = block_size(tfs)) > blocksize) blocksize = tfs->bcnt; } + /* rewrite the rules, do syntax checking */ - for (tfs = fshead; tfs; tfs = tfs->nextfs) + list_for_each(p, &fshead) { + tfs = list_entry(p, FS, nextfs); rewrite(tfs); + } (void)next(argv); display(); diff --git a/text-utils/hexdump.h b/text-utils/hexdump.h index fa8f632c1..c9fc4a009 100644 --- a/text-utils/hexdump.h +++ b/text-utils/hexdump.h @@ -32,9 +32,11 @@ * * @(#)hexdump.h 5.4 (Berkeley) 6/1/90 */ +#include "c.h" +#include "list.h" typedef struct _pr { - struct _pr *nextpr; /* next print unit */ + struct list_head nextpr; /* next print unit */ #define F_ADDRESS 0x001 /* print offset */ #define F_BPAD 0x002 /* blank pad */ #define F_C 0x004 /* %_c */ @@ -54,8 +56,8 @@ typedef struct _pr { } PR; typedef struct _fu { - struct _fu *nextfu; /* next format unit */ - struct _pr *nextpr; /* next print unit */ + struct list_head nextfu; /* next format unit */ + struct list_head nextpr; /* next print unit */ #define F_IGNORE 0x01 /* %_A */ #define F_SETREP 0x02 /* rep count set, not default */ unsigned int flags; /* flag values */ @@ -65,13 +67,13 @@ typedef struct _fu { } FU; typedef struct _fs { /* format strings */ - struct _fs *nextfs; /* linked list of format strings */ - struct _fu *nextfu; /* linked list of format units */ + struct list_head nextfs; /* linked list of format strings */ + struct list_head nextfu; /* linked list of format units */ int bcnt; } FS; extern FU *endfu; -extern FS *fshead; /* head of format strings list */ +extern struct list_head fshead; /* head of format strings list */ extern ssize_t blocksize; /* data block size */ extern int exitval; /* final exit value */ extern ssize_t length; /* max bytes to read */ diff --git a/text-utils/hexsyntax.c b/text-utils/hexsyntax.c index b37e46e0d..9b6a1e2fc 100644 --- a/text-utils/hexsyntax.c +++ b/text-utils/hexsyntax.c @@ -128,7 +128,7 @@ newsyntax(int argc, char ***argvp) } } - if (!fshead) { + if (list_empty(&fshead)) { add("\"%07.7_Ax\n\""); add("\"%07.7_ax \" 8/2 \"%04x \" \"\\n\""); } diff --git a/text-utils/parse.c b/text-utils/parse.c index 26925d971..0584e022c 100644 --- a/text-utils/parse.c +++ b/text-utils/parse.c @@ -55,7 +55,7 @@ FU *endfu; /* format at end-of-data */ void addfile(char *name) { - char *p; + unsigned char *p; FILE *fp; int ch; char buf[2048 + 1]; @@ -63,85 +63,93 @@ void addfile(char *name) if ((fp = fopen(name, "r")) == NULL) err(EXIT_FAILURE, _("can't read %s"), name); while (fgets(buf, sizeof(buf), fp)) { - if ((p = strchr(buf, '\n')) == NULL) { + if ((p = (unsigned char *)strchr(buf, '\n')) == NULL) { warnx(_("line too long")); while ((ch = getchar()) != '\n' && ch != EOF); continue; } *p = '\0'; - for (p = buf; *p && isspace((unsigned char)*p); ++p); + for (p = (unsigned char *)buf; *p && isspace(*p); ++p); if (!*p || *p == '#') continue; - add(p); + add((char *)p); } - (void)fclose(fp); + fclose(fp); } void add(const char *fmt) { - const char *p; - static FS **nextfs = NULL; + const unsigned char *p; FS *tfs; - FU *tfu, **nextfu; - const char *savep; + FU *tfu; + const unsigned char *savep; /* Start new linked list of format units. */ tfs = xcalloc(1, sizeof(FS)); - if (!fshead) - fshead = tfs; - else if (nextfs) - *nextfs = tfs; + INIT_LIST_HEAD(&tfs->nextfs); + INIT_LIST_HEAD(&tfs->nextfu); + list_add_tail(&tfs->nextfs, &fshead); - nextfs = &tfs->nextfs; - nextfu = &tfs->nextfu; + //entry_list here /* Take the format string and break it up into format units. */ - for (p = fmt;;) { + p = (unsigned char *)fmt; + while (TRUE) { /* Skip leading white space. */ - for (; isspace((unsigned char)*p); ++p); + while (isspace(*p) && ++p) + ; if (!*p) break; /* Allocate a new format unit and link it in. */ tfu = xcalloc(1, sizeof(FU)); - *nextfu = tfu; - nextfu = &tfu->nextfu; + INIT_LIST_HEAD(&tfu->nextfu); + INIT_LIST_HEAD(&tfu->nextpr); + list_add_tail(&tfu->nextfu, &tfs->nextfu); tfu->reps = 1; /* If leading digit, repetition count. */ - if (isdigit((unsigned char)*p)) { - for (savep = p; isdigit((unsigned char)*p); ++p); - if (!isspace((unsigned char)*p) && *p != '/') + if (isdigit(*p)) { + savep = p; + while (isdigit(*p) && ++p) + ; + if (!isspace(*p) && *p != '/') badfmt(fmt); /* may overwrite either white space or slash */ - tfu->reps = atoi(savep); + tfu->reps = atoi((char *)savep); tfu->flags = F_SETREP; /* skip trailing white space */ - for (++p; isspace((unsigned char)*p); ++p); + while (++p && isspace(*p)) //correct? + ; } /* Skip slash and trailing white space. */ if (*p == '/') - while (isspace((unsigned char)*++p)); + while (isspace(*++p)) + ; /* byte count */ - if (isdigit((unsigned char)*p)) { - for (savep = p; isdigit((unsigned char)*p); ++p); - if (!isspace((unsigned char)*p)) + if (isdigit(*p)) { + savep = p; + while (isdigit(*p) && ++p) + ; + if (!isspace(*p)) badfmt(fmt); - tfu->bcnt = atoi(savep); + tfu->bcnt = atoi((char *)savep); /* skip trailing white space */ - for (++p; isspace((unsigned char)*p); ++p); + while (++p && isspace(*p)) //correct? + ; } /* format */ if (*p != '"') badfmt(fmt); - for (savep = ++p; *p != '"';) + savep = ++p; + while (*p != '"') if (*p++ == 0) badfmt(fmt); tfu->fmt = xmalloc(p - savep + 1); - (void) strncpy(tfu->fmt, savep, p - savep); + strncpy(tfu->fmt, (char *)savep, p - savep); tfu->fmt[p - savep] = '\0'; escape(tfu->fmt); p++; @@ -153,27 +161,34 @@ static const char *spec = ".#-+ 0123456789"; int block_size(FS *fs) { FU *fu; - int bcnt, cursize; - char *fmt; + int bcnt, cursize = 0; + unsigned char *fmt; + struct list_head *p; int prec; /* figure out the data block size needed for each format unit */ - for (cursize = 0, fu = fs->nextfu; fu; fu = fu->nextfu) { + list_for_each (p, &fs->nextfu) { + fu = list_entry(p, FU, nextfu); if (fu->bcnt) { cursize += fu->bcnt * fu->reps; continue; } - for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) { - if (*fmt != '%') + bcnt = prec = 0; + fmt = (unsigned char *)fu->fmt; + while (*fmt) { + if (*fmt != '%') { + ++fmt; continue; + } /* * skip any special chars -- save precision in * case it's a %s format. */ while (strchr(spec + 1, *++fmt)); - if (*fmt == '.' && isdigit((unsigned char)*++fmt)) { - prec = atoi(fmt); - while (isdigit((unsigned char)*++fmt)); + if (*fmt == '.' && isdigit(*++fmt)) { + prec = atoi((char *)fmt); + while (isdigit(*++fmt)) + ; } switch(*fmt) { case 'c': @@ -196,6 +211,7 @@ int block_size(FS *fs) break; } } + ++fmt; } cursize += bcnt * fu->reps; } @@ -205,26 +221,27 @@ int block_size(FS *fs) void rewrite(FS *fs) { enum { NOTOKAY, USEBCNT, USEPREC } sokay; - PR *pr, **nextpr; + PR *pr; FU *fu; + struct list_head *p, *q; char *p1, *p2; char savech, *fmtp, cs[3]; int nconv, prec; - nextpr = NULL; prec = 0; - for (fu = fs->nextfu; fu; fu = fu->nextfu) { + list_for_each (p, &fs->nextfu) { + fu = list_entry(p, FU, nextfu); /* * Break each format unit into print units; each * conversion character gets its own. */ - for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) { + nconv = 0; + fmtp = fu->fmt; + while (*fmtp) { pr = xcalloc(1, sizeof(PR)); - if (!fu->nextpr) - fu->nextpr = pr; - else if (nextpr) - *nextpr = pr; + INIT_LIST_HEAD(&pr->nextpr); + list_add_tail(&pr->nextpr, &fu->nextpr); /* Skip preceding text and up to the next % sign. */ for (p1 = fmtp; *p1 && *p1 != '%'; ++p1); @@ -286,17 +303,14 @@ isint: cs[2] = '\0'; cs[1] = cs[0]; cs[0] = 'q'; switch(fu->bcnt) { - case 0: case 4: + case 0: pr->bcnt = 4; break; case 1: - pr->bcnt = 1; - break; case 2: - pr->bcnt = 2; - break; + case 4: case 8: - pr->bcnt = 8; + pr->bcnt = fu->bcnt; break; default: p1[1] = '\0'; @@ -306,11 +320,12 @@ isint: cs[2] = '\0'; case 'e': case 'E': case 'f': case 'g': case 'G': pr->flags = F_DBL; switch(fu->bcnt) { - case 0: case 8: + case 0: pr->bcnt = 8; break; case 4: - pr->bcnt = 4; + case 8: + pr->bcnt = fu->bcnt; break; default: p1[1] = '\0'; @@ -404,8 +419,8 @@ isint2: switch(fu->bcnt) { * so can adjust rep count later. */ if (!fu->bcnt) - for (pr = fu->nextpr; pr; pr = pr->nextpr) - fu->bcnt += pr->bcnt; + list_for_each(q, &fu->nextpr) + fu->bcnt += (list_entry(q, PR, nextpr))->bcnt; } /* * If the format string interprets any data at all, and it's @@ -416,17 +431,16 @@ isint2: switch(fu->bcnt) { * If rep count is greater than 1, no trailing whitespace * gets output from the last iteration of the format unit. */ - for (fu = fs->nextfu; fu; fu = fu->nextfu) { - if (!fu->nextfu && fs->bcnt < blocksize && + list_for_each (p, &fs->nextfu) { + fu = list_entry(p, FU, nextfu); + if (list_entry_is_last(&fu->nextfu, &fs->nextfu) && fs->bcnt < blocksize && !(fu->flags&F_SETREP) && fu->bcnt) fu->reps += (blocksize - fs->bcnt) / fu->bcnt; if (fu->reps > 1) { - if (fu->nextpr) { - for (pr = fu->nextpr; ; pr = pr->nextpr) - if (!pr->nextpr) - break; + if (!list_empty(&fu->nextpr)) { + pr = list_last_entry(&fu->nextpr, PR, nextpr); for (p1 = pr->fmt, p2 = NULL; *p1; ++p1) - p2 = isspace((unsigned char)*p1) ? p1 : NULL; + p2 = isspace(*p1) ? p1 : NULL; if (p2) pr->nospace = p2; } |