Edit
IABSD.fr/src/usr.bin/sort/file.c
jsg
- usr.bin/sort/file.c
-
/* $OpenBSD: file.c,v 1.24 2024/09/20 02:00:46 jsg Exp $ */ /*- * Copyright (C) 2009 Gabor Kovesdan <gabor@FreeBSD.org> * Copyright (C) 2012 Oleg Moskalenko <mom040267@gmail.com> * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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/mman.h> #include <sys/stat.h> #include <sys/types.h> #include <sys/queue.h> #include <err.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <string.h> #include <unistd.h> #include <wchar.h> #include <wctype.h> #include "coll.h" #include "file.h" #include "radixsort.h" unsigned long long available_free_memory = 1000000; bool use_mmap; const char *tmpdir = "/tmp"; const char *compress_program; size_t max_open_files = 16; /* * How much space we read from file at once */ #define READ_CHUNK 4096 /* * File reader structure */ struct file_reader { struct reader_buffer rb; FILE *file; char *fname; unsigned char *buffer; unsigned char *mmapaddr; unsigned char *mmapptr; size_t bsz; size_t cbsz; size_t mmapsize; size_t strbeg; char elsymb; }; /* * Structure to be used in file merge process. */ struct file_header { struct file_reader *fr; struct sort_list_item *si; /* current top line */ size_t file_pos; }; /* * List elements of "cleanable" files list. */ struct CLEANABLE_FILE { char *fn; LIST_ENTRY(CLEANABLE_FILE) files; }; /* * List header of "cleanable" files list. */ static LIST_HEAD(CLEANABLE_FILES, CLEANABLE_FILE) tmp_files; /* * Init tmp files list */ void init_tmp_files(void) { LIST_INIT(&tmp_files); } /* * Save name of a tmp file for signal cleanup */ void tmp_file_atexit(const char *tmp_file) { struct CLEANABLE_FILE *item; sigset_t mask, oldmask; item = sort_malloc(sizeof(struct CLEANABLE_FILE)); item->fn = sort_strdup(tmp_file); sigfillset(&mask); sigprocmask(SIG_BLOCK, &mask, &oldmask); LIST_INSERT_HEAD(&tmp_files, item, files); sigprocmask(SIG_SETMASK, &oldmask, NULL); } /* * Clear tmp files */ void clear_tmp_files(void) { struct CLEANABLE_FILE *item; LIST_FOREACH(item, &tmp_files, files) { if (item != NULL && item->fn != NULL) unlink(item->fn); } } /* * Check whether a file is a temporary file */ static bool file_is_tmp(const char *fn) { struct CLEANABLE_FILE *item; LIST_FOREACH(item, &tmp_files, files) { if (item->fn != NULL && strcmp(item->fn, fn) == 0) return true; } return false; } /* * Generate new temporary file name */ char * new_tmp_file_name(void) { char *ret; int fd; sort_asprintf(&ret, "%s/.bsdsort.XXXXXXXXXX", tmpdir); if ((fd = mkstemp(ret)) == -1) err(2, "%s", ret); close(fd); tmp_file_atexit(ret); return ret; } /* * Initialize file list */ void file_list_init(struct file_list *fl, bool tmp) { fl->count = 0; fl->sz = 0; fl->fns = NULL; fl->tmp = tmp; } /* * Add a file name to the list */ void file_list_add(struct file_list *fl, char *fn, bool allocate) { if (fl->count >= fl->sz) { fl->fns = sort_reallocarray(fl->fns, fl->sz ? fl->sz : (fl->sz = 1), 2 * sizeof(char *)); fl->sz *= 2; } fl->fns[fl->count] = allocate ? sort_strdup(fn) : fn; fl->count += 1; } /* * Populate file list from array of file names */ void file_list_populate(struct file_list *fl, int argc, char **argv, bool allocate) { int i; for (i = 0; i < argc; i++) file_list_add(fl, argv[i], allocate); } /* * Clean file list data and delete the files, * if this is a list of temporary files */ void file_list_clean(struct file_list *fl) { if (fl->fns) { size_t i; for (i = 0; i < fl->count; i++) { if (fl->fns[i]) { if (fl->tmp) unlink(fl->fns[i]); sort_free(fl->fns[i]); fl->fns[i] = NULL; } } sort_free(fl->fns); fl->fns = NULL; } fl->sz = 0; fl->count = 0; fl->tmp = false; } /* * Init sort list */ void sort_list_init(struct sort_list *l) { l->count = 0; l->size = 0; l->memsize = sizeof(struct sort_list); l->list = NULL; } /* * Add string to sort list */ void sort_list_add(struct sort_list *l, struct bwstring *str) { size_t indx = l->count; if ((l->list == NULL) || (indx >= l->size)) { size_t newsize = (l->size + 1) + 1024; l->list = sort_reallocarray(l->list, newsize, sizeof(struct sort_list_item *)); l->memsize += (newsize - l->size) * sizeof(struct sort_list_item *); l->size = newsize; } l->list[indx] = sort_list_item_alloc(); sort_list_item_set(l->list[indx], str); l->memsize += sort_list_item_size(l->list[indx]); l->count += 1; } /* * Clean sort list data */ void sort_list_clean(struct sort_list *l) { if (l->list) { size_t i; for (i = 0; i < l->count; i++) { struct sort_list_item *item; item = l->list[i]; if (item) { sort_list_item_clean(item); sort_free(item); l->list[i] = NULL; } } sort_free(l->list); l->list = NULL; } l->count = 0; l->size = 0; l->memsize = sizeof(struct sort_list); } /* * Write sort list to file */ void sort_list_dump(struct sort_list *l, const char *fn) { FILE *f; f = openfile(fn, "w"); if (f == NULL) err(2, "%s", fn); if (l->list) { size_t i; if (!sort_opts_vals.uflag) { for (i = 0; i < l->count; ++i) bwsfwrite(l->list[i]->str, f, sort_opts_vals.zflag); } else { struct sort_list_item *last_printed_item = NULL; struct sort_list_item *item; for (i = 0; i < l->count; ++i) { item = l->list[i]; if ((last_printed_item == NULL) || list_coll(&last_printed_item, &item)) { bwsfwrite(item->str, f, sort_opts_vals.zflag); last_printed_item = item; } } } } closefile(f, fn); } /* * Checks if the given file is sorted. Stops at the first disorder, * prints the disordered line and returns 1. */ int check(const char *fn) { struct bwstring *s1, *s2; struct file_reader *fr; struct keys_array *ka1, *ka2; int res; size_t pos, posdisorder; s1 = s2 = NULL; ka1 = ka2 = NULL; fr = file_reader_init(fn); res = 0; pos = 1; posdisorder = 1; if (fr == NULL) err(2, "%s", fn); s1 = file_reader_readline(fr); if (s1 == NULL) goto end; ka1 = keys_array_alloc(); preproc(s1, ka1); s2 = file_reader_readline(fr); if (s2 == NULL) goto end; ka2 = keys_array_alloc(); preproc(s2, ka2); for (;;) { if (debug_sort) { bwsprintf(stdout, s2, "s1=<", ">"); bwsprintf(stdout, s1, "s2=<", ">"); } int cmp = key_coll(ka2, ka1, 0); if (debug_sort) printf("; cmp1=%d", cmp); if (!cmp && sort_opts_vals.complex_sort && !(sort_opts_vals.uflag) && !(sort_opts_vals.sflag) && !(sort_opts_vals.kflag)) { cmp = top_level_str_coll(s2, s1); if (debug_sort) printf("; cmp2=%d", cmp); } if (debug_sort) printf("\n"); if ((sort_opts_vals.uflag && (cmp <= 0)) || (cmp < 0)) { if (!(sort_opts_vals.csilentflag)) { bws_disorder_warnx(s2, fn, posdisorder); posdisorder = pos; if (debug_sort) bws_disorder_warnx(s1, fn, posdisorder); } res = 1; goto end; } pos++; clean_keys_array(s1, ka1); sort_free(ka1); ka1 = ka2; ka2 = NULL; bwsfree(s1); s1 = s2; s2 = file_reader_readline(fr); if (s2 == NULL) goto end; ka2 = keys_array_alloc(); preproc(s2, ka2); } end: if (ka1) { clean_keys_array(s1, ka1); sort_free(ka1); } bwsfree(s1); if (ka2) { clean_keys_array(s2, ka2); sort_free(ka2); } bwsfree(s2); if (fn == NULL || *fn == 0 || strcmp(fn, "-") == 0) { for (;;) { s2 = file_reader_readline(fr); if (s2 == NULL) break; bwsfree(s2); } } file_reader_free(fr); return res; } /* * Opens a file. If the given filename is "-", stdout will be * opened. */ FILE * openfile(const char *fn, const char *mode) { FILE *file; if (strcmp(fn, "-") == 0) return (mode[0] == 'r') ? stdin : stdout; if (file_is_tmp(fn) && (compress_program != NULL)) { char *cmd; fflush(stdout); if (mode[0] == 'r') sort_asprintf(&cmd, "%s -d < %s", compress_program, fn); else if (mode[0] == 'w') sort_asprintf(&cmd, "%s > %s", compress_program, fn); else err(2, "invalid file mode"); if ((file = popen(cmd, mode)) == NULL) err(2, "%s", compress_program); sort_free(cmd); } else if ((file = fopen(fn, mode)) == NULL) err(2, "%s", fn); return file; } /* * Close file */ void closefile(FILE *f, const char *fn) { if (f == NULL) { ; } else if (f == stdin) { ; } else if (f == stdout) { fflush(f); } else { if (file_is_tmp(fn) && compress_program != NULL) { if (pclose(f) < 0) err(2, NULL); } else fclose(f); } } /* * Reads a file into the internal buffer. */ struct file_reader * file_reader_init(const char *fsrc) { struct file_reader *ret; if (fsrc == NULL) fsrc = "-"; ret = sort_calloc(1, sizeof(struct file_reader)); ret->elsymb = '\n'; if (sort_opts_vals.zflag) ret->elsymb = 0; ret->fname = sort_strdup(fsrc); if (strcmp(fsrc, "-") && (compress_program == NULL) && use_mmap) { struct stat stat_buf; void *addr; size_t sz = 0; int fd; fd = open(fsrc, O_RDONLY); if (fd < 0) err(2, "%s", fsrc); if (fstat(fd, &stat_buf) < 0) err(2, "%s", fsrc); sz = stat_buf.st_size; addr = mmap(NULL, sz, PROT_READ, 0, fd, 0); close(fd); if (addr != MAP_FAILED) { ret->mmapaddr = addr; ret->mmapsize = sz; ret->mmapptr = ret->mmapaddr; posix_madvise(addr, sz, POSIX_MADV_SEQUENTIAL); } } if (ret->mmapaddr == NULL) { ret->file = openfile(fsrc, "r"); if (ret->file == NULL) err(2, "%s", fsrc); if (strcmp(fsrc, "-")) { ret->cbsz = READ_CHUNK; ret->buffer = sort_malloc(ret->cbsz); ret->bsz = 0; ret->strbeg = 0; ret->bsz = fread(ret->buffer, 1, ret->cbsz, ret->file); if (ret->bsz == 0) { if (ferror(ret->file)) err(2, NULL); } } } return ret; } struct bwstring * file_reader_readline(struct file_reader *fr) { struct bwstring *ret = NULL; if (fr->mmapaddr) { unsigned char *mmapend; mmapend = fr->mmapaddr + fr->mmapsize; if (fr->mmapptr >= mmapend) return NULL; else { unsigned char *strend; size_t sz; sz = mmapend - fr->mmapptr; strend = memchr(fr->mmapptr, fr->elsymb, sz); if (strend == NULL) { ret = bwscsbdup(fr->mmapptr, sz); fr->mmapptr = mmapend; } else { ret = bwscsbdup(fr->mmapptr, strend - fr->mmapptr); fr->mmapptr = strend + 1; } } } else if (fr->file != stdin) { unsigned char *strend; size_t bsz1, remsz, search_start; search_start = 0; remsz = 0; strend = NULL; if (fr->bsz > fr->strbeg) remsz = fr->bsz - fr->strbeg; /* line read cycle */ for (;;) { if (remsz > search_start) strend = memchr(fr->buffer + fr->strbeg + search_start, fr->elsymb, remsz - search_start); else strend = NULL; if (strend) break; if (feof(fr->file)) break; if (fr->bsz != fr->cbsz) /* NOTREACHED */ err(2, "File read software error 1"); if (remsz > (READ_CHUNK >> 1)) { search_start = fr->cbsz - fr->strbeg; fr->cbsz += READ_CHUNK; fr->buffer = sort_reallocarray(fr->buffer, 1, fr->cbsz); bsz1 = fread(fr->buffer + fr->bsz, 1, READ_CHUNK, fr->file); if (bsz1 == 0) { if (ferror(fr->file)) err(2, NULL); break; } fr->bsz += bsz1; remsz += bsz1; } else { if (remsz > 0 && fr->strbeg > 0) { memmove(fr->buffer, fr->buffer + fr->strbeg, remsz); } fr->strbeg = 0; search_start = remsz; bsz1 = fread(fr->buffer + remsz, 1, fr->cbsz - remsz, fr->file); if (bsz1 == 0) { if (ferror(fr->file)) err(2, NULL); break; } fr->bsz = remsz + bsz1; remsz = fr->bsz; } } if (strend == NULL) strend = fr->buffer + fr->bsz; if ((fr->buffer + fr->strbeg <= strend) && (fr->strbeg < fr->bsz) && (remsz>0)) ret = bwscsbdup(fr->buffer + fr->strbeg, strend - fr->buffer - fr->strbeg); fr->strbeg = (strend - fr->buffer) + 1; } else { size_t len = 0; ret = bwsfgetln(fr->file, &len, sort_opts_vals.zflag, &(fr->rb)); } return ret; } static void file_reader_clean(struct file_reader *fr) { if (fr->mmapaddr) munmap(fr->mmapaddr, fr->mmapsize); sort_free(fr->buffer); if (fr->file) closefile(fr->file, fr->fname); sort_free(fr->fname); memset(fr, 0, sizeof(struct file_reader)); } void file_reader_free(struct file_reader *fr) { file_reader_clean(fr); sort_free(fr); } int procfile(const char *fsrc, struct sort_list *list, struct file_list *fl) { struct file_reader *fr; fr = file_reader_init(fsrc); if (fr == NULL) err(2, "%s", fsrc); /* file browse cycle */ for (;;) { struct bwstring *bws; bws = file_reader_readline(fr); if (bws == NULL) break; sort_list_add(list, bws); if (list->memsize >= available_free_memory) { char *fn; fn = new_tmp_file_name(); sort_list_to_file(list, fn); file_list_add(fl, fn, false); sort_list_clean(list); } } file_reader_free(fr); return 0; } /* * Compare file headers. Files with EOF always go to the end of the list. */ static int file_header_cmp(struct file_header *f1, struct file_header *f2) { int ret; if (f1 == f2) return 0; if (f1->fr == NULL) return (f2->fr == NULL) ? 0 : 1; if (f2->fr == NULL) return -1; ret = list_coll(&(f1->si), &(f2->si)); if (!ret) return (f1->file_pos < f2->file_pos) ? -1 : 1; return ret; } /* * Allocate and init file header structure */ static void file_header_init(struct file_header **fh, const char *fn, size_t file_pos) { struct bwstring *line; *fh = sort_malloc(sizeof(struct file_header)); (*fh)->file_pos = file_pos; (*fh)->fr = file_reader_init(fn); if ((*fh)->fr == NULL) { err(2, "Cannot open %s for reading", strcmp(fn, "-") == 0 ? "stdin" : fn); } line = file_reader_readline((*fh)->fr); if (line == NULL) { file_reader_free((*fh)->fr); (*fh)->fr = NULL; (*fh)->si = NULL; } else { (*fh)->si = sort_list_item_alloc(); sort_list_item_set((*fh)->si, line); } } /* * Close file */ static void file_header_close(struct file_header **fh) { if ((*fh)->fr) { file_reader_free((*fh)->fr); (*fh)->fr = NULL; } if ((*fh)->si) { sort_list_item_clean((*fh)->si); sort_free((*fh)->si); (*fh)->si = NULL; } sort_free(*fh); *fh = NULL; } /* * Swap two array elements */ static void file_header_swap(struct file_header **fh, size_t i1, size_t i2) { struct file_header *tmp; tmp = fh[i1]; fh[i1] = fh[i2]; fh[i2] = tmp; } /* heap algorithm ==>> */ /* * See heap sort algorithm * "Raises" last element to its right place */ static void file_header_heap_swim(struct file_header **fh, size_t indx) { if (indx > 0) { size_t parent_index; parent_index = (indx - 1) >> 1; if (file_header_cmp(fh[indx], fh[parent_index]) < 0) { /* swap child and parent and continue */ file_header_swap(fh, indx, parent_index); file_header_heap_swim(fh, parent_index); } } } /* * Sink the top element to its correct position */ static void file_header_heap_sink(struct file_header **fh, size_t indx, size_t size) { size_t left_child_index; size_t right_child_index; left_child_index = indx + indx + 1; right_child_index = left_child_index + 1; if (left_child_index < size) { size_t min_child_index; min_child_index = left_child_index; if ((right_child_index < size) && (file_header_cmp(fh[left_child_index], fh[right_child_index]) > 0)) min_child_index = right_child_index; if (file_header_cmp(fh[indx], fh[min_child_index]) > 0) { file_header_swap(fh, indx, min_child_index); file_header_heap_sink(fh, min_child_index, size); } } } /* <<== heap algorithm */ /* * Adds element to the "left" end */ static void file_header_list_rearrange_from_header(struct file_header **fh, size_t size) { file_header_heap_sink(fh, 0, size); } /* * Adds element to the "right" end */ static void file_header_list_push(struct file_header *f, struct file_header **fh, size_t size) { fh[size++] = f; file_header_heap_swim(fh, size - 1); } struct last_printed { struct bwstring *str; }; /* * Prints the current line of the file */ static void file_header_print(struct file_header *fh, FILE *f_out, struct last_printed *lp) { if (sort_opts_vals.uflag) { if ((lp->str == NULL) || (str_list_coll(lp->str, &(fh->si)))) { bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag); if (lp->str) bwsfree(lp->str); lp->str = bwsdup(fh->si->str); } } else bwsfwrite(fh->si->str, f_out, sort_opts_vals.zflag); } /* * Read next line */ static void file_header_read_next(struct file_header *fh) { struct bwstring *tmp; tmp = file_reader_readline(fh->fr); if (tmp == NULL) { file_reader_free(fh->fr); fh->fr = NULL; if (fh->si) { sort_list_item_clean(fh->si); sort_free(fh->si); fh->si = NULL; } } else { if (fh->si == NULL) fh->si = sort_list_item_alloc(); sort_list_item_set(fh->si, tmp); } } /* * Merge array of "files headers" */ static void file_headers_merge(size_t fnum, struct file_header **fh, FILE *f_out) { struct last_printed lp; size_t i; memset(&lp, 0, sizeof(lp)); /* * construct the initial sort structure */ for (i = 0; i < fnum; i++) file_header_list_push(fh[i], fh, i); while (fh[0]->fr) { /* unfinished files are always in front */ /* output the smallest line: */ file_header_print(fh[0], f_out, &lp); /* read a new line, if possible: */ file_header_read_next(fh[0]); /* re-arrange the list: */ file_header_list_rearrange_from_header(fh, fnum); } if (lp.str) bwsfree(lp.str); } /* * Merges the given files into the output file, which can be * stdout. */ static void merge_files_array(size_t argc, char **argv, const char *fn_out) { struct file_header **fh; FILE *f_out; size_t i; f_out = openfile(fn_out, "w"); if (f_out == NULL) err(2, "%s", fn_out); fh = sort_reallocarray(NULL, argc + 1, sizeof(struct file_header *)); for (i = 0; i < argc; i++) file_header_init(fh + i, argv[i], i); file_headers_merge(argc, fh, f_out); for (i = 0; i < argc; i++) file_header_close(fh + i); sort_free(fh); closefile(f_out, fn_out); } /* * Shrinks the file list until its size smaller than max number of opened files */ static int shrink_file_list(struct file_list *fl) { struct file_list new_fl; size_t indx = 0; if (fl->count < max_open_files) return 0; file_list_init(&new_fl, true); while (indx < fl->count) { char *fnew; size_t num; num = fl->count - indx; fnew = new_tmp_file_name(); if (num >= max_open_files) num = max_open_files - 1; merge_files_array(num, fl->fns + indx, fnew); if (fl->tmp) { size_t i; for (i = 0; i < num; i++) unlink(fl->fns[indx + i]); } file_list_add(&new_fl, fnew, false); indx += num; } fl->tmp = false; /* already taken care of */ file_list_clean(fl); fl->count = new_fl.count; fl->fns = new_fl.fns; fl->sz = new_fl.sz; fl->tmp = new_fl.tmp; return 1; } /* * Merge list of files */ void merge_files(struct file_list *fl, const char *fn_out) { while (shrink_file_list(fl)) ; merge_files_array(fl->count, fl->fns, fn_out); } static const char * get_sort_method_name(int sm) { if (sm == SORT_MERGESORT) return "mergesort"; else if (sort_opts_vals.sort_method == SORT_RADIXSORT) return "radixsort"; else if (sort_opts_vals.sort_method == SORT_HEAPSORT) return "heapsort"; else return "quicksort"; } /* * Sort list of lines and writes it to the file */ void sort_list_to_file(struct sort_list *list, const char *outfile) { struct sort_mods *sm = &(keys[0].sm); if (!sm->Mflag && !sm->Rflag && !sm->Vflag && !sm->gflag && !sm->hflag && !sm->nflag) { if (sort_opts_vals.sort_method == SORT_DEFAULT && sort_mb_cur_max == 1) sort_opts_vals.sort_method = SORT_RADIXSORT; } else if (sort_opts_vals.sort_method == SORT_RADIXSORT) err(2, "Radix sort cannot be used with these sort options"); /* * To handle stable sort and the unique cases in the * right order, we need to use a stable algorithm. */ if (sort_opts_vals.sflag) { switch (sort_opts_vals.sort_method){ case SORT_MERGESORT: break; case SORT_RADIXSORT: break; case SORT_DEFAULT: sort_opts_vals.sort_method = SORT_MERGESORT; break; default: errx(2, "The chosen sort method cannot be used with " "stable and/or unique sort"); } } if (sort_opts_vals.sort_method == SORT_DEFAULT) sort_opts_vals.sort_method = DEFAULT_SORT_ALGORITHM; if (debug_sort) printf("sort_method=%s\n", get_sort_method_name(sort_opts_vals.sort_method)); switch (sort_opts_vals.sort_method){ case SORT_RADIXSORT: rxsort(list->list, list->count); break; case SORT_MERGESORT: mergesort(list->list, list->count, sizeof(struct sort_list_item *), list_coll); break; case SORT_HEAPSORT: heapsort(list->list, list->count, sizeof(struct sort_list_item *), list_coll); break; case SORT_QSORT: qsort(list->list, list->count, sizeof(struct sort_list_item *), list_coll); break; default: DEFAULT_SORT_FUNC(list->list, list->count, sizeof(struct sort_list_item *), list_coll); break; } sort_list_dump(list, outfile); }