eolfix.c

/*

Copyright (c) 2002-2015, Ross Smith II (http://smithii.com)

TODO
====

http://packages.debian.org/stable/text/flip

flip
This program converts line endings of text files between MS-DOS and **IX formats.
It detects binary files in a nearly foolproof way and leaves them alone unless you override this.
It will also leave files alone that are already in the right format and preserves file timestamps.
User interrupts are handled gracefully and no garbage or corrupted files left behind.
'flip' does not convert files to a different character set, and it can not handle Apple Macintosh line endings (CR only).
 For that (and more), you can use the 'recode' program (package 'recode').

Command line utility to report, and optionally convert, the line endings of text files between MS-DOS, Unix and Macintosh formats.
It detects and ignores binary files unless instructed to include them.
It does not modify files if the file is already in the requested format.
It properly handles "mixed" format files (files having more than one type of line ending format).
It does not, currently, handle character encodings other than 7-bit ASCII.

fix: eolfix -v -s *.c -l *.c

support runon options: eolfix -vib -d

support comments in @files

only process files in @files

one filename per line?

deal with embedded spaces in @file files

documentation

add asserts()

implement -o directory_name ?

  "-o | --output filespec Send output to a file/dir named 'filespec' (-=stdout)\n"

implement reading options from EOLFIX environment variable

implement reading options from ~/.eolfix settings file


remove debugging code

move basename/dirname/mkstemp/gettimeofday to separate files ?

use ruby code to add windows CE port

todo:

  only support conv compatibility, if program is named conv, or the user uses -C or --conv option

  how to implement the opposite of an option if the user uses the capital of it:

test symlink code

research how cp deals with permissions

dynamically assign BUFSIZ from statbuf.st_blksize?

if windows, copy windows rights specially

-c | --compress        Compress doubled-spaced files to be single-spaced

flush out license() contents

support reading unicode files?

shr long            sht long
--- --------------------------- --- -----------------
-a  --Abort           -A  --no-abort
-b  --Backup          -B  --no-backup
-c  --Compress          -C  --no-compress
-d  --Dos
-e: --Exclude
-f  --Force           -F  --no-force
-g: --confiG
-h  --Help (undocumented)
-i: --Include
-j  --in-place          -J  --no-in-place
-k: --bacKup-ext        -K  --no-backup-ext
-l  --Leave
-m  --Mac
-n  --Native
-o  --Output          -O  --no-output
-p  --Preserve          -P  --no-preserve
-q  --Quiet           -Q  --no-quiet
-r  --Recursive         -R  --no-recursive
-s  --Skip
-t: --Temp-dir          -T  --no-temp-dir
-u  --Unix
-v  --Verbose         -V  --no-verbose
-w  --Windows (undocumented)
-x (unused)
-y  --drY-run         -Y  --no-dry-run
-z  --ignore-case               -Z  --no-ignore-case
-?  --Help

    --license
  --version

conv_mode:

-A  --auto (conv_mode)        --no-auto
-D  --dos (conv_mode)
-F  --force (conv_mode)       --no-force
-M  --mac (conv_mode)
-U  --unix (conv_mode)
-S  --safe (conv_mode)

input --unix  --dos     --mac
======= ======= ============  =====
LF    LF    CR LF     CR
CR    LF    CR LF     CR
CRLF  LF    CR LF     CR
CRCR  LF LF CR LF CR LF   CR CR
CRCRLF  LF    CR LF     CR
*/

#undef CONV_SUPPORT_ENABLED

#define COPYRIGHT "Copyright (c) 2002-2015, Ross Smith II. MIT Licensed."

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "compiler.h"

#include <stdio.h>    /* fprintf() */
#include <assert.h>   /* assert() */
#include <ctype.h>    /* iscntrl() */
#include <errno.h>    /* errno() */
#include <limits.h>   /* PATH_MAX */
#include <signal.h>   /* signal() */
#include <stdarg.h>   /* vfprintf() */
#include <sys/stat.h> /* stat() */
#include <sys/types.h>  /* stat() */

#ifdef HAVE_CONIO_H
# include <conio.h> /* getch() */
#endif

#ifdef HAVE_DIRECT_H
# include <direct.h> /* opendir() (on Watcom) */
#endif

#ifdef HAVE_DIRENT_H
# include <dirent.h> /* opendir() */
#endif

#ifdef HAVE_FCNTL_H
# include <fcntl.h> /* O_RDWR, etc. */
#endif

#ifdef HAVE_FNMATCH_H
# ifdef _POSIX_SOURCE
#  define _POSIX_SOURCE_SAVE _POSIX_SOURCE
#  undef _POSIX_SOURCE
# endif
# include <fnmatch.h> /* fnmatch() */
# ifdef _POSIX_SOURCE_SAVE
#  define _POSIX_SOURCE _POSIX_SOURCE_SAVE
#  undef _POSIX_SOURCE_SAVE
# endif
#else
# include "fnmatch.h" /* local version */
#endif

#ifdef HAVE_GETOPT_LONG
# include <getopt.h> /* getopt() */
#else
# include "getopt.h" /* local version */
#endif

#ifdef HAVE_IO_H
# include <io.h> /* open() */
#endif

#ifdef HAVE_STDBOOL_H
# include <stdbool.h>
#else /* !HAVE_STDBOOL_H */
# ifndef HAVE__BOOL
#  ifdef __cplusplus
    typedef bool _Bool;
#  else
    typedef unsigned char _Bool;
#  endif
# endif
# define bool _Bool
# define false 0
# define true 1
# define __bool_true_false_are_defined 1
#endif /* HAVE_STDBOOL_H */

#ifdef HAVE_STDLIB_H
# include <stdlib.h> /* NULL, EXIT_SUCCESS */
#else
extern void exit();
#endif

#ifdef HAVE_STRING_H
# include <string.h> /* strlen */
#endif

#ifdef HAVE_STRINGS_H
# include <strings.h> /* strlen */
#endif

#ifdef HAVE_SYS_FILE_H
# include <sys/file.h> /* O_RDWR, etc. */
#endif

#ifdef HAVE_SYS_TIME_H
# include <sys/time.h> /* struct timeval */
#endif

#ifdef HAVE_SYS_UTIME_H
# include <sys/utime.h> /* utime() */
#endif

#ifdef HAVE_TIME_H
# include <time.h> /* struct timeval */
#endif

#ifdef HAVE_UTIME_H
# include <utime.h> /* utime() */
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h> /* open() */
#endif

#ifdef HAVE_WINDOWS_H
# include <windows.h> /* GetSystemTimeAsFileTime(), OutputDebugString() */
#endif

#ifndef longlong_t
#if defined(SIZEOF_LONG) && (SIZEOF_LONG >= 8)
# define longlong_t long
#elif (defined(SIZEOF_LONG_LONG) && (SIZEOF_LONG_LONG >= 8)) || defined(__GNUC__)
# define longlong_t long long
#else
# define longlong_t long
#endif
#endif /* longlong_t */

#define ulonglong_t unsigned longlong_t

#ifndef BUFSIZ
# define BUFSIZ 512
#endif

#ifndef O_BINARY
# define O_BINARY 0
#endif

#ifndef PATH_MAX
# ifdef _MAX_PATH
#  define PATH_MAX _MAX_PATH
# else
#  ifdef FILENAME_MAX
#   define PATH_MAX FILENAME_MAX
#  else
#   define PATH_MAX 260
#  endif
# endif
#endif

#ifndef HAVE_SSIZE_T
# define ssize_t int
#endif

#ifndef S_IRUSR
# ifdef S_IREAD
#  define S_IRUSR S_IREAD
# endif
#endif

#ifndef S_IWUSR
# ifdef S_IWRITE
#  define S_IWUSR S_IWRITE
# endif
#endif

/* unix EOF marker */
#define CTRL_D '\x04'

/* Line feed character */
#define CTRL_J '\x0a'

/* Carriage return character */
#define CTRL_M '\x0d'

/* dos EOF marker */
#define CTRL_Z '\x1a'

#define EOLFIX_ENVVAR "EOLFIX"

#define TEMP_FILE_TEMPLATE "/eoXXXXXXX.tmp"

#define TEMP_FILE_TEMPLATE_SUFFIX_LEN 4

#define UNIMPLEMENTED_OPTION "Unimplemented option"
#define PROCESSING_OPTION "Processing option"

static char *progname;

/* input file format */

enum input_e {
  INPUT_NONE    = 0,
  INPUT_UNIX    = 1,
  INPUT_DOS   = 2,
  INPUT_MAC   = 4,
  INPUT_VARIED  = 8,
  INPUT_BINARY  = 16
};

typedef enum input_e input_t;

#define INPUT_ALL_ASCII ((input_t) (INPUT_UNIX | INPUT_DOS | INPUT_MAC | INPUT_VARIED))
#define INPUT_ALL ((input_t) (INPUT_ALL_ASCII | INPUT_BINARY))

/* output file format */

enum output_e {
  OUTPUT_LEAVE  = 0,
  OUTPUT_UNIX   = 1,
  OUTPUT_DOS    = 2,
  OUTPUT_MAC    = 4,
  OUTPUT_SKIP   = 32
};

typedef enum output_e output_t;

#ifdef __DOS__
# define NATIVE "DOS/Windows"
# define OUTPUT_NATIVE OUTPUT_DOS
#elif defined(__MAC__)
/* how to determine? CodeWarrior compiler? */
# define NATIVE "Macintosh"
# define OUTPUT_NATIVE OUTPUT_MAC
#else
# define NATIVE "Unix"
# define OUTPUT_NATIVE OUTPUT_UNIX
#endif

#define T_UNCHANGED "unchanged"
#define T_UNIX    "unix"
#define T_DOS   "dos"
#define T_MAC   "mac"
#define T_VARIED  "varied"
#define T_NONE    "none"
#define T_BINARY  "binary"
#define T_ALL   "all"

static char *input_desc[] = {
  T_NONE,     /* no cr/lf's found */
  T_UNIX,     /* unix */
  T_DOS,      /* dos */
  T_VARIED,   /* dos & unix */
  T_MAC,      /* mac */
  T_VARIED,   /* mac & unix */
  T_VARIED,   /* mac & dos */
  T_VARIED    /* mac & dos & unix */
};

static char *input_descv[] = {
  T_NONE,           /* no cr/lf's found */
  T_UNIX,           /* unix */
  T_DOS,            /* dos */
  T_DOS "/" T_UNIX,     /* dos & unix */
  T_MAC,            /* mac */
  T_MAC "/" T_UNIX,     /* mac & unix */
  T_DOS "/" T_MAC,      /* mac & dos */
  T_DOS "/" T_MAC "/" T_UNIX  /* mac & dos & unix */
};

static char *output_desc[] = {
  T_UNCHANGED,  /* OUTPUT_LEAVE (0) */
  T_UNIX,     /* OUTPUT_UNIX (1) */
  T_DOS,      /* OUTPUT_DOS (2) */
  NULL,     /* not used */
  T_MAC     /* OUTPUT_MAC (4) */
};

struct _options {
  bool  abort;
  bool  backup;
  char  bak_ext[PATH_MAX];
  bool  compress;
  bool  dry_run;
  bool  force;
  int   include; /* input_t */
  bool  in_place;
  char  output_filename[PATH_MAX];
  output_t output_format;
  bool  preserve;
  bool  quiet;
  bool  recursive;
  char  temp_dir[PATH_MAX];
  int   verbose;
  bool  ignore_case;

  bool  std_in;
  bool  std_out;
  bool  wildcards_used;
#ifdef CONV_SUPPORT_ENABLED
  bool  conv_mode;
  bool  _auto;
#endif /* CONV_SUPPORT_ENABLED */
};

typedef struct _options options_t;

#define BACKUP_EXT ".bak"

static options_t opt = {
  false,        /* abort */
  false,        /* backup */
  BACKUP_EXT,     /* backup-ext */
  false,        /* compress */
  false,        /* dry_run */
  false,        /* force */
  INPUT_ALL_ASCII,  /* include */
  false,        /* in_place */
  "",         /* output_filename */
  OUTPUT_LEAVE,   /* output_format */
  false,        /* preserve */
  false,        /* quiet */
  false,        /* recursive */
  "",         /* temp_dir */
  0,          /* verbose */
#ifdef IS_CASE_INSENSITIVE_FILESYSTEM
  true,       /* ignore_case */
#else
  false,
#endif
  false,        /* stdin */
  false,        /* stdout */
  false,        /* wildcard_found */
#ifdef CONV_SUPPORT_ENABLED
  ,false,       /* _auto */
  false       /* conv_mode */
#endif /* CONV_SUPPORT_ENABLED */
};

static char *input_filename;
static char temp_filename[PATH_MAX] = "";

static int output_handle = -1;

static int exit_value = 0;

#ifdef CONV_SUPPORT_ENABLED
# define CONV_MODE_SWITCHES "DMU"
# define FORCE_OPTION   "force-rewrite"
# define FORCEOPTION    "forcerewrite"
# define NO_FORCE_OPTION  "no-force-rewrite"
# define NOFORCEOPTION    "noforcerewrite"
#else
# define CONV_MODE_SWITCHES
# define FORCE_OPTION   "force"
# define FORCEOPTION    "force"
# define NO_FORCE_OPTION  "no-force"
# define NOFORCEOPTION    "noforce"
#endif /* CONV_SUPPORT_ENABLED */

#define UNDOCUMENTED_SWITCHES "wRh"

#define NEGATE_SWITCHES "ABCFJKOPQRTVYZ"

static char* short_options = "abcde:fg:i:jk:lmno:pqrst:uvyz?-" NEGATE_SWITCHES UNDOCUMENTED_SWITCHES CONV_MODE_SWITCHES;

/* For long options that have no equivalent short option, use a
   non-character as a pseudo short option, starting with UCHAR_MAX + 1.  */
enum opt_e {
  OPT_LICENSE = UCHAR_MAX + 1,
  OPT_VERSION
#ifdef CONV_SUPPORT_ENABLED
  ,OPT_AUTO,
  OPT_FORCE,
  OPT_SAFE,
  OPT_NO_AUTO,
  OPT_NO_FORCE
#endif /* CONV_SUPPORT_ENABLED */
};

static struct option long_options[] = {
  {"abort",     no_argument,    0, 'a'},
  {"backup",      no_argument,    0, 'b'},
  {"backup-ext",    required_argument,  0, 'k'},
  {"compress",    no_argument,    0, 'c'},
  {"config",      required_argument,  0, 'g'},
  {"dos",       no_argument,    0, 'd'},
  {"dry-run",     no_argument,    0, 'y'},
  {"exclude",     required_argument,  0, 'e'},
  {FORCE_OPTION,    no_argument,    0, 'f'},
  {"help",      no_argument,    0, '?'},
  {"ignore-case",   no_argument,    0, 'z'},
  {"include",     required_argument,  0, 'i'},
  {"in-place",    no_argument,    0, 'j'},
  {"leave",     no_argument,    0, 'l'},
  {"license",     no_argument,    0, OPT_LICENSE},
  {"mac",       no_argument,    0, 'm'},
  {"native",      no_argument,    0, 'n'},
  {"output",      required_argument,  0, 'o'},
  {"preserve",    no_argument,    0, 'p'},
  {"quiet",     no_argument,    0, 'q'},
  {"recursive",   no_argument,    0, 'r'},
  {"skip",      no_argument,    0, 's'},
  {"temp-dir",    required_argument,  0, 't'},
  {"unix",      no_argument,    0, 'u'},
  {"verbose",     no_argument,    0, 'v'},
  {"version",     no_argument,    0, OPT_VERSION},

  /* negate options */
  {"no-abort",    no_argument,    0, 'A'},
  {"no-backup",   no_argument,    0, 'B'},
  {"no-backup-ext", no_argument,    0, 'K'},
  {"no-compress",   no_argument,    0, 'C'},
  {"no-dry-run",    no_argument,    0, 'Y'},
  {NO_FORCE_OPTION, no_argument,    0, 'F'},
  {"no-ignore-case",  no_argument,    0, 'Z'},
  {"no-in-place",   no_argument,    0, 'J'},
  {"no-output",   no_argument,    0, 'O'},
  {"no-preserve",   no_argument,    0, 'P'},
  {"no-quiet",    no_argument,    0, 'Q'},
  {"no-recursive",  no_argument,    0, 'R'},
  {"no-temp-dir",   no_argument,    0, 'T'},
  {"no-tmp-dir",    no_argument,    0, 'T'},
  {"no-verbose",    no_argument,    0, 'V'},

  /* undocumented alternatives */

  /* abort */
  {"abort-on-error",  no_argument,    0, 'a'},

  /* backup-ext */
  {"backupext",   required_argument,  0, 'k'},

  /* dos */
  {"crlf",      no_argument,    0, 'd'},
  {"msdos",     no_argument,    0, 'd'},
  {"u2d",       no_argument,    0, 'd'},
  {"unix2dos",    no_argument,    0, 'd'},
  {"m2d",       no_argument,    0, 'd'},
  {"mac2dos",     no_argument,    0, 'd'},
  {"win",       no_argument,    0, 'd'},
  {"windows",     no_argument,    0, 'd'},

  /* dry-run */
  {"dryrun",      no_argument,    0, 'y'},

  /* force */
  {FORCEOPTION,   no_argument,    0, 'f'},

  /* help */
  {"help",      no_argument,    0, '?'},
  {"usage",     no_argument,    0, '?'},

  /* ignore-case */
  {"ignorecase",    no_argument,    0, 'Z'},

  /* in-place */
  {"inplace",     no_argument,    0, 'j'},

  /* leave */
  {"leave-alone",   no_argument,    0, 'l'},

  /* license */
  {"licence",     no_argument,    0, OPT_LICENSE},

  /* mac */
  {"cr",        no_argument,    0, 'm'},
  {"macintosh",   no_argument,    0, 'm'},
  {"d2m",       no_argument,    0, 'u'},
  {"dos2mac",     no_argument,    0, 'u'},
  {"u2m",       no_argument,    0, 'u'},
  {"unix2mac",    no_argument,    0, 'u'},

  /* no-change */
  {"nochange",    no_argument,    0, 'n'},

  /* recursive */
  {"recurse",     no_argument,    0, 'r'},

  /* temp-dir */
  {"tempdir",     required_argument,  0, 't'},
  {"tmp-dir",     required_argument,  0, 't'},
  {"tmpdir",      required_argument,  0, 't'},

  /* unix */
  {"lf",        no_argument,    0, 'u'},
  {"nl",        no_argument,    0, 'u'},
  {"d2u",       no_argument,    0, 'u'},
  {"dos2unix",    no_argument,    0, 'u'},
  {"m2u",       no_argument,    0, 'u'},
  {"mac2unix",    no_argument,    0, 'u'},

  /* negate options */
  {"noabort",     no_argument,    0, 'A'},
  {"nobackup",    no_argument,    0, 'B'},
  {"nobackupext",   no_argument,    0, 'K'},
  {"nocaseinsensitive",no_argument,   0, 'Z'},
  {"nodryrun",    no_argument,    0, 'Y'},
  {NOFORCEOPTION,   no_argument,    0, 'F'},
  {"noignorecase",  no_argument,    0, 'Z'},
  {"noinplace",   no_argument,    0, 'J'},
  {"nooutput",    no_argument,    0, 'O'},
  {"nopreserve",    no_argument,    0, 'P'},
  {"noquiet",     no_argument,    0, 'Q'},
  {"norecursive",   no_argument,    0, 'R'},
  {"notempdir",   no_argument,    0, 'T'},
  {"notmpdir",    no_argument,    0, 'T'},
  {"noverbose",   no_argument,    0, 'V'}
#ifdef CONV_SUPPORT_ENABLED
   ,{"auto",      no_argument,    0, OPT_AUTO},
  {"dos",       no_argument,    0, 'D'},
  {"force",     no_argument,    0, OPT_FORCE},
  {"mac",       no_argument,    0, 'M'},
  {"safe",      no_argument,    0, OPT_SAFE},
  {"unix",      no_argument,    0, 'U'},
    {"no-auto",     no_argument,    0, OPT_NO_AUTO},
  {"no-force",    no_argument,    0, OPT_NO_FORCE},

    {"noauto",      no_argument,    0, OPT_NO_AUTO},
  {"noforce",     no_argument,    0, OPT_NO_FORCE}
#endif /* CONV_SUPPORT_ENABLED */
};

#ifdef CONV_SUPPORT_ENABLED
#  define CONV_USAGE \
  "-A | --auto             Convert to UNIX if DOS, Mac, or varied, or DOS if UNIX\n" \
  "-D | --u2d      [files] Convert text files to have DOS/Windows line endings\n" \
  "     --unix2dos [files] Convert text files to have DOS/Windows line endings\n" \
  "-U | --d2u      [files] Convert text files to have UNIX line endings\n" \
  "     --dos2unix [files] Convert text files to have UNIX line endings\n" \
  "     --force            Force conversion of binary files\n" \
  "     --safe             Do not convert binary files (default)\n"
#else
# define CONV_USAGE
#endif /* CONV_SUPPORT_ENABLED */

/****************************************************************************/

static
#if !defined(_DEBUG) && !defined(__LCC__)
/* Workaround for LCC's: Error eolfix.c: 2168  operands of = have illegal types 'pointer to char' and 'int' */
inline
#endif
void _DBG(char *fmt, ...) {
#ifdef _DEBUG
  static char buffer[65535];
  va_list args;
  va_start(args, fmt);
  vsprintf(buffer, fmt, args);
  strcat(buffer, "\n");
# if defined(__WINDOWS__)
  OutputDebugString(buffer);
# endif
  fprintf(stdout, buffer);
  fflush(stdout);
  va_end(args);
#endif
}

/****************************************************************************/

static void usage(int exit_value) {
  printf(
"Usage: %s [options] [files...]\n"
"Options:\n",
    progname
  );
#ifdef CONV_SUPPORT_ENABLED
  if (opt.conv_mode) {
    printf(CONV_USAGE);
    printf("\n");
  }
#endif /* CONV_SUPPORT_ENABLED */
/*2345678901234567890123456789012345678901234567890123456789012345678901234567890*/
  printf(
"-u | --unix    [files] Convert text files to have UNIX line endings\n"
"-d | --dos     [files] Convert text files to have DOS/Windows line endings\n"
"-m | --mac     [files] Convert text files to have Macintosh line endings\n"
"-n | --native  [files] Convert text files to have %s line endings\n"
"-l | --leave   [files] Report on the type of file, but do not convert (default)\n"
"-s | --skip    [files] Skip these files entirely\n"
"-i | --include type    Include types: unix, dos, mac, varied, binary and all\n"
"                       Default is to include unix, dos, mac and varied files\n"
"-e | --exclude type    Exclude types: unix, dos, mac, varied, binary and all\n"

"-a | --abort           Abort processing on the first error encountered\n"
"-b | --backup          Backup each file before converting it\n"
"-k | --backup-ext .ext Use <.ext> for backup file extension (default is %s)\n"
"-c | --compress        Compress doubled-spaced files to be single-spaced (todo)\n"
"-g | --config file     Process options in <file>\n"
"-y | --dry-run         Skip conversion, but show what would have been converted\n"
"-f | --%-15s Convert every file, even if no change would result\n"
"-z | --ignore-case     Perform case-insensitive filename matching\n"
"-j | --in-place        Convert text files in-place (slower)\n"
"-o | --output file     Send output to <file> (use - for stdout)\n"
"-p | --preserve        Preserve file ownership and times\n"
"-r | --recursive       Recurse into directories\n"
"-t | --temp-dir dir    Use <dir> for temporary files (default is file's dir)\n"
, NATIVE, opt.bak_ext, FORCE_OPTION);
#ifdef HAVE_GETCH
  if (isatty(fileno(stdin)) && isatty(fileno(stdout))) {
    printf("Press any key: ");
    while (!getch())
      ;
    printf("\r");
  }
#endif
  printf(
"-v | --verbose         Report on every file, even if it would not be changed\n"
"-q | --quiet           Only report errors\n"
"-? | --help            Show this help message and quit\n"
"     --version         Display version information and quit\n"
"     --license         Display licensing information\n"
"     --                Stop processing options\n"
);
#ifdef CONV_SUPPORT_ENABLED
  if (!opt.conv_mode) {
    printf("\n");
    printf(CONV_USAGE);
  }
#endif /* CONV_SUPPORT_ENABLED */

  exit(exit_value);
}

/****************************************************************************/
#ifndef HAVE_BASENAME
/****************************************************************************/

/* per http://www.scit.wlv.ac.uk/cgi-bin/mansec?3C+basename */
static char* basename(char* s) {
  char* rv;

  if (!s || !*s)
    return ".";

  rv = s + strlen(s) - 1;

  do {
    if (IS_PATH_SEPARATOR(*rv))
      return rv + 1;
    --rv;
  } while (rv >= s);

  return s;
}

#define HAVE_BASENAME 1

#endif /* ! HAVE_BASENAME */


/****************************************************************************/
#ifndef HAVE_DIRNAME
/****************************************************************************/

/* per http://www.scit.wlv.ac.uk/cgi-bin/mansec?3C+dirname */
static char* dirname(char* path) {
  static char rv[PATH_MAX];

  char *p;
  unsigned int i = 0;

  if (path == NULL || *path == '\0')
    return ".";
  i = strlen(path) - 1;
  p = path + i;
  while (IS_PATH_SEPARATOR(*p)) {
    if (p == path)
      return path;
    *p-- = '\0';
    --i;
  }

  while (p >= path && !IS_PATH_SEPARATOR(*p)) {
    --p;
    --i;
  }

  if (p < path) {
    return ".";
  }

  if (p == path) {
    return "/";
  }

  if (i > PATH_MAX - 1) {
    return "";
  }

  strncpy(rv, path, i);
  rv[i] = '\0';

  return rv;
/*
  int i;
  static char rv[PATH_MAX];
  int at_end = 1;

  if (s) {
    for (i = strlen(s) - 1; i >= 0; --i) {
      if (IS_PATH_SEPARATOR(s[i])) {
        if (!at_end) {
          if (i > 0) {
            if (i > PATH_MAX - 1)
              return NULL;
            strncpy(rv, s, i);
          }
          rv[i] = '\0';
          return rv;
        }
      } else
        at_end = 0;
    }
  }

  return ".";
*/
}

#define HAVE_DIRNAME 1

#endif /* ! HAVE_DIRNAME */


/****************************************************************************/
#ifndef HAVE_GETTIMEOFDAY
/****************************************************************************/

#if !defined(HAVE_STRUCT_TIMEVAL) && defined(HAVE_WINSOCK_H) && !defined(__CYGWIN__)
# include <winsock.h> /* struct timeval */
#endif

#define MAKE_ULONGLONG(hi, lo) ((((ulonglong_t) hi) << 32) + ((ulonglong_t) lo))

static int gettimeofday(struct timeval* tv, void* timezone) {
/*
  FILETIME time;
  double timed;

  GetSystemTimeAsFileTime(&time);
  timed = ((time.dwHighDateTime * 4294967296e-7) - 11644473600.0) + (time.dwLowDateTime  * 1e-7);
  tv->tv_sec  = (long) timed;
  tv->tv_usec = (long) ((timed - tv->tv_sec) * 1e6);
*/
    SYSTEMTIME nowst;
    FILETIME nowft;
    static ulonglong_t then = 0;
    ulonglong_t now;
    ulonglong_t diff;

    if (!then) {
      SYSTEMTIME thenst = {1970, 1, 4, 1, 0, 0, 0, 0};  /* 00:00:00 Jan 1st 1970 */
      FILETIME thenft;

      SystemTimeToFileTime(&thenst, &thenft);
      then = MAKE_ULONGLONG(thenft.dwHighDateTime, thenft.dwLowDateTime);
  }

    GetLocalTime(&nowst);
    SystemTimeToFileTime(&nowst, &nowft);
    now = MAKE_ULONGLONG(nowft.dwHighDateTime, nowft.dwLowDateTime);

  diff = now - then; /* time from 00:00:00 Jan 1st 1970 to now in 100 nanos */

  /* 100 nanos / 10 = 1 micro / 1000 = 1 milli / 1000 = 1 second */
    tv->tv_sec = (long) (diff / 10000000);
    diff %= 10000000;
  tv->tv_usec = (long) (diff * 100);

  return 0;
}

# define HAVE_GETTIMEOFDAY 1

#endif /* ! HAVE_GETTIMEOFDAY */


/****************************************************************************/
#ifndef HAVE_MKSTEMPS
/****************************************************************************/

#ifdef HAVE_PROCESS_H
# include <process.h> /* getpid() */
#endif /* HAVE_PROCESS_H */

#ifndef TMP_MAX
# define TMP_MAX 32767
#endif

static int mkstemps (char *templat, int suffix_len) {
  static const char letters[] =
#ifndef IS_CASE_INSENSITIVE_FILESYSTEM
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#endif
    "abcdefghijklmnopqrstuvwxyz0123456789";
  static ulonglong_t value;
#ifdef HAVE_GETTIMEOFDAY
  struct timeval tv;
#endif
  char *XXXXXX;
  size_t len;
  int count;

  len = strlen(templat);

  if ((int) len < 6 + suffix_len || strncmp(&templat[len - 6 - suffix_len], "XXXXXX", 6))
    return -1;

  XXXXXX = &templat[len - 6 - suffix_len];

#ifdef HAVE_GETTIMEOFDAY
  gettimeofday(&tv, NULL);
  value += ((ulonglong_t) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid();
#else
  value += getpid();
#endif

  for (count = 0; count < TMP_MAX; ++count) {
    ulonglong_t v = value;
    int fd;

    /* Fill in the random bits.  */
    XXXXXX[0] = letters[(unsigned int) (v % sizeof(letters))];
    v /= sizeof(letters);
    XXXXXX[1] = letters[(unsigned int) (v % sizeof(letters))];
    v /= sizeof(letters);
    XXXXXX[2] = letters[(unsigned int) (v % sizeof(letters))];
    v /= sizeof(letters);
    XXXXXX[3] = letters[(unsigned int) (v % sizeof(letters))];
    v /= sizeof(letters);
    XXXXXX[4] = letters[(unsigned int) (v % sizeof(letters))];
    v /= sizeof(letters);
    XXXXXX[5] = letters[(unsigned int) (v % sizeof(letters))];

    fd = open(templat, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
    if (fd >= 0)
      return fd;

    value += 7777;
  }

  templat[0] = '\0';
  return -1;
}

#define HAVE_MKSTEMPS 1

#endif /* ! HAVE MKSTEMPS */


/****************************************************************************/
#ifndef HAVE_OPENDIR
/****************************************************************************/

struct dirent {
  char *d_name;
};

struct _dir {
  long        findfirst_handle;
  struct _finddata_t  *finddata;
  struct dirent   *direntry;
  struct dirent   *firstentry;
};

typedef struct _dir DIR;

static void dh_free(DIR *dh) {
  free(dh->finddata);
  free(dh->direntry);
  free(dh);
  dh = NULL;
}

/* http://www.scit.wlv.ac.uk/cgi-bin/mansec?3C+opendir */
static DIR *opendir(const char *dir) {
  char path[PATH_MAX];
  DIR *dh;
  struct stat statbuf;

  if (!dir) {
    errno = EFAULT;
    return (DIR *) NULL;
  }

  if (!*dir) {
    errno = ENOTDIR;
    return (DIR *) NULL;
  }

  if (stat(dir, &statbuf) == -1)
    return (DIR *) NULL;

  if (!(statbuf.st_mode & S_IFDIR)) {
    errno = ENOTDIR;
    return (DIR *) NULL;
  }

  dh = (DIR *) malloc(sizeof(DIR));
  if (!dh) {
    errno = ENOMEM;
    return (DIR *) NULL;
  }

  dh->finddata = (struct _finddata_t*) malloc(sizeof(struct _finddata_t));
  if (!dh->finddata) {
    free(dh);
    errno = ENOMEM;
    return (DIR *) NULL;
  }

  dh->direntry = (struct dirent*) malloc(sizeof(struct dirent));
  if (!dh->direntry) {
    free(dh);
    free(dh->finddata);
    errno = ENOMEM;
    return (DIR *) NULL;
  }

  if (strlen(dir) + 2 > sizeof(path) - 1) {
    dh_free(dh);
    errno = ENAMETOOLONG;
    return (DIR *) NULL;
  }

  sprintf(path, "%s/%s", dir, "*");

  dh->findfirst_handle = _findfirst(path, dh->finddata);
  if (dh->findfirst_handle == -1) {
    errno = ENOENT;
    dh_free(dh);
    return (DIR *) NULL;
  }

  dh->firstentry = dh->direntry;
  dh->direntry->d_name = dh->finddata->name;

  return dh;
}

/* http://www.scit.wlv.ac.uk/cgi-bin/mansec?3C+readdir */
static struct dirent *readdir(DIR *dh) {
  struct dirent *de;

  if (!dh) {
    errno = EBADF;
    return NULL;
  }

  if (dh->firstentry) {
    de = dh->firstentry;
    dh->firstentry = NULL;
    return de;
  }

  if (_findnext(dh->findfirst_handle, dh->finddata) == -1) {
    if (errno == ENOENT)
      errno = 0;
    return NULL;
  }

  de = dh->direntry;
  de->d_name = dh->finddata->name;

  return de;
}

/* http://www.scit.wlv.ac.uk/cgi-bin/mansec?3C+closedir */
static int closedir(DIR *dh) {
  int rv;

  if (!dh) {
    errno = EBADF;
    return -1;
  }

  rv = _findclose(dh->findfirst_handle);

  dh_free(dh);

  return rv;
}

#endif /* HAVE_OPENDIR */

/****************************************************************************/

static void version(void) {
  printf("%s - Version %s - %s", progname, VERSION, __DATE__);
#ifdef _DEBUG
  printf(" (debug build: %s=" COMPILER_PRINTF ")", COMPILER, COMPILER_VERSION);
#endif
  printf("\n%s\n", COPYRIGHT);
}

static void license(void) {
  version();
  /* todo */
}

static void warning(char *fmt, ...) {
  va_list args;

  fprintf(stderr, "%s: ", progname);

  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  if (errno) {
    exit_value |= errno;
    fprintf(stderr, ": ");
    fprintf(stderr, "%s", strerror(errno));
  }
  fprintf(stderr, "\n");
  fflush(stderr);
  va_end(args);
}

static void error(char *fmt, ...) {
  va_list args;

  fprintf(stderr, "%s: ", progname);

  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  if (errno) {
    exit_value |= errno;
    fprintf(stderr, ": ");
    fprintf(stderr, "%s", strerror(errno));
  }
  fprintf(stderr, "\n");
  fflush(stderr);
  va_end(args);
  if (errno == ENOMEM || opt.abort)
    exit(exit_value ? exit_value : 1);
  errno = 0;
}

static inline void *xalloc(int size) {
  void *p = malloc(size);
  if (!p) {
    error("out of memory");
    exit(ENOMEM);
  }

  return p;
}

static inline char *xstrdup(char *s) {
  char *p = strdup(s);
  if (!p) {
    error("out of memory");
    exit(ENOMEM);
  }

  return p;
}

static inline int read1(int fh, char* c) {
  ssize_t bytes = read(fh, c, 1);
  if (bytes < 0)
    error("cannot read %s", input_filename);
  return bytes;
}

static inline void write1(int fh, char c) {
/*  _DBG("write1(%s%c)", ((c < 32) ? "^" : ""), ((c < 32) ? c + 64 : c)); */
  if (fh != -1 && write(fh, &c, 1) < 0)
    error("cannot write to %s", temp_filename);
}

static inline void write_nl(int fh, char c, output_t output_format) {
  switch (output_format) {
    case OUTPUT_LEAVE:
      write1(fh, c);
      break;
    case OUTPUT_UNIX:
      write1(fh, CTRL_J);
      break;
    case OUTPUT_DOS:
      write1(fh, CTRL_M);
      write1(fh, CTRL_J);
      break;
    case OUTPUT_MAC:
      write1(fh, CTRL_M);
      break;
    case OUTPUT_SKIP:
      break;
  }
}

static int convert(int fh, int fh2, input_t *input_format, bool *rewrite, bool *binary, int include, output_t output_format) {
  int rv = 0;
  char c = -1;
  bool read_next_char = true;
  bool check_binary = true;
#ifdef CONV_SUPPORT_ENABLED
  bool first_line = true;
#endif /* CONV_SUPPORT_ENABLED */

  *input_format = INPUT_NONE;
  *rewrite = false;
  *binary = false;

#ifdef HAVE_SETMODE
  if (!isatty(fh))
    setmode(fh, O_BINARY);
  if (fh2 != -1)
    if (!isatty(fh2))
      setmode(fh2, O_BINARY);
#endif

  for (;;) {
    if (read_next_char)
      if ((rv = read1(fh, &c)) <= 0)
        break;

    /* Does the file contain ASCII 0x00-0x08, 0x0e-0x1f, or 0x7f ? */
    if (check_binary && iscntrl(c) && !isspace(c)) {
      /* A Ctrl-D or Ctrl-Z at the end of the file, does not make it a binary file */
      if (c == CTRL_D || c == CTRL_Z) {
        write1(fh2, c);
        if ((rv = read1(fh, &c)) <= 0)
          break;
      }
      *binary = true;
      if ((include & INPUT_BINARY) != INPUT_BINARY) {
        *rewrite = false;
        break;
      }
      check_binary = false;
    }

    read_next_char = true;

    switch (c) {
      case CTRL_J:
#ifdef CONV_SUPPORT_ENABLED
        if (first_line && opt._auto) {
          /* UNIX to DOS */
          output_format = OUTPUT_DOS;
          first_line = false;
        }
#endif /* CONV_SUPPORT_ENABLED */
        *input_format = (input_t) (*input_format | INPUT_UNIX);
        /* LF: rewrite if DOS or Mac */
        *rewrite |= (output_format & OUTPUT_DOS) | (output_format & OUTPUT_MAC);
        write_nl(fh2, CTRL_J, output_format);
        break;

      case CTRL_M:
        /* CR: rewrite if Unix */
        *rewrite |= (output_format & OUTPUT_UNIX);
        if ((rv = read1(fh, &c)) <= 0) {
          if (*input_format == INPUT_NONE)
            *input_format = (input_t) (*input_format | INPUT_MAC);
          *rewrite |= (output_format & OUTPUT_DOS);
          write_nl(fh2, CTRL_M, output_format);
          break;
        }

        if (c == CTRL_J) { /* CR / LF */
#ifdef CONV_SUPPORT_ENABLED
          if (first_line && opt._auto) {
            /* DOS to UNIX */
            output_format = OUTPUT_UNIX;
            first_line = false;
          }
#endif /* CONV_SUPPORT_ENABLED */

          *input_format = (input_t) (*input_format | INPUT_DOS);
          /* rewrite if Mac */
          *rewrite |= (output_format & OUTPUT_MAC);
          if (output_format == OUTPUT_LEAVE) {
            write1(fh2, CTRL_M);
            write1(fh2, CTRL_J);
            continue;
          }
          write_nl(fh2, CTRL_J, output_format);
          continue;
        }

#ifdef CONV_SUPPORT_ENABLED
        if (first_line && opt._auto) {
          /* MAC/varied to UNIX */
          output_format = OUTPUT_UNIX;
          first_line = false;
        }
#endif /* CONV_SUPPORT_ENABLED */

        *input_format = (input_t) (*input_format | INPUT_MAC);

        if (c != CTRL_M) { /* CR / not CR or LF */
          /* rewrite if Unix or DOS */
          *rewrite |= (output_format & OUTPUT_UNIX) | (output_format & OUTPUT_DOS);
          write_nl(fh2, CTRL_M, output_format);
          read_next_char = false;
          continue;
        }

        /* CR / CR, reading the 3rd character */
        if ((rv = read1(fh, &c)) <= 0) {
          /* rewrite if Unix or DOS */
          *rewrite |= (output_format & OUTPUT_UNIX) | (output_format & OUTPUT_DOS);
          write_nl(fh2, CTRL_M, output_format);
          write_nl(fh2, CTRL_M, output_format);
          break;
        }

        if (c == CTRL_J) { /* CR / CR / LF: bad perforce sync, treat as one EOL */
          *input_format = (input_t) (*input_format | INPUT_DOS);
          /* rewrite if Unix or DOS or Mac */
          *rewrite |= OUTPUT_UNIX | OUTPUT_DOS | OUTPUT_MAC;
          if (output_format == OUTPUT_LEAVE) {
            write1(fh2, CTRL_M);
            write1(fh2, CTRL_M);
            write1(fh2, CTRL_J);
            continue;
          }
          write_nl(fh2, CTRL_M, output_format);
          continue;
        }

        if (c == CTRL_M) { /* CR / CR / CR: must be a mac file, treat as three EOLs */
          /* rewrite if Unix or DOS */
          *rewrite |= (output_format & OUTPUT_UNIX) | (output_format & OUTPUT_DOS);
          write_nl(fh2, CTRL_M, output_format);
          write_nl(fh2, CTRL_M, output_format);
          write_nl(fh2, CTRL_M, output_format);
          continue;
        }

        /* CR / CR / not CR or LF: treat as two EOLs */
        *rewrite |= (output_format & OUTPUT_UNIX) | (output_format & OUTPUT_DOS);
        write_nl(fh2, CTRL_M, output_format);
        write_nl(fh2, CTRL_M, output_format);
        read_next_char = false;
        break;

      default:
        write1(fh2, c);
        break;
    }
  }

  return rv == -1 ? -1 : 0;
}

static int copy_file(char *src, char *dst, int dst_options) {
  int fh;
  int fh2;
  int rv = 0;

  fh = open(src, O_RDONLY | O_BINARY, 0600);
  if (fh == -1) {
    error("cannot open %s", src);
    return errno;
  }

  fh2 = open(dst, O_WRONLY | O_TRUNC | O_BINARY | dst_options, 0600);
  if (fh2 == -1) {
    error("cannot open %s", dst);
    close(fh);
    return errno;
  }

  for (;;) {
    char buf[BUFSIZ];
    ssize_t bytes;

    bytes = read(fh, buf, sizeof(buf));

    if (bytes < 0) {
      error("cannot read %s", src);
      rv = errno;
      break;
    }

    if (bytes == 0) /* EOF */
      break;

    if (write(fh2, buf, bytes) < 0) {
      error("cannot write to %s", dst);
      rv = errno;
      break;
    }
  }

  if (close(fh) == -1) {
    error("cannot close %s", src);
    rv = errno;
  }

  if (close(fh2) == -1) {
    error("cannot close %s", dst);
    rv = errno;
  }

  return rv;
}

static int preserve(char *name, struct stat *statbuf) {
  struct utimbuf utimebuf;
  int rv = 0;

  utimebuf.actime   = statbuf->st_atime;
  utimebuf.modtime  = statbuf->st_mtime;

  if (utime(name, &utimebuf) == -1) {
    rv |= errno;
    error("cannot set time for %s", name);
  }

#ifdef HAVE_CHOWN
  if (chown(name, statbuf->st_uid, statbuf->st_gid) == -1) {
    rv |= errno;
    if (opt.verbose >= 1)
      warning("cannot set ownership for %s", name);
  }
#endif

  if (chmod(name, statbuf->st_mode & 07777) == -1) {
    rv |= errno;
    error("cannot set rights for %s", name);
  }

  return rv;
}

struct _list {
  void      *data;
  struct _list  *next;
};

typedef struct _list List;

static List *list_new(void *data) {
  List *node = (List *) xalloc(sizeof(List));

  node->data = data;
  node->next = NULL;

  return node;
}

static List *list_last(List *node) {
  if (!node)
    return NULL;

  while (node->next)
    node = node->next;

  return node;
}

static List *list_append(List **head, void *data) {
  List *node = list_new(data);

  if (*head == NULL)
    *head = node;
  else {
    List *tail = list_last(*head);
    tail->next = node;
  }

  return node;
}

/*
static int list_count(List *node) {
  int rv = 0;

  while (node) {
    ++rv;
    node = node->next;
  }

  return rv;
}
*/

static void list_free(List *node) {
  while (node) {
    List *next = node->next;
    free(node);
    node = next;
  }
}

struct _file {
  char    *filespec;
  int     include;
  output_t  output_format;
};

typedef struct _file File;

static File *filespec_new(char *filespec, output_t output_format, int include) {
  File *node = (File *) xalloc(sizeof(File));

  node->filespec    = filespec;
  node->include   = include;
  node->output_format = output_format;

  return node;
}

static List *filespec_append(List **head, char *filespec, output_t output_format, int include, bool dont_alloc) {
  char *p;
  void *data;
  List *node = *head;

  if (dont_alloc)
    p = filespec;
  else
    p = xstrdup(filespec);

  data = (void *) filespec_new(p, output_format, include);
  if (strchr(p, '*') || strchr(p, '?')) {
    opt.wildcards_used = true;
  }

  while (node) {
    File *data = (File *) node->data;
    bool filespecs_equal;

    if (opt.ignore_case) {
        filespecs_equal = strcasecmp(data->filespec, filespec) == 0;
    } else {
        filespecs_equal = strcmp(data->filespec, filespec) == 0;
    }

    if (filespecs_equal) {
      /* free(data->filespec); */
      data->filespec = p;
      data->include = include;
      data->output_format = output_format;
      return node;
    }
    node = node->next;
  }

  return list_append(head, data);
}

static void filespec_free(List *head) {
  List *node = head;

  while (node) {
    File *data = (File *) node->data;
    free(data->filespec);
    node = node->next;
  }

  list_free(head);
}

static int process_directory(char *directory, List *file_list);

char *get_filename(char *filename, char *real_filename) {
  static char buf[PATH_MAX * 2 + 4];

  if (strcmp(filename, real_filename)) {
    sprintf(buf, "%s (%s)", filename, real_filename);
    return buf;
  }

  return filename;
}

static int process_file(char *filename, output_t output_format, int include, bool do_file, bool *is_directory) {
  int   fh;
  struct  stat statbuf;
  input_t input_format = INPUT_NONE;
  bool  rewrite = false;
  bool  binary  = false;
  bool  excluded = false;
  bool  do_write = (bool)(!(opt.dry_run || output_format == OUTPUT_LEAVE));

  char  backup_filename[PATH_MAX];
  char  real_filename[PATH_MAX];
  char  tmp_filename[PATH_MAX];

  strncpy(tmp_filename, filename, sizeof(tmp_filename));

#define DEBUG_STAT

#ifdef DEBUG_STAT
  _DBG("tmp_filename='%s'", tmp_filename);
#endif

  for (;;) {
    errno = 0;

#ifndef HAVE_LSTAT
    if (stat(tmp_filename, &statbuf) != -1)
      strncpy(real_filename, tmp_filename, sizeof(real_filename));
# ifdef DEBUG_STAT
    _DBG("real_filename='%s'", real_filename);
# endif
#else
    while (errno == 0) {
      if (lstat(tmp_filename, &statbuf) == -1)
        break;

      if (!S_ISLNK(statbuf.st_mode)) {
        strcpy(real_filename, tmp_filename);
        break;
      }

      memset(real_filename, 0, sizeof(real_filename)); /* Cygwin bugfix */
      if (readlink(tmp_filename, real_filename, sizeof(real_filename)) == -1)
        break;

# ifdef DEBUG_STAT
    _DBG("real_filename='%s'", real_filename);
# endif

      strncpy(tmp_filename, real_filename, sizeof(tmp_filename));
    }
#endif

    if (errno) {
      if (strcmp(filename, tmp_filename) == 0)
        error("cannot access %s", get_filename(filename, tmp_filename));
      break;
    }

    if ((statbuf.st_mode & S_IFDIR) == S_IFDIR) {
      *is_directory = true;
      errno = 0;
      break;
    }

    if (!do_file) {
      errno = 0;
      break;
    }

    if ((statbuf.st_mode & S_IFREG) != S_IFREG) {
      error("%s is not a regular file", filename);
      break;
    }

    if ((statbuf.st_mode & S_IRUSR) != S_IRUSR) {
      error("cannot read %s", filename);
      break;
    }

    if (do_write && (statbuf.st_mode & S_IWUSR) != S_IWUSR) {
      error("cannot write to %s", filename);
      break;
    }

    output_handle = -1;

    if (do_write) {
      char *dir;

      if (*opt.temp_dir) {
        dir = opt.temp_dir;
      } else {
        dir = dirname(filename);
        if (dir == NULL) {
          errno = ENAMETOOLONG;
          error("path too long: %s", filename);
          break;
        }

        if (!*dir)
          dir = ".";
      }

      strcpy(temp_filename, dir);
      if (strlen(temp_filename) + strlen(TEMP_FILE_TEMPLATE) > sizeof(temp_filename) - 1) {
        errno = ENAMETOOLONG;
        error("path too long: %s", filename);
        break;
      }

      strcat(temp_filename, TEMP_FILE_TEMPLATE);
      output_handle = mkstemps(temp_filename, TEMP_FILE_TEMPLATE_SUFFIX_LEN);
      if (output_handle == -1) {
        error("cannot open %s", temp_filename);
        break;
      }
    }

    fh = open(real_filename, O_RDONLY | O_BINARY, 0600);
    if (fh == -1) {
      int e = errno;
      error("cannot open %s", filename);
      if (do_write) {
        close(output_handle);
        output_handle = -1;
        unlink(temp_filename);
      }
      errno = e;
      break;
    }

    convert(fh, output_handle, &input_format, &rewrite, &binary, include, output_format);

    if (close(fh) == -1) {
      int e = errno;
      error("cannot close %s", filename);
      if (do_write) {
        close(output_handle);
        output_handle = -1;
        unlink(temp_filename);
      }
      errno = e;
      break;
    }

    if (input_format == INPUT_NONE) {
      rewrite = false;
      if (include != INPUT_ALL_ASCII)
        excluded = true;
    } else {
      if (binary) {
        if ((include & INPUT_BINARY) != INPUT_BINARY) {
          rewrite = false;
          excluded = true;
        }
      } else
        if (input_format == INPUT_UNIX || input_format == INPUT_DOS || input_format == INPUT_MAC) {
          if ((include & input_format) != input_format) {
            rewrite = false;
            excluded = true;
          }
        } else
          if ((include & INPUT_VARIED) != INPUT_VARIED) {
            rewrite = false;
            excluded = true;
          }
    }

    if (opt.force)
      rewrite = true;

    if (!excluded && !opt.quiet) {
      char *input_str;
      char *output_str;

      input_str = opt.verbose >= 2 ? input_descv[input_format] : input_desc[input_format];
      output_str = output_desc[rewrite ? output_format : OUTPUT_LEAVE];

      if (binary) {
        input_str = T_BINARY;
        if ((include & INPUT_BINARY) != INPUT_BINARY)
          output_str = T_UNCHANGED;
      }

      if (opt.verbose >= 1 || rewrite) {
        if (do_write || opt.dry_run)
          printf("%-13s: %-6s > %s\n", filename, input_str, output_str);
        else
          printf("%-13s: %-6s\n", filename, input_str);
      }
    }

    if (!do_write) {
      errno = 0;
      break;
    }

    if (close(output_handle) == -1) {
      int e = errno;
      error("cannot close %s", temp_filename);
      unlink(temp_filename);
      errno = e;
      break;
    }

    if (excluded || !rewrite) {
      if (unlink(temp_filename) == -1)
        if (errno != ENOENT) {
          error("cannot delete %s", temp_filename);
          /* ignore */
        }
      errno = 0;
      break;
    }

    if (opt.backup) {
      /* todo strip off file extension if 8.3 filesystem? */

      strcpy(backup_filename, filename);
      if (strlen(backup_filename) + strlen(opt.bak_ext) > sizeof(backup_filename) - 1) {
        errno = ENAMETOOLONG;
        error("path too long: %s", filename);
        break;
      }
      strcat(backup_filename, opt.bak_ext);

      if (unlink(backup_filename) == -1)
        if (errno != ENOENT) {
          warning("cannot delete %s", backup_filename);
          errno = 0;
          /* ignore */
        }
    }

    if (opt.in_place) {
      if (opt.backup)
        if (copy_file(filename, backup_filename, O_CREAT) != 0)
          break;

      if (copy_file(temp_filename, filename, 0) != 0) {
        if (opt.backup) {
          if (copy_file(backup_filename, filename, 0) == 0)
            unlink(backup_filename);
        }
        break;
      }

      if (unlink(temp_filename) == -1) {
        error("cannot delete %s", temp_filename);
        break;
      }
    } else { /* !opt.in_place */
      if (opt.backup) {
        if (rename(filename, backup_filename) == -1) {
          error("cannot rename %s to %s", filename, backup_filename);
          break;
        }
      } else {
        if (unlink(filename) == -1)
          if (errno != ENOENT) {
            warning("cannot delete %s", filename);
            errno = 0;
            /* ignore */
          }
      }

      if (rename(temp_filename, filename) == -1) {
        bool failed = true;
        if (*opt.temp_dir) {
          /* maybe rename failed because temp_dir is on another
             filesystem, so let's try to copy */
          failed = (bool) copy_file(temp_filename, filename, 0);
        }
        if (!failed) {
          if (opt.backup)
            rename(backup_filename, filename);
          error("cannot rename %s to %s", temp_filename, filename);
          break;
        }
      }
    } /* opt.in_place */

    if (opt.preserve)
      preserve(filename, &statbuf);

    break;
  }

  temp_filename[0] = '\0';

  return errno;
}

static int process_directory(char *directory, List *file_list) {
  DIR *dirp;
  int rv = 0;
  int fnmatch_flags = 0;

  List *dir_list = NULL;
  List *node;

  dirp = opendir(directory);

  if (dirp == NULL) {
    error("cannot read directory %s", directory);
    return 1;
  }

  if (opt.ignore_case) {
    fnmatch_flags |= FNM_CASEFOLD;
  } else {
    fnmatch_flags &= ~FNM_CASEFOLD;
  }

  for (;;) {
    struct dirent *dp;
    char *path;
    int len;
    File *file = NULL;
    bool is_directory = false;
    bool do_file;
    bool skip;
    output_t output_format = OUTPUT_LEAVE;

    errno = 0;
    dp = readdir(dirp);
    if (dp == NULL) {
      if (errno == 0)
        break;
      error("error reading directory %s", directory);
      break;
    }

    if (strcmp(dp->d_name, ".") == 0)
      continue;

    if (strcmp(dp->d_name, "..") == 0)
      continue;

    do_file = false;
    skip = false;
    node = file_list;
    while (node) {
      file = (File *) node->data;

      if (fnmatch(file->filespec, dp->d_name, fnmatch_flags) == FNM_NOMATCH) {
        node = node->next;
        continue;
      }

      if (file->output_format == OUTPUT_SKIP)
        skip = true;
      else
        do_file = true;

      output_format = file->output_format;
      break;
    }

    if (strcmp(directory, ".") == 0) {
      path = xstrdup(dp->d_name);
    } else {
      len = strlen(directory) + strlen(dp->d_name) + 1;

      if (len > PATH_MAX - 1) {
        errno = ENAMETOOLONG;
        error("path too long: %s/%s", directory, dp->d_name);
        continue;
      }

      path = (char *) xalloc(len + 1);

      sprintf(path, "%s/%s", directory, dp->d_name);
    }

    rv |= process_file(path, output_format, file->include, (bool) (do_file && !skip), &is_directory);

    if (is_directory && opt.recursive)
      filespec_append(&dir_list, path, file->output_format, file->include, true);
  }

  node = dir_list;
  while (node) {
    File *file = (File *) node->data;

    rv |= process_directory(file->filespec, file_list);

    node = node->next;
  }

  filespec_free(dir_list);

  closedir(dirp);

  return rv;
}

static void sighandler(int sig) {
  signal(sig, SIG_IGN);

  if (output_handle != -1)
    close(output_handle);
  if (*temp_filename && output_handle != fileno(stdout))
    unlink(temp_filename);

  if (sig == SIGINT)
    fprintf(stderr, "terminated by user");
  exit(EXIT_FAILURE);
}

static int process_filelist(List **file_list, char *filename) {
  FILE* fp;

  fp = fopen(filename, "rb");
  if (fp == NULL) {
    error("cannot open %s", filename);
    return errno;
  }

  for (;;) {
    char buf[BUFSIZ];
    char *pstart;
    char *pend;

    pstart = fgets(buf, sizeof(buf), fp);

    if (pstart == NULL) {
      if (ferror(fp)) {
        error("read error reading %s", filename);
        return errno;
      }
      fclose(fp);
      break;
    }

    pend = strstr(pstart, "//");
    if (pend)
      *pend = '\0';

    while (isspace(*pstart))
      ++pstart;
    if (!*pstart)
      continue;

    pend = pstart + strlen(pstart) - 1;
    while (isspace(*pend))
      --pend;
    ++pend;
    *pend = '\0';

    if (!*pstart)
    continue;

    filespec_append(file_list, pstart, opt.output_format, opt.include, false);
  }

  return 0;
}

static char* str_trim(char *p) {
  char *pend;

  while (isspace(*p))
    ++p;
  if (*p) {
    pend = p + strlen(p) - 1;
    while (isspace(*pend))
      --pend;
    ++pend;
    *pend = '\0';
  }

  return p;
}

static int process_options(List **file_list, int argc, char **argv);

#define COMMENT_DELIMETER "//"
#define TOKEN_DELIMETERS " \t"

static int process_envvar(List **file_list, char *envvar) {
  List *argv_list = NULL;
  int argc = 1;
  char **argv;
  List *node;
  char **p;

  char *pstart;
  char *pend;
  char *token;

  pstart = getenv(envvar);

  if (!pstart || !*pstart) {
    return 0;
  }

  pend = strstr(pstart, COMMENT_DELIMETER);
  if (pend)
    *pend = '\0';

  pstart = str_trim(pstart);

  if (strlen(pstart) == 0)
    return 0;

  token = strtok(pstart, TOKEN_DELIMETERS);

  while (token != NULL) {
    token = str_trim(token);

    if (strlen(token)) {
      ++argc;
      list_append(&argv_list, (void *) token);
    }

    token = strtok(NULL, TOKEN_DELIMETERS);
  }

  if (argc == 1)
    return 0;

  argv = (char **) xalloc((argc + 1) * sizeof(char *));
  p = argv;
  *p++ = progname;
  node = argv_list;
  while (node) {
    *p++ = (char *) node->data;
    node = node->next;
  }
  *p = NULL;

  process_options(file_list, argc, argv);

  free(argv);

  list_free(argv_list);

  return 0;
}

static int process_option_file(List **file_list, char *filename) {
  FILE* fp;
  List *argv_list = NULL;
  int argc = 1;
  char **argv;
  List *node;
  char **p;

  fp = fopen(filename, "rb");
  if (fp == NULL) {
    error("cannot open %s", filename);
    return errno;
  }

  for (;;) {
    char buf[BUFSIZ];
    char *pstart;
    char *pend;
    char *pnew;
    char *token;

    pstart = fgets(buf, sizeof(buf), fp);

    if (pstart == NULL) {
      if (ferror(fp)) {
        error("read error reading %s", filename);
        return errno;
      }
      fclose(fp);
      break;
    }

    pend = strstr(pstart, COMMENT_DELIMETER);
    if (pend)
      *pend = '\0';

    pstart = str_trim(pstart);

    if (strlen(pstart) == 0)
      continue;

    if (*pstart == '-') {
      pnew = xstrdup(pstart);
    } else {
      pnew = (char *) xalloc(strlen(pstart) + 3);
      strcpy(pnew, "--");
      strcat(pnew, pstart);
    }

    token = strtok(pnew, TOKEN_DELIMETERS);
    while (token != NULL) {
      token = str_trim(token);

      if (strlen(token)) {
        ++argc;
        list_append(&argv_list, (void *) xstrdup(token));
      }

      token = strtok(NULL, TOKEN_DELIMETERS);
    }

    free(pnew);
  }

  fclose(fp);

  if (argc == 1)
    return 0;

  argv = (char **) xalloc((argc + 1) * sizeof(char *));
  p = argv;
  *p++ = xstrdup(progname);
  node = argv_list;
  while (node) {
    *p++ = (char *) node->data;
    node = node->next;
  }
  *p = NULL;

  process_options(file_list, argc, argv);

  free(argv);

  node = argv_list;
  while (node) {
    free(node->data);
    node = node->next;
  }

  list_free(argv_list);

  return 0;
}

static bool opt_compare(char **optarg, char *option) {
  if (strcasecmp(*optarg, option) == 0) {
    (*optarg) += strlen(*optarg);
    return true;
  }

  if (*optarg[0] == option[0]) {
    (*optarg)++;
    return true;
  }

  return false;
}

static char *long_option_name(int c) {
  int i;

  for (i = 0; i < (sizeof(long_options) / sizeof(long_options[0])); ++i) {
    if (long_options[i].val == c) {
      return (char *) long_options[i].name;
    }
  }

  return NULL;
}

static void unimplemented_option(int c) {
  errno = 0;
  if (long_option_name(c)) {
    if (c > CHAR_MAX)
      error("%s %d (--%s)", UNIMPLEMENTED_OPTION, c, long_option_name(c));
    else
      error("%s -%c (--%s)", UNIMPLEMENTED_OPTION, c, long_option_name(c));
  } else {
    if (c > CHAR_MAX)
      error("%s %d", UNIMPLEMENTED_OPTION, c);
    else
      error("%s -%c", UNIMPLEMENTED_OPTION, c);
  }
  exit(EINVAL);
}

static bool process_filename(List **file_list, char *arg) {
  if (*arg == '@') {
    process_filelist(file_list, ++arg);
    return true;
  }

  filespec_append(file_list, arg, opt.output_format, opt.include, false);

  return true;
}

static int process_options(List **file_list, int argc, char **argv) {
  int last_optind = 0;
  int c = 0;

  /* turn off getopt's error messages */
  opterr = 0;
  optind = 1;
//  optreset = 1;

  while (optind < argc) {
    int option_index = 0;

//    if (optind <= last_optind)
//      optind = last_optind + 1;

    if (optind >= argc)
      break;

    if (last_optind < optind)
      last_optind = optind;

#if defined(__WINDOWS__)
    if (optind < argc && argv[optind] && argv[optind][0] == '/')
      argv[optind][0] = '-';
#endif

    c = getopt_long(argc, argv, short_options, long_options, &option_index);

    if (opterr) {
      usage(EINVAL);
    }

    if (c <= 1) {
      if (strcmp(argv[optind - 1], "--") == 0) {
        ++last_optind;
        for (; last_optind < argc; ++last_optind) {
          process_filename(file_list, argv[last_optind]);
        }
        break;
      }
      if (last_optind >= argc) {
        break;
      }
      process_filename(file_list, argv[last_optind]);
      ++optind;
      ++last_optind;
      continue;
    }

    for (; last_optind < optind - 1; ++last_optind) {
      if (*argv[last_optind] == '-') {
        continue;
      }
      process_filename(file_list, argv[last_optind]);
    }

#ifdef _DEBUG
    if (long_option_name(c)) {
      if (c > CHAR_MAX)
        _DBG("%s %d (--%s) (%s)", PROCESSING_OPTION, c, long_option_name(c), argv[optind - 1]);
      else
        _DBG("%s -%c (--%s) (%s)", PROCESSING_OPTION, c, long_option_name(c), argv[optind - 1]);
    } else {
      if (c > CHAR_MAX)
        _DBG("%s %d (%s)", PROCESSING_OPTION, c, argv[optind - 1]);
      else
        _DBG("%s -%c (%s)", PROCESSING_OPTION, c, argv[optind - 1]);
    }
#endif

    switch (c) {
      case '-': /* - */
        /* read from stdin */
        opt.std_in = true;
        break;
      case 'a': /* --abort */
        opt.abort = true;
        break;
      case 'b':   /* --backup */
        opt.backup = true;
        break;
      case 'c':   /* --compress */
        unimplemented_option(c);
        opt.compress = true;
        break;
      case 'd': /* --dos */
      case 'w': /* --windows (undocumented) */
        opt.output_format = OUTPUT_DOS;
#ifdef CONV_SUPPORT_ENABLED
        opt._auto = false;
#endif /* CONV_SUPPORT_ENABLED */
        break;
      case 'e': /* --exclude */
        while (optarg && *optarg) {
          _DBG("Processing exclude option %c (%s)", *optarg, optarg);
          if (opt_compare(&optarg, T_UNIX))
            opt.include &= ~INPUT_UNIX;
          else if (opt_compare(&optarg, T_DOS))
            opt.include &= ~INPUT_DOS;
          else if (opt_compare(&optarg, T_MAC))
            opt.include &= ~INPUT_MAC;
          else if (opt_compare(&optarg, T_VARIED))
            opt.include &= ~INPUT_VARIED;
          else if (opt_compare(&optarg, T_BINARY))
            opt.include &= ~INPUT_BINARY;
          else if (opt_compare(&optarg, T_ALL))
            opt.include = INPUT_NONE;
          else if (opt_compare(&optarg, T_NONE))
            opt.include = INPUT_ALL;
          else {
            errno = 0;
            error("invalid exclude option: %s", optarg);
            usage(EINVAL);
          }
        }
        break;
      case 'f': /* --force */
        opt.force = true;
        break;
      case 'g':   /* --config */
        process_option_file(file_list, optarg);
        break;
      /* case 'h': --help (undocumented) */
      case 'i': /* --include */
        while (optarg && *optarg) {
          _DBG("Processing include option %c (%s)", *optarg, optarg);
          if (opt_compare(&optarg, T_UNIX))
            opt.include |= INPUT_UNIX;
          else if (opt_compare(&optarg, T_DOS))
            opt.include |= INPUT_DOS;
          else if (opt_compare(&optarg, T_MAC))
            opt.include |= INPUT_MAC;
          else if (opt_compare(&optarg, T_VARIED))
            opt.include |= INPUT_VARIED;
          else if (opt_compare(&optarg, T_BINARY))
            opt.include |= INPUT_BINARY;
          else if (opt_compare(&optarg, T_ALL))
            opt.include = INPUT_ALL;
          else if (opt_compare(&optarg, T_NONE))
            opt.include = INPUT_NONE;
          else {
            errno = 0;
            error("invalid include option: %s", optarg);
            usage(EINVAL);
          }
        }
        break;
      case 'j': /* --in-place */
        opt.in_place = true;
        break;
      case 'k':   /* --backup-ext */
        if (strlen(optarg) >= sizeof(opt.bak_ext)) {
          errno = ENAMETOOLONG;
          error("backup-ext argument too long: '%s", optarg);
        } else
          strcpy(opt.bak_ext, optarg);
        break;
      case 'l':   /* --leave */
        opt.output_format = OUTPUT_LEAVE;
#ifdef CONV_SUPPORT_ENABLED
        opt._auto = false;
#endif /* CONV_SUPPORT_ENABLED */
        break;
      case 'm': /* --mac */
        opt.output_format = OUTPUT_MAC;
#ifdef CONV_SUPPORT_ENABLED
        opt._auto = false;
#endif /* CONV_SUPPORT_ENABLED */
        break;
      case 'n':   /* --native */
        opt.output_format = OUTPUT_NATIVE;
#ifdef CONV_SUPPORT_ENABLED
        opt._auto = false;
#endif /* CONV_SUPPORT_ENABLED */
        break;
      case 'o':   /* --output */
        if (strlen(optarg) >= PATH_MAX) {
          errno = ENAMETOOLONG;
          error("output argument too long: '%s", optarg);
        } else {
          if (strcmp(optarg, "-") == 0) {
            opt.std_out = true;
          } else {
            opt.std_out = false;
            strcpy(opt.output_filename, optarg);
          }
        }
        break;
      case 'p': /* --preserve */
        opt.preserve = true;
        break;
      case 'q': /* --quiet */
        opt.quiet = true;
        opt.verbose = 0;
        break;
      case 'r': /* --recursive */
        opt.recursive = true;
        break;
      case 's': /* --skip */
        opt.output_format = OUTPUT_SKIP;
        break;
      case 't':   /* --temp-dir */
        if (strlen(optarg) >= PATH_MAX - strlen(TEMP_FILE_TEMPLATE)) {
          errno = ENAMETOOLONG;
          error("temp-dir argument too long: '%s", optarg);
        } else
          strcpy(opt.temp_dir, optarg);
        break;
      case 'u': /* --unix */
        opt.output_format = OUTPUT_UNIX;
#ifdef CONV_SUPPORT_ENABLED
        opt._auto = false;
#endif /* CONV_SUPPORT_ENABLED */
        break;
      case 'v': /* --verbose */
        ++opt.verbose;
        opt.quiet = false;
        break;
      /* case 'w': --windows (undocumented) */
      case 'y': /* --dry-run */
        opt.dry_run = true;
        break;
      case 'z': /* --ignore_case */
        opt.ignore_case = true;
        break;
      case '?': /* --help */
      case 'h': /* --help (undocumented) */
        usage(EXIT_SUCCESS);
        break;
      case OPT_LICENSE:   /* --license */
        license();
        exit(EXIT_SUCCESS);
        break;
      case OPT_VERSION: /* --version */
        version();
        exit(EXIT_SUCCESS);
        break;

      /* negate options */
      case 'A': /* --no-abort */
        opt.abort = false;
        break;
      case 'B': /* --no-backup */
        opt.backup = false;
        break;
      case 'C':   /* --no-compress */
        unimplemented_option(c);
        opt.compress = false;
        break;
      case 'F': /* --no-force */
        opt.force = false;
        break;
      case 'K': /* --no-backup-ext */
        strcpy(opt.bak_ext, BACKUP_EXT);
        break;
      case 'J': /* --no-in-place */
        opt.in_place = false;
        break;
      case 'O': /* --no-output */
        strcpy(opt.output_filename, "");
        break;
      case 'P': /* --no-preserve */
        opt.preserve = false;
        break;
      case 'Q': /* --no-quiet */
        opt.quiet = false;
        break;
      case 'R': /* --no-recursive */
        opt.recursive = false;
        break;
      case 'T': /* --no-temp-dir */
        strcpy(opt.temp_dir, "");
        break;
      case 'V': /* --no-verbose */
        --opt.verbose;
        break;
      case 'Y': /* --no-dry-run */
        opt.dry_run = false;
        break;
      case 'Z': /* --no-ignore_case */
        opt.ignore_case = false;
        break;
#ifdef CONV_SUPPORT_ENABLED
      case OPT_AUTO:  /* --auto */
        opt._auto = true;
        break;
      case 'D': /* -D (conv_mode) */
        opt.output_format = OUTPUT_DOS;
        opt._auto = false;
        break;
      case OPT_FORCE: /* --force */
        opt.include |= INPUT_BINARY;
        break;
      case 'M': /* -M */
        opt.output_format = OUTPUT_MAC;
        opt._auto = false;
        break;
      case OPT_SAFE:  /* --safe */
        opt.include &= ~INPUT_BINARY;
        break;
      case 'U': /* -U */
        opt.output_format = OUTPUT_UNIX;
        opt._auto = false;
        break;
      case OPT_NO_AUTO: /* --no-auto */
        opt._auto = false;
        break;
      case OPT_NO_FORCE:  /* --no-force */
        opt.include &= ~INPUT_BINARY;
        break;
      case OPT_NO_SAFE: /* --no-safe */
        opt.include |= INPUT_BINARY;
        break;

#endif /* CONV_SUPPORT_ENABLED */
      case ':':
        error("Option -%c requires an operand\n", optopt);
        usage(EINVAL);
        break;
      default:
        errno = 0;
    error("invalid option: %c", c);
        usage(EINVAL);
    } /* switch (c) { */

  } /* while (optind < argc) { */

  if (opt.include == INPUT_NONE) {
    errno = 0;
    error("invalid include/exclude options");
    usage(EINVAL);
  }

  return 0;
}

int main(int argc, char **argv) {
  List *file_list = NULL;

#ifdef SIGABRT
  if (signal(SIGABRT, SIG_IGN) != SIG_IGN)
    signal(SIGABRT, sighandler);
#endif
#ifdef SIGHUP
  if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
    signal(SIGHUP, sighandler);
#endif
#ifdef SIGINT
  if (signal(SIGINT, SIG_IGN) != SIG_IGN)
    signal(SIGINT, sighandler);
#endif
#ifdef SIGPIPE
  if (signal(SIGPIPE, SIG_IGN) != SIG_IGN)
    signal(SIGPIPE, sighandler);
#endif
#ifdef SIGQUIT
  if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
    signal(SIGQUIT, sighandler);
#endif
#ifdef SIGTERM
  if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
    signal(SIGTERM, sighandler);
#endif

  progname = basename(argv[0]);

  if (progname) {
#ifdef __DOS__
    int len = strlen(progname);
    if (len > 4 && strcasecmp(progname + len - 4, ".exe") == 0)
      progname[len - 4] = '\0';
#endif
#ifdef CONV_SUPPORT_ENABLED
    if (strcasecmp(progname, "conv") == 0) {
      opt.conv_mode = true;
    }
#endif /* CONV_SUPPORT_ENABLED */

    if (strcasecmp(progname, "dos2unix") == 0 ||
      strcasecmp(progname, "d2u") == 0 ||
      strcasecmp(progname, "m2u") == 0) {
      opt.output_format = OUTPUT_UNIX;
#ifdef CONV_SUPPORT_ENABLED
      opt.conv_mode = true;
#endif /* CONV_SUPPORT_ENABLED */
    }

    if (strcasecmp(progname, "unix2dos") == 0 ||
      strcasecmp(progname, "u2d") == 0 ||
      strcasecmp(progname, "m2d") == 0) {
      opt.output_format = OUTPUT_DOS;
#ifdef CONV_SUPPORT_ENABLED
      opt.conv_mode = true;
#endif /* CONV_SUPPORT_ENABLED */
    }

    if (strcasecmp(progname, "unix2mac") == 0 ||
      strcasecmp(progname, "dos2mac") == 0 ||
      strcasecmp(progname, "u2m") == 0 ||
      strcasecmp(progname, "d2m") == 0) {
      opt.output_format = OUTPUT_MAC;
#ifdef CONV_SUPPORT_ENABLED
      opt.conv_mode = true;
#endif /* CONV_SUPPORT_ENABLED */
    }
  }

  process_envvar(&file_list, EOLFIX_ENVVAR);

  process_options(&file_list, argc, argv);

  /* @todo fixme
  if (file_list == NULL && !isatty(fileno(stdin))) {
    opt.std_in = true;
  }
  */

  /* user specified - on the command line, so let's process stdin */
  if (opt.std_in) {
    int fh;
    input_t input_format = INPUT_NONE;
    bool rewrite;
    bool binary;

    fh = fileno(stdin);

    input_filename = "<standard input>";

    if (*opt.output_filename) {
      strcpy(temp_filename, opt.output_filename);
      output_handle = open(temp_filename, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, 0600);
      if (output_handle == -1) {
        error("cannot open %s", temp_filename);
        close(output_handle);
        return errno;
      }
    } else {
      opt.std_out = true;
      output_handle = fileno(stdout);
      strcpy(temp_filename, "<standard ouput>");
    }

    /* since we're processing standard input we should not abort if there
       is binary data in the stream */
    convert(fh, output_handle, &input_format, &rewrite, &binary, INPUT_BINARY, opt.output_format);

    if (close(fh) == -1)
      error("cannot close %s", input_filename);

    if (close(output_handle) == -1)
      error("cannot close %s", temp_filename);

    return exit_value;
  }

  if (file_list == NULL) {
    filespec_append(&file_list, "*", opt.output_format, opt.include, false);
  }

  if (opt.wildcards_used) {
    _DBG("Calling process_directory(\".\", file_list)");
    process_directory(".", file_list);
  } else {
    List *node;

    node = file_list;
    while (node) {
      bool is_directory = false;
      File *file = (File *) node->data;

      process_file(file->filespec, file->output_format, file->include, true, &is_directory);

      node = node->next;
    }

    if (opt.recursive)
      process_directory(".", file_list);
  }

  filespec_free(file_list);

  _DBG("returning %d", exit_value);
  return exit_value;
}