remove dmake-only utils

Change-Id: Id0723277613cf1867b28dbd98c2249ff9ea73649

1 files changed, 0 insertions, 906 deletions

diff --git a/soltools/javadep/javadep.c b/soltools/javadep/javadep.c
deleted file mode 100644
index beaf393b509f..000000000000
--- a/soltools/javadep/javadep.c
+++ /dev/null
@@ -1,906 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * This file is part of the LibreOffice project.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This file incorporates work covered by the following license notice:
- *
- *   Licensed to the Apache Software Foundation (ASF) under one or more
- *   contributor license agreements. See the NOTICE file distributed
- *   with this work for additional information regarding copyright
- *   ownership. The ASF licenses this file to you under the Apache
- *   License, Version 2.0 (the "License"); you may not use this file
- *   except in compliance with the License. You may obtain a copy of
- *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
- */
-
-/* All Java Virtual Machine Specs are from
- * "The Java Virtual Machine Specification", T. Lindholm, F. Yellin
- * (JVMS)
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-#include <errno.h>
-#include <ctype.h>
-#include <limits.h>
-
-#if defined(UNX)
-#include <unistd.h>
-#include <netinet/in.h>     /* ntohl(), ntohs() */
-#elif defined(WNT)
-#include <io.h>
-#define access      _access
-#define vsnprintf   _vsnprintf
-#define CDECL       _cdecl
-#define F_OK        00
-#define PATH_MAX    _MAX_PATH
-#define ntohl(x)    ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
-                        (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
-
-#define ntohs(x)    ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))
-#endif
-
-/* max. length of line in response file */
-#define RES_FILE_BUF    65536
-
-struct file {
-    char *pname;
-    FILE *pfs;
-};
-
-struct growable {
-    int     ncur;
-    int     nmax;
-    char    **parray;
-};
-
-typedef struct file     file_t;
-typedef unsigned char   uint8;
-typedef unsigned short  uint16;
-typedef unsigned int    uint32;
-
-struct utf8 {
-    uint16  nlen;
-    void    *pdata;
-};
-
-typedef struct utf8     utf8_t;
-
-/* The contents of the Constant_pool is described in JVMS p. 93
- */
-enum {
-    CONSTANT_Class              = 7,
-    CONSTANT_Fieldref           = 9,
-    CONSTANT_Methodref          = 10,
-    CONSTANT_InterfaceMethodref = 11,
-    CONSTANT_String             = 8,
-    CONSTANT_Integer            = 3,
-    CONSTANT_Float              = 4,
-    CONSTANT_Long               = 5,
-    CONSTANT_Double             = 6,
-    CONSTANT_NameAndType        = 12,
-    CONSTANT_Utf8               = 1
-};
-
-enum { NGROW_INIT = 10, NGROW = 2 };
-
-static char     *pprogname  = "javadep";
-static char     csep        = ';';
-#if defined (UNX)
-#define CDECL
-static char     cpathsep    = '/';
-#elif defined (WNT)
-static char     cpathsep    = '\\';
-#endif
-static FILE     *pfsout     = NULL;
-static char     *pout_file  = NULL;
-
-
-/* prototypes */
-uint8   read_uint8(const file_t *pfile);
-uint16  read_uint16(const file_t *pfile);
-uint32  read_uint32(const file_t *pfile);
-void    skip_bytes(const file_t *pfile, const long nnum);
-char    *escape_slash(const char *pstr);
-int     is_inner(const char *pstr);
-void    print_dependencies(const struct growable *pdep,
-                           const char* pclass_file);
-void    process_class_file(const char *pfilenamem,
-                           const struct growable *pfilt);
-char    *utf8tolatin1(const utf8_t a_utf8);
-void    *xmalloc(size_t size);
-void    *xcalloc(size_t nmemb, size_t size);
-void    *xrealloc(void *ptr, size_t size);
-void    grow_if_needed (struct growable *pgrow);
-int     append_to_growable(struct growable *, char *);
-struct growable *allocate_growable(void);
-void    free_growable(struct growable *pgrowvoid);
-void    create_filters(struct growable *pfilt, const struct growable *pinc);
-void    usage(void);
-void    err_quit(const char *, ...);
-void    silent_quit(void);
-
-#ifdef WNT
-/* poor man's getopt() */
-int     simple_getopt(char *pargv[], const char *poptstring);
-char    *optarg = NULL;
-int     optind  = 1;
-int     optopt  = 0;
-int     opterr  = 0;
-#endif
-
-uint8
-read_uint8(const file_t *pfile)
-{
-    /* read a byte from classfile */
-    size_t nread;
-    uint8 ndata;
-    nread = fread(&ndata, sizeof(uint8), 1, pfile->pfs);
-    if ( !nread ) {
-        fclose(pfile->pfs);
-        err_quit("%s: truncated class file", pfile->pname);
-    }
-    return ndata;
-}
-
-uint16
-read_uint16(const file_t *pfile)
-{
-    /* read a short from classfile and convert it to host format */
-    size_t nread;
-    uint16 ndata;
-    nread = fread(&ndata, sizeof(uint16), 1, pfile->pfs);
-    if ( !nread ) {
-        fclose(pfile->pfs);
-        err_quit("%s: truncated class file", pfile->pname);
-    }
-    ndata = ntohs(ndata);
-    return ndata;
-}
-
-uint32
-read_uint32(const file_t *pfile)
-{
-    /* read an int from classfile and convert it to host format */
-    size_t nread;
-    uint32 ndata;
-    nread = fread(&ndata, sizeof(uint32), 1, pfile->pfs);
-    if ( !nread ) {
-        fclose(pfile->pfs);
-        err_quit("%s: truncated class file", pfile->pname);
-    }
-    ndata = ntohl(ndata);
-    return ndata;
-}
-
-utf8_t
-read_utf8(const file_t *pfile)
-{
-    /* Read a java utf-8-string with uint16 length prependend
-     * from class file. Returns utf8 struct
-     * with fresh allocated datablock,
-     * caller is responsible for freeing.
-     * Data is still in network byteorder
-     */
-
-    utf8_t  a_utf8;
-    size_t  nread;
-
-    a_utf8.pdata = NULL;
-
-    a_utf8.nlen = read_uint16(pfile);
-    if (a_utf8.nlen > 0) {
-        a_utf8.pdata = xmalloc(a_utf8.nlen*sizeof(char));
-        nread = fread(a_utf8.pdata, a_utf8.nlen*sizeof(char), 1, pfile->pfs);
-        if ( !nread ) {
-            fclose(pfile->pfs);
-            err_quit("%s: truncated class file", pfile->pname);
-        }
-    }
-
-    return a_utf8;
-}
-
-char *utf8tolatin1(const utf8_t a_utf8)
-{
-    /* function returns fresh allocated zero terminated string,
-     * caller is responsible for freeing
-     */
-
-    /* JVMS p. 101: the null byte is encoded using a two byte format,
-     * Java Virtual Machine Utf8 strings differ in this respect from
-     * standard UTF-8 strings
-     */
-
-    /* Multibyte data is in network byte order */
-
-    char *p;
-    char *pp;
-    char *pstr;
-
-    pstr = pp = xmalloc((a_utf8.nlen+1) * sizeof(char));
-
-    for ( p = (char*)a_utf8.pdata;
-          p <  (char*)a_utf8.pdata+a_utf8.nlen;
-          p++ ) {
-        if ( *p & 0x80 ) {
-            err_quit("sorry, real UTF8 decoding not yet implemented\n");
-        } else {
-            *pp++ = *p;
-        }
-    }
-    *pp = '\0';
-
-    return pstr;
-}
-
-
-void
-skip_bytes(const file_t *pfile, const long nnumber)
-{
-    /* skip a nnumber of bytes in classfile */
-    if ( fseek(pfile->pfs, nnumber, SEEK_CUR) == -1 )
-         err_quit("%s: %s", pfile->pname, strerror(errno));
-}
-
-void
-add_to_dependencies(struct growable *pdep,
-                    const struct growable *pfilt,
-                    char *pdepstr,
-                    const char *pclass_file)
-{
-    /* create dependencies */
-    int i;
-    size_t nlen_filt, nlen_str, nlen_pdepstr;
-    char *pstr, *ptrunc;
-    char path[PATH_MAX+1];
-    char cnp_class_file[PATH_MAX+1];
-    char cnp_str[PATH_MAX+1];
-
-    nlen_pdepstr = strlen(pdepstr);
-    pstr = xmalloc((nlen_pdepstr+6+1)*sizeof(char));
-    memcpy(pstr, pdepstr, nlen_pdepstr+1);
-    strncat(pstr, ".class", 6);
-
-    if ( pfilt->ncur == 0 ) { /* no filters */
-        if ( access(pstr, F_OK) == 0 ) {
-            append_to_growable(pdep, strdup(pstr));
-        }
-    } else {
-        nlen_str    = strlen(pstr);
-        for ( i = 0; i < pfilt->ncur; i++ ) {
-            nlen_filt   = strlen(pfilt->parray[i]);
-            if ( nlen_filt + 1 + nlen_str > PATH_MAX )
-                err_quit("path to long");
-            memcpy(path, pfilt->parray[i], nlen_filt);
-            path[nlen_filt]     = '/';
-            memcpy( path+nlen_filt+1, pstr, nlen_str+1);
-
-            if ( access(path, F_OK) != 0 ) {
-                free(pstr);
-                pstr = NULL;
-                return; /* path doesn't represent a real file, don't bother */
-            }
-
-            /* get the canonical path */
-#if defined (UNX)
-            if ( !(realpath(pclass_file, cnp_class_file)
-                && realpath(path, cnp_str) ) ) {
-                err_quit("can't get the canonical path");
-            }
-#else
-            if ( !(_fullpath(cnp_class_file, pclass_file, sizeof(cnp_class_file))
-                && _fullpath(cnp_str, path, sizeof(cnp_str)) ) ) {
-                err_quit("can't get the canonical path");
-            }
-#endif
-
-            /* truncate so that only the package prefix remains */
-            ptrunc = strrchr(cnp_str, cpathsep);
-            *ptrunc = '\0';
-            ptrunc = strrchr(cnp_class_file, cpathsep);
-            *ptrunc = '\0';
-
-            if ( !strcmp(cnp_str, cnp_class_file) ) {
-                free(pstr);
-                pstr = NULL;
-                return; /* identical, don't bother with this one */
-            }
-
-            append_to_growable(pdep, strdup(path));
-        }
-    }
-    free(pstr);
-    return;
-}
-
-char *
-escape_slash(const char *pstr)
-{
-    /* returns a fresh allocated string with all cpathsep escaped exchanged
-     * with "$/"
-     *
-     * caller is responsible for freeing
-     */
-
-    const char *pp = pstr;
-    char *p, *pnp;
-    char *pnew_str;
-    size_t nlen_pnp, nlen_pp;
-    int i = 0;
-
-    while ( (p=strchr(pp, cpathsep)) != NULL ) {
-        ++i;
-        pp = ++p;
-    }
-
-    nlen_pnp = strlen(pstr) + i;
-    pnp = pnew_str = xmalloc((nlen_pnp+1) * sizeof(char));
-
-    pp = pstr;
-
-    if ( i > 0 ) {
-        while ( (p=strchr(pp, cpathsep)) != NULL ) {
-            memcpy(pnp, pp, p-pp);
-            pnp += p-pp;
-            *pnp++ = '$';
-            *pnp++ = '/';
-            pp = ++p;
-        }
-    }
-    nlen_pp = strlen(pp);
-    memcpy(pnp, pp, nlen_pp+1);
-
-    return pnew_str;
-}
-
-
-void
-print_dependencies(const struct growable *pdep, const char* pclass_file)
-{
-    char *pstr;
-    int i;
-
-    pstr = escape_slash(pclass_file);
-    fprintf(pfsout, "%s:", pstr);
-    free(pstr);
-
-    for( i=0; i<pdep->ncur; ++i) {
-        fprintf(pfsout, "  \\\n");
-        pstr=escape_slash(pdep->parray[i]);
-        fprintf(pfsout, "\t%s", pstr);
-        free(pstr);
-    }
-
-    fprintf(pfsout,"\n\n");
-    return;
-}
-
-int
-is_inner(const char *pstr)
-{
-    /* return true if character '$' is found in classname */
-
-    /*
-     * note that a '$' in a classname is not an exact indicator
-     * for an inner class. Java identifier may legally contain
-     * this chararcter, and so may classnames. In the context
-     * of javadep this doesn't matter since the makefile system
-     * can't cope with classfiles with '$'s in the filename
-     * anyway.
-     *
-     */
-
-    if ( strchr(pstr, '$') != NULL )
-        return 1;
-
-    return 0;
-}
-
-void
-process_class_file(const char *pfilename, const struct growable *pfilt)
-{
-    /* read class file and extract object information
-     * java class files are in bigendian data format
-     * (JVMS, p. 83)
-     */
-    int     i;
-    uint32  nmagic;
-    uint16  nminor, nmajor;
-    uint16  ncnt;
-    uint16  nclass_cnt;
-    utf8_t* pc_pool;
-    uint16* pc_class;
-    file_t  file;
-
-    struct growable *pdepen;
-
-    file.pname = (char*)pfilename;
-
-    file.pfs = fopen(file.pname,"rb");
-    if ( !file.pfs )
-        silent_quit();
-
-    nmagic = read_uint32(&file);
-
-    if ( nmagic != 0xCAFEBABE ) {
-        fclose(file.pfs);
-        err_quit("%s: invalid magic", file.pname);
-    }
-
-    nminor = read_uint16(&file);
-    nmajor = read_uint16(&file);
-
-    /* get number of entries in constant pool */
-    ncnt = read_uint16(&file);
-
-#ifdef DEBUG
-    printf("Magic: %x\n", nmagic);
-    printf("Major %d, Minor %d\n", nmajor, nminor);
-    printf("Const_pool_count %d\n", ncnt);
-#else
-    (void)nmajor;
-    (void)nminor;
-#endif
-
-    /* There can be ncount entries in the constant_pool table
-     * so at most ncount-1 of them can be of type CONSTANT_Class
-     * (at leat one CONSTANT_Utf8 entry must exist).
-     * Usually way less CONSTANT_Class entries exists, of course
-     */
-
-    pc_pool = xcalloc(ncnt,sizeof(utf8_t));
-    pc_class = xmalloc((ncnt-1)*sizeof(uint16));
-
-    /* pc_pool[0] is reserved to the java virtual machine and does
-     * not exist in the class file
-     */
-
-    nclass_cnt = 0;
-
-    for (i = 1; i < ncnt; i++) {
-        uint8   ntag;
-        uint16  nindex;
-        utf8_t  a_utf8;
-
-        ntag = read_uint8(&file);
-
-        /* we are only interested in CONSTANT_Class entries and
-         * Utf8 string entries, because they might belong to
-         * CONSTANT_Class entries
-         */
-        switch(ntag) {
-            case CONSTANT_Class:
-                nindex = read_uint16(&file);
-                pc_class[nclass_cnt++] = nindex;
-                break;
-            case CONSTANT_Fieldref:
-            case CONSTANT_Methodref:
-            case CONSTANT_InterfaceMethodref:
-                skip_bytes(&file, 4L);
-                break;
-            case CONSTANT_String:
-                skip_bytes(&file, 2L);
-                break;
-            case CONSTANT_Integer:
-            case CONSTANT_Float:
-                skip_bytes(&file, 4L);
-                break;
-            case CONSTANT_Long:
-            case CONSTANT_Double:
-                skip_bytes(&file, 8L);
-                /* Long and Doubles take 2(!)
-                 * entries in constant_pool_table
-                 */
-                i++;
-                break;
-            case CONSTANT_NameAndType:
-                skip_bytes(&file, 4L);
-                break;
-            case CONSTANT_Utf8:
-                a_utf8 = read_utf8(&file);
-                pc_pool[i] = a_utf8;
-                break;
-            default:
-                /* Unknown Constant_pool entry, this means we are
-                 * in trouble
-                 */
-                err_quit("corrupted class file\n");
-                break;
-
-        }
-    }
-
-    fclose(file.pfs);
-
-    pdepen = allocate_growable();
-
-    for (i = 0; i < nclass_cnt; i++) {
-        char *pstr, *ptmpstr;
-        pstr = ptmpstr = utf8tolatin1(pc_pool[pc_class[i]]);
-        /* we are not interested in inner classes */
-        if ( is_inner(pstr) ) {
-            free(pstr);
-            pstr = NULL;
-            continue;
-        }
-        /* strip off evt. array indicators */
-        if ( *ptmpstr == '[' ) {
-            while ( *ptmpstr == '[' )
-                ptmpstr++;
-            /* we only interested in obj. arrays, which are marked with 'L' */
-            if ( *ptmpstr == 'L' ) {
-                char *p = pstr;
-                pstr = strdup(++ptmpstr);
-                /* remove final ';' from object array name */
-                pstr[strlen(pstr)-1] = '\0';
-                free(p);
-            } else {
-                free(pstr);
-                pstr = NULL;
-            }
-        }
-
-        if (pstr) {
-            add_to_dependencies(pdepen, pfilt, pstr, file.pname);
-            free(pstr);
-        }
-    }
-
-    print_dependencies(pdepen, file.pname);
-    free_growable(pdepen);
-    pdepen = NULL;
-
-    for (i = 0; i < ncnt; i++)
-        free(pc_pool[i].pdata);
-
-    free(pc_class);
-    free(pc_pool);
-}
-
-void *
-xmalloc(size_t size)
-{
-    void *ptr;
-
-    ptr = malloc(size);
-
-    if ( !ptr )
-        err_quit("out of memory");
-
-    return ptr;
-}
-
-
-void *
-xcalloc(size_t nmemb, size_t size)
-{
-    void *ptr;
-
-    ptr = calloc(nmemb, size);
-
-    if ( !ptr )
-        err_quit("out of memory");
-
-    return ptr;
-}
-
-void *
-xrealloc(void *ptr, size_t size)
-{
-    void *newptr = realloc(ptr, size);
-
-    if (newptr)
-        ptr = newptr;
-    else
-        err_quit("out of memory");
-
-    return ptr;
-}
-
-void
-err_quit(const char* fmt, ...)
-{
-    /* No dependency file must be generated for any error condition,
-     * just print message and exit.
-     */
-    va_list args;
-    char buffer[PATH_MAX];
-
-    va_start(args, fmt);
-
-    if ( pprogname )
-        fprintf(stderr, "%s: ", pprogname);
-    vsnprintf(buffer, sizeof(buffer), fmt, args);
-    fputs(buffer, stderr);
-    fputc('\n', stderr);
-
-    va_end(args);
-
-    /* clean up */
-    if ( pfsout && pfsout != stdout ) {
-        fclose(pfsout);
-        unlink(pout_file);
-    }
-    exit(1);
-}
-
-void
-silent_quit()
-{
-    /* In some cases we should just do a silent exit */
-
-    /* clean up */
-    if ( pfsout && pfsout != stdout ) {
-        fclose(pfsout);
-        unlink(pout_file);
-    }
-    exit(0);
-}
-
-int append_to_growable(struct growable *pgrow, char *pstr)
-{
-    /* append an element pstr to pgrow,
-     * return new number of elements
-     */
-    grow_if_needed(pgrow);
-    pgrow->parray[pgrow->ncur++] = pstr;
-    return pgrow->ncur;
-}
-
-void
-grow_if_needed(struct growable *pgrow)
-{
-    /* grow growable arrays */
-
-    if ( pgrow->ncur >= pgrow->nmax ) {
-        pgrow->parray = xrealloc(pgrow->parray,
-                           (NGROW*pgrow->nmax)*sizeof(char*));
-        pgrow->nmax *= NGROW;
-    }
-    return;
-}
-
-struct growable *allocate_growable(void)
-{
-    /* allocate an growable array,
-     * initialize with NGROW_INIT elements
-     */
-
-    struct growable *pgrow;
-
-    pgrow = xmalloc(sizeof(struct growable));
-    pgrow->parray = xmalloc(NGROW_INIT*sizeof(char *));
-    pgrow->nmax = NGROW_INIT;
-    pgrow->ncur = 0;
-    return pgrow;
-}
-
-void
-free_growable(struct growable *pgrow)
-{
-    int i;
-    for( i = 0; i < pgrow->ncur; i++ )
-        free(pgrow->parray[i]);
-    free(pgrow->parray);
-    free(pgrow);
-}
-
-void
-create_filters(struct growable *pfilt, const struct growable *pinc)
-{
-    char *p, *pp, *pstr;
-    int i;
-    size_t nlen, nlen_pstr;
-    /* break up includes into filter list */
-    for ( i = 0; i < pinc->ncur; i++ ) {
-        pp = pinc->parray[i];
-
-        while ( (p = strchr(pp, csep)) != NULL) {
-            nlen = p - pp;
-            pstr = xmalloc((nlen+1)*sizeof(char*));
-            memcpy(pstr, pp, nlen);
-            pstr[nlen] = '\0';
-            append_to_growable(pfilt, pstr);
-            pp = p + 1;
-        }
-        nlen_pstr = strlen(pp);
-        pstr = xmalloc((nlen_pstr+1)*sizeof(char*));
-        memcpy(pstr, pp, nlen_pstr+1);
-        append_to_growable(pfilt, pstr);
-    }
-
-}
-
-void
-usage()
-{
-    fprintf(stderr,
-            "usage: %s [-i|-I includepath ...  -s|-S seperator "
-            "-o|-O outpath -v|-V -h|-H] <file> ....\n",
-            pprogname);
-}
-
-#ifdef WNT
-/* my very simple minded implementation of getopt()
- * it's to sad that getopt() is not available everywhere
- * note: this is not a full POSIX conforming getopt()
- */
-int simple_getopt(char *pargv[], const char *poptstring)
-{
-    char *parg = pargv[optind];
-
-    /* skip all response file arguments */
-    if ( parg ) {
-        while ( *parg == '@' )
-            parg = pargv[++optind];
-
-        if ( parg[0] == '-' && parg[1] != '\0' ) {
-            char *popt;
-            int c = parg[1];
-            if ( (popt = strchr(poptstring, c)) == NULL ) {
-               optopt = c;
-                if ( opterr )
-                    fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
-                return '?';
-            }
-            if ( *(++popt) == ':') {
-                if ( parg[2] != '\0' ) {
-                    optarg = ++parg;
-                } else {
-                    optarg = pargv[++optind];
-                }
-            } else {
-                optarg = NULL;
-            }
-            ++optind;
-            return c;
-        }
-    }
-    return -1;
-}
-#endif
-
-int CDECL
-main(int argc, char *argv[])
-{
-    int     bv_flag = 0;
-    struct  growable *presp, *pincs, *pfilters;
-    int     c, i, nall_argc;
-    char    **pall_argv;
-
-    presp = allocate_growable();
-
-    /* FIXME: cleanup the option parsing */
-    /* search for response file, read it */
-    for ( i = 1; i < argc; i++ ) {
-        char *parg = argv[i];
-        char buffer[RES_FILE_BUF];
-
-        if ( *parg == '@' ) {
-            FILE *pfile = fopen(++parg, "r");
-            if ( !pfile )
-                err_quit("%s: %s", parg, strerror(errno));
-            while ( !feof(pfile) ) {
-                char *p, *token;
-
-                if ( fgets(buffer, RES_FILE_BUF, pfile) ) {;
-                    p = buffer;
-                    while ( (token = strtok(p, " \t\n")) != NULL ) {
-                        p = NULL;
-                        append_to_growable(presp, strdup(token));
-                    }
-                }
-            }
-            fclose(pfile);
-        }
-    }
-
-    /* copy all arguments incl. response file in one array
-     * for parsing with getopt
-     */
-    nall_argc = argc + presp->ncur;
-    pall_argv = xmalloc((nall_argc+1)*sizeof(char *));
-    memcpy(pall_argv, argv, argc*sizeof(char *));
-    memcpy(pall_argv+argc, presp->parray, presp->ncur*sizeof(char *));
-    *(pall_argv+argc+presp->ncur) = '\0'; /* terminate */
-
-    opterr = 0;
-    pincs = allocate_growable();
-
-#ifdef WNT
-    while( (c = simple_getopt(pall_argv, ":i:I:s:S:o:OhHvV")) != -1 ) {
-#else
-    while( (c = getopt(nall_argc, pall_argv, ":i:I:s:S:o:OhHvV")) != -1 ) {
-#endif
-        switch(c) {
-            case 'i':
-            case 'I':
-                append_to_growable(pincs, strdup(optarg));
-                break;
-            case 's':
-            case 'S':
-                csep = optarg[0];
-                break;
-            case 'o':
-            case 'O':
-                pout_file = optarg;
-                break;
-            case 'h':
-            case 'H':
-                usage();
-                return 0;
-                break;
-            case 'v':
-            case 'V':
-                bv_flag = 1;
-                break;
-            case '?':
-                if (isprint (optopt))
-                    fprintf (stderr,
-                             "Unknown option `-%c'.\n", optopt);
-                else
-                    fprintf (stderr,
-                             "Unknown option character `\\x%x'.\n",
-                             optopt);
-                usage();
-                return 1;
-                break;
-            case ':':
-                fprintf(stderr, "Missing parameter.\n");
-                usage();
-                return 1;
-                break;
-            default:
-                usage();
-                return 1;
-                break;
-        }
-    }
-
-    pfilters = allocate_growable();
-    create_filters(pfilters, pincs);
-    free_growable(pincs);
-    pincs = NULL;
-
-    if ( pout_file ) {
-        pfsout = fopen(pout_file, "w");
-        if ( !pfsout )
-            err_quit("%s: %s", pout_file, strerror(errno));
-    } else {
-        pfsout = stdout;
-    }
-
-    /* the remaining arguments are either class file
-     * names or response files, ignore response file
-     * since they have already been included
-     */
-    for ( i = optind; i < nall_argc; i++ ) {
-        char *parg = pall_argv[i];
-        if ( *parg != '@' ) {
-            process_class_file(parg, pfilters);
-            if ( pfsout != stdout ) {
-                if ( bv_flag )
-                    printf("Processed %s ...\n", parg);
-            }
-        }
-    }
-
-    free_growable(pfilters);
-    pfilters = NULL;
-    free(pall_argv);
-    pall_argv = NULL;
-    free_growable(presp);
-    presp = NULL;
-
-    fclose(pfsout);
-    exit(0);
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */