Rename SIMPLEQ_* to STAILQ_* in /usr/src/usr.bin
Index: ctfconv/dw.c
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/dw.c,v
retrieving revision 1.4
diff -u -p -r1.4 dw.c
--- ctfconv/dw.c 27 Sep 2017 08:59:38 -0000 1.4
+++ ctfconv/dw.c 25 Dec 2020 16:23:20 -0000
@@ -372,7 +372,7 @@ dw_attr_parse(struct dwbuf *dwbuf, struc
return error;
}
- SIMPLEQ_INSERT_TAIL(davq, dav, dav_next);
+ STAILQ_INSERT_TAIL(davq, dav, dav_next);
return 0;
}
@@ -381,12 +381,12 @@ dw_attr_purge(struct dwaval_queue *davq)
{
struct dwaval *dav;
- while ((dav = SIMPLEQ_FIRST(davq)) != NULL) {
- SIMPLEQ_REMOVE_HEAD(davq, dav_next);
+ while ((dav = STAILQ_FIRST(davq)) != NULL) {
+ STAILQ_REMOVE_HEAD(davq, dav_next);
pfree(&dav_pool, dav);
}
- SIMPLEQ_INIT(davq);
+ STAILQ_INIT(davq);
}
static int
@@ -412,7 +412,7 @@ dw_die_parse(struct dwbuf *dwbuf, size_t
continue;
}
- SIMPLEQ_FOREACH(dab, dabq, dab_next) {
+ STAILQ_FOREACH(dab, dabq, dab_next) {
if (dab->dab_code == code)
break;
}
@@ -426,9 +426,9 @@ dw_die_parse(struct dwbuf *dwbuf, size_t
die->die_lvl = lvl;
die->die_dab = dab;
die->die_offset = doff;
- SIMPLEQ_INIT(&die->die_avals);
+ STAILQ_INIT(&die->die_avals);
- SIMPLEQ_FOREACH(dat, &dab->dab_attrs, dat_next) {
+ STAILQ_FOREACH(dat, &dab->dab_attrs, dat_next) {
error = dw_attr_parse(dwbuf, dat, psz, &die->die_avals);
if (error != 0) {
dw_attr_purge(&die->die_avals);
@@ -439,7 +439,7 @@ dw_die_parse(struct dwbuf *dwbuf, size_t
if (dab->dab_children == DW_CHILDREN_yes)
lvl++;
- SIMPLEQ_INSERT_TAIL(dieq, die, die_next);
+ STAILQ_INSERT_TAIL(dieq, die, die_next);
}
return 0;
@@ -450,13 +450,13 @@ dw_die_purge(struct dwdie_queue *dieq)
{
struct dwdie *die;
- while ((die = SIMPLEQ_FIRST(dieq)) != NULL) {
- SIMPLEQ_REMOVE_HEAD(dieq, die_next);
+ while ((die = STAILQ_FIRST(dieq)) != NULL) {
+ STAILQ_REMOVE_HEAD(dieq, die_next);
dw_attr_purge(&die->die_avals);
pfree(&die_pool, die);
}
- SIMPLEQ_INIT(dieq);
+ STAILQ_INIT(dieq);
}
int
@@ -484,9 +484,9 @@ dw_ab_parse(struct dwbuf *abseg, struct
dab->dab_code = code;
dab->dab_tag = tag;
dab->dab_children = children;
- SIMPLEQ_INIT(&dab->dab_attrs);
+ STAILQ_INIT(&dab->dab_attrs);
- SIMPLEQ_INSERT_TAIL(dabq, dab, dab_next);
+ STAILQ_INSERT_TAIL(dabq, dab, dab_next);
for (;;) {
struct dwattr *dat;
@@ -506,7 +506,7 @@ dw_ab_parse(struct dwbuf *abseg, struct
dat->dat_attr = attr;
dat->dat_form = form;
- SIMPLEQ_INSERT_TAIL(&dab->dab_attrs, dat, dat_next);
+ STAILQ_INSERT_TAIL(&dab->dab_attrs, dat, dat_next);
}
}
@@ -518,19 +518,19 @@ dw_dabq_purge(struct dwabbrev_queue *dab
{
struct dwabbrev *dab;
- while ((dab = SIMPLEQ_FIRST(dabq)) != NULL) {
+ while ((dab = STAILQ_FIRST(dabq)) != NULL) {
struct dwattr *dat;
- SIMPLEQ_REMOVE_HEAD(dabq, dab_next);
- while ((dat = SIMPLEQ_FIRST(&dab->dab_attrs)) != NULL) {
- SIMPLEQ_REMOVE_HEAD(&dab->dab_attrs, dat_next);
+ STAILQ_REMOVE_HEAD(dabq, dab_next);
+ while ((dat = STAILQ_FIRST(&dab->dab_attrs)) != NULL) {
+ STAILQ_REMOVE_HEAD(&dab->dab_attrs, dat_next);
pfree(&dat_pool, dat);
}
pfree(&dab_pool, dab);
}
- SIMPLEQ_INIT(dabq);
+ STAILQ_INIT(dabq);
}
int
@@ -599,8 +599,8 @@ dw_cu_parse(struct dwbuf *info, struct d
dcu->dcu_version = version;
dcu->dcu_abbroff = abbroff;
dcu->dcu_psize = psz;
- SIMPLEQ_INIT(&dcu->dcu_abbrevs);
- SIMPLEQ_INIT(&dcu->dcu_dies);
+ STAILQ_INIT(&dcu->dcu_abbrevs);
+ STAILQ_INIT(&dcu->dcu_dies);
error = dw_ab_parse(&abseg, &dcu->dcu_abbrevs);
if (error != 0) {
Index: ctfconv/dw.h
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/dw.h,v
retrieving revision 1.2
diff -u -p -r1.2 dw.h
--- ctfconv/dw.h 11 Aug 2017 14:58:56 -0000 1.2
+++ ctfconv/dw.h 25 Dec 2020 16:23:20 -0000
@@ -25,13 +25,13 @@ struct dwbuf {
};
struct dwattr {
- SIMPLEQ_ENTRY(dwattr) dat_next;
+ STAILQ_ENTRY(dwattr) dat_next;
uint64_t dat_attr;
uint64_t dat_form;
};
struct dwaval {
- SIMPLEQ_ENTRY(dwaval) dav_next;
+ STAILQ_ENTRY(dwaval) dav_next;
struct dwattr *dav_dat; /* corresponding attribute */
union {
struct dwbuf _buf;
@@ -55,27 +55,27 @@ struct dwaval {
#define dav_u8 AV._V._T._u8
};
-SIMPLEQ_HEAD(dwaval_queue, dwaval);
+STAILQ_HEAD(dwaval_queue, dwaval);
struct dwdie {
- SIMPLEQ_ENTRY(dwdie) die_next;
+ STAILQ_ENTRY(dwdie) die_next;
struct dwabbrev *die_dab;
size_t die_offset;
uint8_t die_lvl;
struct dwaval_queue die_avals;
};
-SIMPLEQ_HEAD(dwdie_queue, dwdie);
+STAILQ_HEAD(dwdie_queue, dwdie);
struct dwabbrev {
- SIMPLEQ_ENTRY(dwabbrev) dab_next;
+ STAILQ_ENTRY(dwabbrev) dab_next;
uint64_t dab_code;
uint64_t dab_tag;
uint8_t dab_children;
- SIMPLEQ_HEAD(, dwattr) dab_attrs;
+ STAILQ_HEAD(, dwattr) dab_attrs;
};
-SIMPLEQ_HEAD(dwabbrev_queue, dwabbrev);
+STAILQ_HEAD(dwabbrev_queue, dwabbrev);
struct dwcu {
uint64_t dcu_length;
Index: ctfconv/itype.h
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/itype.h,v
retrieving revision 1.5
diff -u -p -r1.5 itype.h
--- ctfconv/itype.h 11 Nov 2019 19:10:35 -0000 1.5
+++ ctfconv/itype.h 25 Dec 2020 16:23:20 -0000
@@ -36,7 +36,7 @@ struct itype {
TAILQ_ENTRY(itype) it_symb; /* itype: global queue of symbol */
RB_ENTRY(itype) it_node; /* itype: per-type tree of types */
- SIMPLEQ_HEAD(, itref) it_refs; /* itype: backpointing refs */
+ STAILQ_HEAD(, itref) it_refs; /* itype: backpointing refs */
TAILQ_HEAD(, imember) it_members;/* itype: members of struct/union */
@@ -83,7 +83,7 @@ struct imember {
* merging duplicated types.
*/
struct itref {
- SIMPLEQ_ENTRY(itref) ir_next;
+ STAILQ_ENTRY(itref) ir_next;
struct itype *ir_itp;
};
Index: ctfconv/parse.c
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/parse.c,v
retrieving revision 1.13
diff -u -p -r1.13 parse.c
--- ctfconv/parse.c 7 Nov 2019 13:42:54 -0000 1.13
+++ ctfconv/parse.c 25 Dec 2020 16:23:20 -0000
@@ -203,7 +203,7 @@ it_new(uint64_t index, size_t off, const
assert((name != NULL) || !(flags & (ITF_FUNC|ITF_OBJ)));
it = pmalloc(&it_pool, sizeof(*it));
- SIMPLEQ_INIT(&it->it_refs);
+ STAILQ_INIT(&it->it_refs);
TAILQ_INIT(&it->it_members);
it->it_off = off;
it->it_ref = ref;
@@ -258,7 +258,7 @@ it_merge(struct itype *fwd, struct itype
assert(fwd->it_flags & ITF_FORWARD);
assert(fwd->it_type == it->it_type);
assert(TAILQ_EMPTY(&fwd->it_members));
- assert(SIMPLEQ_EMPTY(&it->it_refs));
+ assert(STAILQ_EMPTY(&it->it_refs));
fwd->it_off = it->it_off;
fwd->it_ref = it->it_ref;
@@ -366,14 +366,14 @@ ir_add(struct itype *it, struct itype *t
{
struct itref *ir;
- SIMPLEQ_FOREACH(ir, &tmp->it_refs, ir_next) {
+ STAILQ_FOREACH(ir, &tmp->it_refs, ir_next) {
if (ir->ir_itp == it)
return;
}
ir = pmalloc(&ir_pool, sizeof(*ir));
ir->ir_itp = it;
- SIMPLEQ_INSERT_TAIL(&tmp->it_refs, ir, ir_next);
+ STAILQ_INSERT_TAIL(&tmp->it_refs, ir, ir_next);
}
void
@@ -381,8 +381,8 @@ ir_purge(struct itype *it)
{
struct itref *ir;
- while ((ir = SIMPLEQ_FIRST(&it->it_refs)) != NULL) {
- SIMPLEQ_REMOVE_HEAD(&it->it_refs, ir_next);
+ while ((ir = STAILQ_FIRST(&it->it_refs)) != NULL) {
+ STAILQ_REMOVE_HEAD(&it->it_refs, ir_next);
pfree(&ir_pool, ir);
}
}
@@ -548,10 +548,10 @@ cu_merge(struct dwcu *dcu, struct itype_
struct imember *im;
/* Substitute references */
- while ((ir = SIMPLEQ_FIRST(&old->it_refs)) != NULL) {
+ while ((ir = STAILQ_FIRST(&old->it_refs)) != NULL) {
it = ir->ir_itp;
- SIMPLEQ_REMOVE_HEAD(&old->it_refs, ir_next);
+ STAILQ_REMOVE_HEAD(&old->it_refs, ir_next);
pfree(&ir_pool, ir);
if (it->it_refp == old)
@@ -617,7 +617,7 @@ cu_parse(struct dwcu *dcu, struct itype_
assert(RB_EMPTY(cuot));
- SIMPLEQ_FOREACH(die, &dcu->dcu_dies, die_next) {
+ STAILQ_FOREACH(die, &dcu->dcu_dies, die_next) {
uint64_t tag = die->die_dab->dab_tag;
switch (tag) {
@@ -728,7 +728,7 @@ parse_base(struct dwdie *die, size_t psz
uint16_t encoding, enc = 0, bits = 0;
int type;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_encoding:
enc = dav2val(dav, psz);
@@ -810,7 +810,7 @@ parse_refers(struct dwdie *die, size_t p
const char *name = NULL;
size_t ref = 0, size = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -851,7 +851,7 @@ parse_array(struct dwdie *die, size_t ps
const char *name = NULL;
size_t ref = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -881,7 +881,7 @@ parse_enum(struct dwdie *die, size_t psz
const char *name = NULL;
size_t size = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_byte_size:
size = dav2val(dav, psz);
@@ -917,14 +917,14 @@ subparse_subrange(struct dwdie *die, siz
* This loop assumes that the children of a DIE are just
* after it on the list.
*/
- while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
+ while ((die = STAILQ_NEXT(die, die_next)) != NULL) {
uint64_t tag = die->die_dab->dab_tag;
size_t nelems = 0;
if (tag != DW_TAG_subrange_type)
break;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_count:
nelems = dav2val(dav, psz);
@@ -959,7 +959,7 @@ subparse_enumerator(struct dwdie *die, s
* This loop assumes that the children of a DIE are just
* after it on the list.
*/
- while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
+ while ((die = STAILQ_NEXT(die, die_next)) != NULL) {
uint64_t tag = die->die_dab->dab_tag;
size_t val = 0;
const char *name = NULL;
@@ -967,7 +967,7 @@ subparse_enumerator(struct dwdie *die, s
if (tag != DW_TAG_enumerator)
break;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -1004,7 +1004,7 @@ parse_struct(struct dwdie *die, size_t p
size_t size = 0;
int forward = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_declaration:
forward = dav2val(dav, psz);
@@ -1049,7 +1049,7 @@ subparse_member(struct dwdie *die, size_
* This loop assumes that the children of a DIE are just
* after it on the list.
*/
- while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
+ while ((die = STAILQ_NEXT(die, die_next)) != NULL) {
int64_t tag = die->die_dab->dab_tag;
name = NULL;
@@ -1072,7 +1072,7 @@ subparse_member(struct dwdie *die, size_
it->it_flags |= ITF_UNRES_MEMB;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -1126,7 +1126,7 @@ subparse_arguments(struct dwdie *die, si
* This loop assumes that the children of a DIE are after it
* on the list.
*/
- while ((die = SIMPLEQ_NEXT(die, die_next)) != NULL) {
+ while ((die = STAILQ_NEXT(die, die_next)) != NULL) {
uint64_t tag = die->die_dab->dab_tag;
if (tag == DW_TAG_unspecified_parameters) {
@@ -1157,7 +1157,7 @@ subparse_arguments(struct dwdie *die, si
it->it_flags |= ITF_UNRES_MEMB;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_type:
ref = dav2val(dav, psz);
@@ -1184,7 +1184,7 @@ parse_function(struct dwdie *die, size_t
const char *name = NULL;
size_t ref = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -1234,7 +1234,7 @@ parse_funcptr(struct dwdie *die, size_t
const char *name = NULL;
size_t ref = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_name:
name = dav2str(dav);
@@ -1272,7 +1272,7 @@ parse_variable(struct dwdie *die, size_t
size_t ref = 0;
int forward = 0, global = 0;
- SIMPLEQ_FOREACH(dav, &die->die_avals, dav_next) {
+ STAILQ_FOREACH(dav, &die->die_avals, dav_next) {
switch (dav->dav_dat->dat_attr) {
case DW_AT_declaration:
forward = dav2val(dav, psz);
Index: ctfconv/pool.c
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/pool.c,v
retrieving revision 1.3
diff -u -p -r1.3 pool.c
--- ctfconv/pool.c 29 Aug 2017 21:10:20 -0000 1.3
+++ ctfconv/pool.c 25 Dec 2020 16:23:20 -0000
@@ -36,7 +36,7 @@ struct pool_item {
SLIST_ENTRY(pool_item) pi_list;
};
-SIMPLEQ_HEAD(, pool) pool_head = SIMPLEQ_HEAD_INITIALIZER(pool_head);
+STAILQ_HEAD(, pool) pool_head = STAILQ_HEAD_INITIALIZER(pool_head);
void
pool_init(struct pool *pp, const char *name, size_t nmemb, size_t size)
@@ -50,7 +50,7 @@ pool_init(struct pool *pp, const char *n
pp->pr_nitems = 0;
pp->pr_nfree = 0;
- SIMPLEQ_INSERT_TAIL(&pool_head, pp, pr_list);
+ STAILQ_INSERT_TAIL(&pool_head, pp, pr_list);
}
void *
@@ -98,7 +98,7 @@ pool_dump(void)
{
struct pool *pp;
- SIMPLEQ_FOREACH(pp, &pool_head, pr_list)
+ STAILQ_FOREACH(pp, &pool_head, pr_list)
printf("%s: %zd items, %zd free\n", pp->pr_name, pp->pr_nitems,
pp->pr_nfree);
}
Index: ctfconv/pool.h
===================================================================
RCS file: /cvs/src/usr.bin/ctfconv/pool.h,v
retrieving revision 1.2
diff -u -p -r1.2 pool.h
--- ctfconv/pool.h 11 Aug 2017 14:58:56 -0000 1.2
+++ ctfconv/pool.h 25 Dec 2020 16:23:20 -0000
@@ -22,7 +22,7 @@
#ifndef NOPOOL
struct pool {
- SIMPLEQ_ENTRY(pool) pr_list; /* list of all pools */
+ STAILQ_ENTRY(pool) pr_list; /* list of all pools */
const char *pr_name; /* identifier */
SLIST_HEAD(, pool_item) pr_free; /* free list */
size_t pr_nmemb; /* # of items per allocation */
Index: paste/paste.c
===================================================================
RCS file: /cvs/src/usr.bin/paste/paste.c,v
retrieving revision 1.26
diff -u -p -r1.26 paste.c
--- paste/paste.c 4 Aug 2018 19:19:37 -0000 1.26
+++ paste/paste.c 25 Dec 2020 16:23:20 -0000
@@ -93,7 +93,7 @@ main(int argc, char *argv[])
}
struct list {
- SIMPLEQ_ENTRY(list) entries;
+ STAILQ_ENTRY(list) entries;
FILE *fp;
int cnt;
char *name;
@@ -102,7 +102,7 @@ struct list {
void
parallel(char **argv)
{
- SIMPLEQ_HEAD(, list) head = SIMPLEQ_HEAD_INITIALIZER(head);
+ STAILQ_HEAD(, list) head = STAILQ_HEAD_INITIALIZER(head);
struct list *lp;
char *line, *p;
size_t linesize;
@@ -121,7 +121,7 @@ parallel(char **argv)
err(1, "%s", p);
lp->cnt = cnt;
lp->name = p;
- SIMPLEQ_INSERT_TAIL(&head, lp, entries);
+ STAILQ_INSERT_TAIL(&head, lp, entries);
}
line = NULL;
@@ -129,7 +129,7 @@ parallel(char **argv)
for (opencnt = cnt; opencnt;) {
output = 0;
- SIMPLEQ_FOREACH(lp, &head, entries) {
+ STAILQ_FOREACH(lp, &head, entries) {
if (lp->fp == NULL) {
if (output && lp->cnt &&
(ch = delim[(lp->cnt - 1) % delimcnt]))
Index: sdiff/sdiff.c
===================================================================
RCS file: /cvs/src/usr.bin/sdiff/sdiff.c,v
retrieving revision 1.37
diff -u -p -r1.37 sdiff.c
--- sdiff/sdiff.c 28 Sep 2018 18:21:52 -0000 1.37
+++ sdiff/sdiff.c 25 Dec 2020 16:23:20 -0000
@@ -36,7 +36,7 @@
/* A single diff line. */
struct diffline {
- SIMPLEQ_ENTRY(diffline) diffentries;
+ STAILQ_ENTRY(diffline) diffentries;
char *left;
char div;
char *right;
@@ -58,7 +58,7 @@ static void prompt(const char *, const c
__dead static void usage(void);
static char *xfgets(FILE *);
-SIMPLEQ_HEAD(, diffline) diffhead = SIMPLEQ_HEAD_INITIALIZER(diffhead);
+STAILQ_HEAD(, diffline) diffhead = STAILQ_HEAD_INITIALIZER(diffhead);
size_t line_width; /* width of a line (two columns and divider) */
size_t width; /* width of each column */
size_t file1ln, file2ln; /* line number of file1 and file2 */
@@ -782,7 +782,7 @@ enqueue(char *left, char div, char *righ
diffp->left = left;
diffp->div = div;
diffp->right = right;
- SIMPLEQ_INSERT_TAIL(&diffhead, diffp, diffentries);
+ STAILQ_INSERT_TAIL(&diffhead, diffp, diffentries);
}
/*
@@ -873,11 +873,11 @@ processq(void)
char divc, *left, *right;
/* Don't process empty queue. */
- if (SIMPLEQ_EMPTY(&diffhead))
+ if (STAILQ_EMPTY(&diffhead))
return;
/* Remember the divider. */
- divc = SIMPLEQ_FIRST(&diffhead)->div;
+ divc = STAILQ_FIRST(&diffhead)->div;
left = NULL;
right = NULL;
@@ -885,7 +885,7 @@ processq(void)
* Go through set of diffs, concatenating each line in left or
* right column into two long strings, `left' and `right'.
*/
- SIMPLEQ_FOREACH(diffp, &diffhead, diffentries) {
+ STAILQ_FOREACH(diffp, &diffhead, diffentries) {
/*
* Print changed lines if -s was given,
* print all lines if -s was not given.
@@ -902,9 +902,9 @@ processq(void)
}
/* Empty queue and free each diff line and its elements. */
- while (!SIMPLEQ_EMPTY(&diffhead)) {
- diffp = SIMPLEQ_FIRST(&diffhead);
- SIMPLEQ_REMOVE_HEAD(&diffhead, diffentries);
+ while (!STAILQ_EMPTY(&diffhead)) {
+ diffp = STAILQ_FIRST(&diffhead);
+ STAILQ_REMOVE_HEAD(&diffhead, diffentries);
freediff(diffp);
}
@@ -951,10 +951,10 @@ static void
printc(FILE *file1, size_t file1end, FILE *file2, size_t file2end)
{
struct fileline {
- SIMPLEQ_ENTRY(fileline) fileentries;
+ STAILQ_ENTRY(fileline) fileentries;
char *line;
};
- SIMPLEQ_HEAD(, fileline) delqhead = SIMPLEQ_HEAD_INITIALIZER(delqhead);
+ STAILQ_HEAD(, fileline) delqhead = STAILQ_HEAD_INITIALIZER(delqhead);
/* Read lines to be deleted. */
for (; file1ln <= file1end; ++file1ln) {
@@ -969,11 +969,11 @@ printc(FILE *file1, size_t file1end, FIL
if (!(linep = malloc(sizeof(struct fileline))))
err(2, "printc");
linep->line = line1;
- SIMPLEQ_INSERT_TAIL(&delqhead, linep, fileentries);
+ STAILQ_INSERT_TAIL(&delqhead, linep, fileentries);
}
/* Process changed lines.. */
- for (; !SIMPLEQ_EMPTY(&delqhead) && file2ln <= file2end;
+ for (; !STAILQ_EMPTY(&delqhead) && file2ln <= file2end;
++file2ln) {
struct fileline *del;
char *add;
@@ -982,9 +982,9 @@ printc(FILE *file1, size_t file1end, FIL
if (!(add = xfgets(file2)))
errx(2, "error reading add in change");
- del = SIMPLEQ_FIRST(&delqhead);
+ del = STAILQ_FIRST(&delqhead);
enqueue(del->line, '|', add);
- SIMPLEQ_REMOVE_HEAD(&delqhead, fileentries);
+ STAILQ_REMOVE_HEAD(&delqhead, fileentries);
/*
* Free fileline structure but not its elements since
* they are queued up.
@@ -1006,12 +1006,12 @@ printc(FILE *file1, size_t file1end, FIL
processq();
/* Process remaining lines to delete. */
- while (!SIMPLEQ_EMPTY(&delqhead)) {
+ while (!STAILQ_EMPTY(&delqhead)) {
struct fileline *filep;
- filep = SIMPLEQ_FIRST(&delqhead);
+ filep = STAILQ_FIRST(&delqhead);
enqueue(filep->line, '<', NULL);
- SIMPLEQ_REMOVE_HEAD(&delqhead, fileentries);
+ STAILQ_REMOVE_HEAD(&delqhead, fileentries);
free(filep);
}
processq();
Index: vmstat/vmstat.c
===================================================================
RCS file: /cvs/src/usr.bin/vmstat/vmstat.c,v
retrieving revision 1.150
diff -u -p -r1.150 vmstat.c
--- vmstat/vmstat.c 28 Nov 2019 16:27:26 -0000 1.150
+++ vmstat/vmstat.c 25 Dec 2020 16:23:20 -0000
@@ -1027,14 +1027,14 @@ dopool_sysctl(void)
void
dopool_kvm(void)
{
- SIMPLEQ_HEAD(,pool) pool_head;
+ STAILQ_HEAD(,pool) pool_head;
struct pool pool, *pp = &pool;
struct kinfo_pool pi;
long total = 0, inuse = 0;
u_long addr;
kread(X_POOLHEAD, &pool_head, sizeof(pool_head));
- addr = (u_long)SIMPLEQ_FIRST(&pool_head);
+ addr = (u_long)STAILQ_FIRST(&pool_head);
while (addr != 0) {
char name[32];
@@ -1076,7 +1076,7 @@ dopool_kvm(void)
inuse += (pi.pr_nget - pi.pr_nput) * pi.pr_size;
total += pi.pr_npages * pi.pr_pgsize;
- addr = (u_long)SIMPLEQ_NEXT(pp, pr_poollist);
+ addr = (u_long)STAILQ_NEXT(pp, pr_poollist);
}
inuse /= 1024;
