压缩解压

开发平台：
MultiPlatform

amiga.c：源码内容
							/*------------------------------------------------------------------------
  amiga.c
  Amiga-specific routines for use with Info-ZIP's UnZip 5.1 and later.
  See History.5xx for revision history.
  Contents:   do_wild()
              mapattr()
              mapname()
              checkdir()
              close_outfile()
              stamp_file()
              _abort()                (Aztec C only)
             [dateformat()]           (currently not used)
              windowheight()
              version()
  ------------------------------------------------------------------------*/
#define UNZIP_INTERNAL
#ifdef AZTEC_C
#  define NO_FCNTL_H
#endif
#include "unzip.h"
/* Globular varibundus -- now declared in SYSTEM_SPECIFIC_GLOBALS in amiga.h */
/* static int created_dir; */      /* used in mapname(), checkdir() */
/* static int renamed_fullpath; */ /* ditto */
#define PERMS   0777
#define MKDIR(path,mode) mkdir(path)
#ifndef S_ISCRIPT          /* not having one implies you have none */
#  define S_IARCHIVE 0020  /* not modified since this bit was last set */
#  define S_IREAD    0010  /* can be opened for reading */
#  define S_IWRITE   0004  /* can be opened for writing */
#  define S_IDELETE  0001  /* can be deleted */
#endif /* S_ISCRIPT */
#ifndef S_IRWD
#  define S_IRWD     0015  /* useful combo of Amiga privileges */
#endif /* !S_IRWD */
#ifndef S_IHIDDEN
#  define S_IHIDDEN  0200  /* hidden supported in future AmigaDOS (someday) */
#endif /* !S_HIDDEN */
#ifndef SFX
/* Make sure the number here matches version.h in the *EXACT* form */
/* UZ_MAJORVER "." UZ_MINORVER PATCHLEVEL vvvv     No non-digits!  */
const char version_id[]  = "$VER: UnZip 5.4 ("
#include "env:VersionDate"
   ")rn";
#endif /* SFX */
static int ispattern(char *p)
{
    register char c;
    while (c = *p++)
        if (c == '\') {
            if (!*++p)
                return FALSE;
        } else if (c == '?' || c == '*')
            return TRUE;
        else if (c == '[') {
            for (;;) {
                if (!(c = *p++))
                    return FALSE;
                else if (c == '\') {
                    if (!*++p)
                        return FALSE;
                } else if (c == ']')
                    return TRUE;
            }
        }
    return FALSE;
}
/**********************/
/* Function do_wild() */
/**********************/
char *do_wild(__G__ wildspec)
    __GDEF
    char *wildspec;         /* only used first time on a given dir */
{
/* these statics are now declared in SYSTEM_SPECIFIC_GLOBALS in amiga.h:
    static DIR *wild_dir = NULL;
    static char *dirname, *wildname, matchname[FILNAMSIZ];
    static int notfirstcall = FALSE, dirnamelen;
*/
    struct dirent *file;
    BPTR lok = 0;
    /* Even when we're just returning wildspec, we *always* do so in
     * matchname[]--calling routine is allowed to append four characters
     * to the returned string, and wildspec may be a pointer to argv[].
     */
    if (!G.notfirstcall) {      /* first call:  must initialize everything */
        G.notfirstcall = TRUE;
        /* avoid needless readdir() scans: */
        if (!ispattern(wildspec) || (lok = Lock(wildspec, ACCESS_READ))) {
            if (lok) UnLock(lok);       /* ^^ we ignore wildcard chars if */
            G.dirnamelen = 0;           /* the name matches a real file   */
            strcpy(G.matchname, wildspec);
            return G.matchname;
        }
        /* break the wildspec into a directory part and a wildcard filename */
        if ((G.wildname = strrchr(wildspec, '/')) == NULL
                        && (G.wildname = strrchr(wildspec, ':')) == NULL) {
            G.dirname = "";             /* current dir */
            G.dirnamelen = 0;
            G.wildname = wildspec;
        } else {
            ++G.wildname;     /* point at character after '/' or ':' */
            G.dirnamelen = G.wildname - wildspec;
            if ((G.dirname = (char *)malloc(G.dirnamelen+1)) == NULL) {
                Info(slide, 1, ((char *)slide,
                     "warning:  cannot allocate wildcard buffersn"));
                strcpy(G.matchname, wildspec);
                return G.matchname; /* but maybe filespec was not a wildcard */
            }
            strncpy(G.dirname, wildspec, G.dirnamelen);
            G.dirname[G.dirnamelen] = 0;
        }
        if ((G.wild_dir = opendir(G.dirname)) != NULL) {
            while ((file = readdir(G.wild_dir)) != NULL) {
                if (match(file->d_name, G.wildname, 1)) {  /* ignore case */
                    strcpy(G.matchname, G.dirname);
                    strcpy(G.matchname + G.dirnamelen, file->d_name);
                    return G.matchname;
                }
            }
            /* if we get to here directory is exhausted, so close it */
            closedir(G.wild_dir);
            G.wild_dir = NULL;
        }
        /* return the raw wildspec in case that works (e.g., directory not
         * searchable, but filespec was not wild and file is readable) */
        strcpy(G.matchname, wildspec);
        return G.matchname;
    }
    /* last time through, might have failed opendir but returned raw wildspec */
    if (G.wild_dir == NULL) {
        G.notfirstcall = FALSE;    /* nothing left to try -- reset */
        if (G.dirnamelen > 0)
            free(G.dirname);
        return (char *)NULL;
    }
    /* If we've gotten this far, we've read and matched at least one entry
     * successfully (in a previous call), so dirname has been copied into
     * matchname already.
     */
    while ((file = readdir(G.wild_dir)) != NULL)
        if (match(file->d_name, G.wildname, 1)) {   /* 1 == ignore case */
            /* strcpy(G.matchname, dirname); */
            strcpy(G.matchname + G.dirnamelen, file->d_name);
            return G.matchname;
        }
    closedir(G.wild_dir);  /* have read at least one dir entry; nothing left */
    G.wild_dir = NULL;
    G.notfirstcall = FALSE;  /* reset for new wildspec */
    if (G.dirnamelen > 0)
        free(G.dirname);
    return (char *)NULL;
} /* end function do_wild() */
/**********************/
/* Function mapattr() */
/**********************/
int mapattr(__G)      /* Amiga version */
    __GDEF
{
    ulg  tmp = G.crec.external_file_attributes;
    /* Amiga attributes = hsparwed = hidden, script, pure, archive,
     * read, write, execute, delete */
    switch (G.pInfo->hostnum) {
        case AMIGA_:
            if ((tmp & 1) == (tmp>>18 & 1))
                tmp ^= 0x000F0000;      /* PKAZip compatibility kluge */
            /* turn off archive bit for restored Amiga files */
            G.pInfo->file_attr = (unsigned)((tmp>>16) & (~S_IARCHIVE));
            break;
        case UNIX_:   /* preserve read, write, execute:  use logical-OR of */
        case VMS_:    /* user, group, and other; if writable, set delete bit */
        case ACORN_:
        case ATARI_:
        case BEOS_:
        case QDOS_:
        case TANDEM_:
            {
              unsigned uxattr = (unsigned)(tmp >> 16);
              int r = FALSE;
              if (uxattr == 0 && G.extra_field) {
                /* Some (non-Info-ZIP) implementations of Zip for Unix and
                   VMS (and probably others ??) leave 0 in the upper 16-bit
                   part of the external_file_attributes field. Instead, they
                   store file permission attributes in some extra field.
                   As a work-around, we search for the presence of one of
                   these extra fields and fall back to the MSDOS compatible
                   part of external_file_attributes if one of the known
                   e.f. types has been detected.
                   Later, we might implement extraction of the permission
                   bits from the VMS extra field. But for now, the work-around
                   should be sufficient to provide "readable" extracted files.
                   (For ASI Unix e.f., an experimental remap of the e.f.
                   mode value IS already provided!)
                 */
                ush ebID;
                unsigned ebLen;
                uch *ef = G.extra_field;
                unsigned ef_len = G.crec.extra_field_length;
                while (!r && ef_len >= EB_HEADSIZE) {
                    ebID = makeword(ef);
                    ebLen = (unsigned)makeword(ef+EB_LEN);
                    if (ebLen > (ef_len - EB_HEADSIZE))
                        /* discoverd some e.f. inconsistency! */
                        break;
                    switch (ebID) {
                      case EF_ASIUNIX:
                        if (ebLen >= (EB_ASI_MODE+2)) {
                            uxattr =
                              (unsigned)makeword(ef+(EB_HEADSIZE+EB_ASI_MODE));
                            /* force stop of loop: */
                            ef_len = (ebLen + EB_HEADSIZE);
                            break;
                        }
                        /* else: fall through! */
                      case EF_PKVMS:
                        /* "found nondecypherable e.f. with perm. attr" */
                        r = TRUE;
                      default:
                        break;
                    }
                    ef_len -= (ebLen + EB_HEADSIZE);
                    ef += (ebLen + EB_HEADSIZE);
                }
              }
              if (!r) {
                uxattr = (( uxattr>>6 | uxattr>>3 | uxattr) & 07) << 1;
                G.pInfo->file_attr = (unsigned)(uxattr&S_IWRITE ?
                                                uxattr|S_IDELETE : uxattr);
                break;
              }
            }
            /* fall through! */
        /* all other platforms:  assume read-only bit in DOS half of attribute
         * word is set correctly ==> will become READ or READ+WRITE+DELETE */
        case FS_FAT_:
        case FS_HPFS_:  /* can add S_IHIDDEN check to MSDOS/OS2/NT eventually */
        case FS_NTFS_:
        case MAC_:
        case TOPS20_:
        default:
            G.pInfo->file_attr = (unsigned)(tmp&1? S_IREAD : S_IRWD);
            break;
    } /* end switch (host-OS-created-by) */
    G.pInfo->file_attr &= 0xff;   /* mask off all but lower eight bits */
    return 0;
} /* end function mapattr() */
/************************/
/*  Function mapname()  */
/************************/
int mapname(__G__ renamed)  /* return 0 if no error, 1 if caution (truncate), */
    __GDEF                  /* 2 if warning (skip because dir doesn't exist), */
    int renamed;            /* 3 if error (skip file), 10 if no memory (skip) */
{                           /*  [also IZ_VOL_LABEL, IZ_CREATED_DIR] */
    char pathcomp[FILNAMSIZ];   /* path-component buffer */
    char *pp, *cp=NULL;         /* character pointers */
    char *lastsemi = NULL;      /* pointer to last semi-colon in pathcomp */
    int error = 0;
    register unsigned workch;   /* hold the character being tested */
/*---------------------------------------------------------------------------
    Initialize various pointers and counters and stuff.
  ---------------------------------------------------------------------------*/
    if (G.pInfo->vollabel)
        return IZ_VOL_LABEL;    /* can't set disk volume labels in AmigaDOS */
    /* can create path as long as not just freshening, or if user told us */
    G.create_dirs = (!uO.fflag || renamed);
    G.created_dir = FALSE;      /* not yet */
    /* user gave full pathname:  don't prepend G.rootpath */
#ifndef OLD_AMIGA_RENAMED
    G.renamed_fullpath = (renamed &&
                          (*G.filename == '/' || *G.filename == ':'));
#else
    /* supress G.rootpath even when user gave a relative pathname */
# if 1
    G.renamed_fullpath = (renamed && strpbrk(G.filename, ":/");
# else
    G.renamed_fullpath = (renamed &&
                          (strchr(G.filename, ':') || strchr(G.filename, '/')));
# endif
#endif
    if (checkdir(__G__ (char *)NULL, INIT) == 10)
        return 10;              /* initialize path buffer, unless no memory */
    *pathcomp = '';           /* initialize translation buffer */
    pp = pathcomp;              /* point to translation buffer */
    if (uO.jflag)               /* junking directories */
        cp = (char *)strrchr(G.filename, '/');
    if (cp == NULL)             /* no '/' or not junking dirs */
        cp = G.filename;        /* point to internal zipfile-member pathname */
    else
        ++cp;                   /* point to start of last component of path */
/*---------------------------------------------------------------------------
    Begin main loop through characters in filename.
  ---------------------------------------------------------------------------*/
    while ((workch = (uch)*cp++) != 0) {
        switch (workch) {
        case '/':             /* can assume -j flag not given */
            *pp = '';
            if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1)
                return error;
            pp = pathcomp;    /* reset conversion buffer for next piece */
            lastsemi = NULL;  /* leave directory semi-colons alone */
            break;
        case ';':             /* VMS version (or DEC-20 attrib?) */
            lastsemi = pp;         /* keep for now; remove VMS ";##" */
            *pp++ = (char)workch;  /*  later, if requested */
            break;
        default:
            /* allow ISO European characters in filenames: */
            if (isprint(workch) || (160 <= workch && workch <= 255))
                *pp++ = (char)workch;
        } /* end switch */
    } /* end while loop */
    *pp = '';                   /* done with pathcomp:  terminate it */
    /* if not saving them, remove with VMS version numbers (appended ";###") */
    if (!uO.V_flag && lastsemi) {
        pp = lastsemi + 1;
        while (isdigit((uch)(*pp)))
            ++pp;
        if (*pp == '')          /* only digits between ';' and end:  nuke */
            *lastsemi = '';
    }
/*---------------------------------------------------------------------------
    Report if directory was created (and no file to create:  filename ended
    in '/'), check name to be sure it exists, and combine path and name be-
    fore exiting.
  ---------------------------------------------------------------------------*/
    if (G.filename[strlen(G.filename) - 1] == '/') {
        checkdir(__G__ G.filename, GETPATH);
        if (G.created_dir) {
            if (QCOND2) {
                Info(slide, 0, ((char *)slide, "   creating: %sn",
                  G.filename));
            }
            return IZ_CREATED_DIR;   /* set dir time (note trailing '/') */
        }
        return 2;   /* dir existed already; don't look for data to extract */
    }
    if (*pathcomp == '') {
        Info(slide, 1, ((char *)slide, "mapname:  conversion of %s failedn",
             G.filename));
        return 3;
    }
    if ((error = checkdir(__G__ pathcomp, APPEND_NAME)) == 1) {
        /* GRR:  OK if truncated here:  warn and continue */
        /* (warn in checkdir?) */
    }
    checkdir(__G__ G.filename, GETPATH);
    return error;
} /* end function mapname() */
/***********************/
/* Function checkdir() */
/***********************/
int checkdir(__G__ pathcomp, flag)
    __GDEF
    char *pathcomp;
    int flag;
/*
 * returns:  1 - (on APPEND_xxx) truncated path component
 *           2 - path doesn't exist, not allowed to create
 *           3 - path doesn't exist, tried to create and failed; or
 *               path exists and is not a directory, but is supposed to be
 *           4 - path is too long
 *          10 - can't allocate memory for filename buffers
 */
{
/* these statics are now declared in SYSTEM_SPECIFIC_GLOBALS in amiga.h: */
/*  static int rootlen = 0; */   /* length of rootpath */
/*  static char *rootpath;  */   /* user's "extract-to" directory */
/*  static char *buildpath; */   /* full path (so far) to extracted file */
/*  static char *end;       */   /* pointer to end of buildpath ('') */
#   define FN_MASK   7
#   define FUNCTION  (flag & FN_MASK)
/*---------------------------------------------------------------------------
    APPEND_DIR:  append the path component to the path being built and check
    for its existence.  If doesn't exist and we are creating directories, do
    so for this one; else signal success or error as appropriate.
  ---------------------------------------------------------------------------*/
/* GRR:  check path length after each segment:  warn about truncation */
    if (FUNCTION == APPEND_DIR) {
        int too_long = FALSE;
        Trace((stderr, "appending dir segment [%s]n", pathcomp));
        while ((*G.build_end = *pathcomp++))
            ++G.build_end;
        /* Truncate components over 30 chars? Nah, the filesystem handles it. */
        if ((G.build_end-G.buildpath) > FILNAMSIZ-3)       /* room for "/a" */
            too_long = TRUE;                /* check if extracting directory? */
        if (stat(G.buildpath, &G.statbuf)) {  /* path doesn't exist */
            if (!G.create_dirs) { /* told not to create (freshening) */
                free(G.buildpath);
                return 2;         /* path doesn't exist:  nothing to do */
            }
            if (too_long) {
                Info(slide, 1, ((char *)slide,
                  "checkdir error:  path too long: %sn", G.buildpath));
                free(G.buildpath);
                return 4;         /* no room for filenames:  fatal */
            }
            if (MKDIR(G.buildpath, 0777) == -1) {   /* create the directory */
                Info(slide, 1, ((char *)slide,
                 "checkdir error:  cannot create %sn
                 unable to process %s.n", G.buildpath, G.filename));
                free(G.buildpath);
                return 3;      /* path didn't exist, tried to create, failed */
            }
            G.created_dir = TRUE;
        } else if (!S_ISDIR(G.statbuf.st_mode)) {
            Info(slide, 1, ((char *)slide,
                 "checkdir error:  %s exists but is not a directoryn
                 unable to process %s.n", G.buildpath, G.filename));
            free(G.buildpath);
            return 3;          /* path existed but wasn't dir */
        }
        if (too_long) {
            Info(slide, 1, ((char *)slide,
                 "checkdir error:  path too long: %sn", G.buildpath));
            free(G.buildpath);
            return 4;         /* no room for filenames:  fatal */
        }
        *G.build_end++ = '/';
        *G.build_end = '';
        Trace((stderr, "buildpath now = [%s]n", G.buildpath));
        return 0;
    } /* end if (FUNCTION == APPEND_DIR) */
/*---------------------------------------------------------------------------
    GETPATH:  copy full path to the string pointed at by pathcomp, and free
    G.buildpath.  Not our responsibility to worry whether pathcomp has room.
  ---------------------------------------------------------------------------*/
    if (FUNCTION == GETPATH) {
        strcpy(pathcomp, G.buildpath);
        Trace((stderr, "getting and freeing path [%s]n", pathcomp));
        free(G.buildpath);
        G.buildpath = G.build_end = NULL;
        return 0;
    }
/*---------------------------------------------------------------------------
    APPEND_NAME:  assume the path component is the filename; append it and
    return without checking for existence.
  ---------------------------------------------------------------------------*/
    if (FUNCTION == APPEND_NAME) {
        Trace((stderr, "appending filename [%s]n", pathcomp));
        while ((*G.build_end = *pathcomp++)) {
            ++G.build_end;
            if ((G.build_end-G.buildpath) >= FILNAMSIZ) {
                *--G.build_end = '';
                Info(slide, 1, ((char *)slide,
                   "checkdir warning:  path too long; truncatingn
                   %sn                -> %sn", G.filename, G.buildpath));
                return 1;   /* filename truncated */
            }
        }
        Trace((stderr, "buildpath static now = [%s]n", G.buildpath));
        return 0;  /* could check for existence here, prompt for new name... */
    }
/*---------------------------------------------------------------------------
    INIT:  allocate and initialize buffer space for the file currently being
    extracted.  If file was renamed with an absolute path, don't prepend the
    extract-to path.
  ---------------------------------------------------------------------------*/
    if (FUNCTION == INIT) {
        Trace((stderr, "initializing buildpath static to "));
        if ((G.buildpath = (char *)malloc(strlen(G.filename)+G.rootlen+1))
              == NULL)
            return 10;
        if ((G.rootlen > 0) && !G.renamed_fullpath) {
            strcpy(G.buildpath, G.rootpath);
            G.build_end = G.buildpath + G.rootlen;
        } else {
            *G.buildpath = '';
            G.build_end = G.buildpath;
        }
        Trace((stderr, "[%s]n", G.buildpath));
        return 0;
    }
/*---------------------------------------------------------------------------
    ROOT:  if appropriate, store the path in G.rootpath and create it if
    necessary; else assume it's a zipfile member and return.  This path
    segment gets used in extracting all members from every zipfile specified
    on the command line.
  ---------------------------------------------------------------------------*/
#if (!defined(SFX) || defined(SFX_EXDIR))
    if (FUNCTION == ROOT) {
        Trace((stderr, "initializing root path to [%s]n", pathcomp));
        if (pathcomp == NULL) {
            G.rootlen = 0;
            return 0;
        }
        if ((G.rootlen = strlen(pathcomp)) > 0) {
            if (stat(pathcomp, &G.statbuf) || !S_ISDIR(G.statbuf.st_mode)) {
                /* path does not exist */
                if (!G.create_dirs) {
                    G.rootlen = 0;
                    return 2;   /* treat as stored file */
                }
                /* create the directory (could add loop here to scan pathcomp
                 * and create more than one level, but why really necessary?) */
                if (MKDIR(pathcomp, 0777) == -1) {
                    Info(slide, 1, ((char *)slide,
                         "checkdir:  cannot create extraction directory: %sn",
                         pathcomp));
                    G.rootlen = 0; /* path didn't exist, tried to create, and */
                    return 3;  /* failed:  file exists, or 2+ levels required */
                }
            }
            if ((G.rootpath = (char *)malloc(G.rootlen+2)) == NULL) {
                G.rootlen = 0;
                return 10;
            }
            strcpy(G.rootpath, pathcomp);
            if (G.rootpath[G.rootlen-1] != ':' && G.rootpath[G.rootlen-1] != '/')
                G.rootpath[G.rootlen++] = '/';
            G.rootpath[G.rootlen] = '';
            Trace((stderr, "rootpath now = [%s]n", G.rootpath));
        }
        return 0;
    }
#endif /* !SFX || SFX_EXDIR */
/*---------------------------------------------------------------------------
    END:  free G.rootpath, immediately prior to program exit.
  ---------------------------------------------------------------------------*/
    if (FUNCTION == END) {
        Trace((stderr, "freeing rootpathn"));
        if (G.rootlen > 0) {
            free(G.rootpath);
            G.rootlen = 0;
        }
        return 0;
    }
    return 99;  /* should never reach */
} /* end function checkdir() */
/**************************************/
/* Function close_outfile() */
/**************************************/
/* this part differs slightly with Zip */
/*-------------------------------------*/
void close_outfile(__G)
    __GDEF
{
    time_t m_time;
#ifdef USE_EF_UT_TIME
    iztimes z_utime;
#endif
    LONG FileDate();
    if (uO.cflag)               /* can't set time or filenote on stdout */
        return;
  /* close the file *before* setting its time under AmigaDOS */
    fclose(G.outfile);
#ifdef USE_EF_UT_TIME
    if (G.extra_field &&
#ifdef IZ_CHECK_TZ
        G.tz_is_valid &&
#endif
        (ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0,
                          G.lrec.last_mod_dos_datetime, &z_utime, NULL)
         & EB_UT_FL_MTIME))
    {
        TTrace((stderr, "close_outfile:  Unix e.f. modif. time = %ldn",
                         z_utime.mtime));
        m_time = z_utime.mtime;
    } else {
        /* Convert DOS time to time_t format */
        m_time = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
    }
#else /* !USE_EF_UT_TIME */
    /* Convert DOS time to time_t format */
    m_time = dos_to_unix_time(G.lrec.last_mod_dos_datetime);
#endif /* ?USE_EF_UT_TIME */
#ifdef DEBUG
    Info(slide, 1, ((char *)slide, "nclose_outfile(): m_time=%sn",
                         ctime(&m_time)));
#endif
    if (!FileDate(G.filename, &m_time))
        Info(slide, 1, ((char *)slide,
             "warning:  cannot set the time for %sn", G.filename));
  /* set file perms after closing (not done at creation)--see mapattr() */
    chmod(G.filename, G.pInfo->file_attr);
  /* give it a filenote from the zipfile comment, if appropriate */
    if (uO.N_flag && G.filenotes[G.filenote_slot]) {
        SetComment(G.filename, G.filenotes[G.filenote_slot]);
        free(G.filenotes[G.filenote_slot]);
        G.filenotes[G.filenote_slot] = NULL;
    }
} /* end function close_outfile() */
#ifdef TIMESTAMP
/*************************/
/* Function stamp_file() */
/*************************/
int stamp_file(fname, modtime)
    ZCONST char *fname;
    time_t modtime;
{
    time_t m_time;
    LONG FileDate();
    m_time = modtime;
    return (FileDate((char *)fname, &m_time));
} /* end function stamp_file() */
#endif /* TIMESTAMP */
#ifndef __SASC
/********************************************************************/
/* Load filedate as a separate external file; it's used by Zip, too.*/
/*                                                                  */
#  include "amiga/filedate.c"                                    /* */
/*                                                                  */
/********************************************************************/
/********************* do linewise with stat.c **********************/
#  include "amiga/stat.c"
/* this is the exact same stat.c used by Zip */
#endif /* !__SASC */
/* SAS/C makes separate object modules of these; there is less  */
/* trouble that way when redefining standard library functions. */
#include <stdio.h>
void _abort(void)               /* called when ^C is pressed */
{
    /* echon(); */
    close_leftover_open_dirs();
    fflush(stdout);
    fputs("n^Cn", stderr);
    exit(1);
}
/**************************************************************/
/* function windowheight() -- uses sendpkt() from filedate.c: */
/**************************************************************/
#include <devices/conunit.h>
#include <dos/dosextens.h>
#include <exec/memory.h>
#include <clib/exec_protos.h>
extern long sendpkt(struct MsgPort *pid, long action, long *args, long nargs);
int windowheight(BPTR fh)
{
    if (fh && IsInteractive(fh)) {
        struct ConUnit *conunit = NULL;
        void *conp = ((struct FileHandle *) (fh << 2))->fh_Type;
        struct InfoData *ind = AllocMem(sizeof(*ind), MEMF_PUBLIC);
        long argp = ((unsigned long) ind) >> 2;
        if (ind && conp && sendpkt(conp, ACTION_DISK_INFO, &argp, 1))
            conunit = (void *) ((struct IOStdReq *) ind->id_InUse)->io_Unit;
        if (ind)
            FreeMem(ind, sizeof(*ind));
        if (conunit)
            return conunit->cu_YMax + 1;
    }
    return INT_MAX;
}
#ifdef AMIGA_VOLUME_LABELS
/* This function is for if we someday implement -$ on the Amiga. */
#  include <dos/dosextens.h>
#  include <dos/filehandler.h>
#  include <clib/macros.h>
BOOL is_floppy(char *path)
{
    BOOL okay = FALSE;
    char devname[32], *debna;
    ushort i;
    BPTR lok = Lock(path, ACCESS_READ), pok;
    struct FileSysStartupMsg *fart;
    struct DeviceNode *debb, devlist = (void *) BADDR((struct DosInfo *)
                                BADDR(DOSBase->dl_Root->rn_Info)->di_DevInfo);
    if (!lok)
        return FALSE;                   /* should not happen */
    if (pok = ParentDir(path)) {
        UnLock(lok);
        UnLock(pok);
        return FALSE;                   /* it's not a root directory path */
    }
    Forbid();
    for (debb = devlist; debb; debb = BADDR(debb->dn_Next))
        if (debb->dn_Type == DLT_DEVICE && (debb->dn_Task == lick->fl_Task))
            if (fart = BADDR(debb->dn_Startup)) {
                debna = (char *) BADDR(fart->fssm_Device) + 1;
                if ((i = debna[-1]) > 31) i = 30;
                strncpy(devname, debna, i);
                devname[i] = 0;
                okay = !strcmp(devname, "trackdisk.device")
                                || !strcmp(devname, "mfm.device")
                                || !strcmp(devname, "messydisk.device");
                break;  /* We only support obvious floppy drives, not tricky */
            }           /* things like removable cartrige hard drives, or    */
    Permit();           /* any unusual kind of floppy device driver.         */
    return okay;
}
#endif /* AMIGA_VOLUME_LABELS */
#ifndef SFX
# if 0
/* As far as I can tell, all the locales AmigaDOS 2.1 knows about all */
/* happen to use DF_MDY ordering, so there's no point in using this.  */
/*************************/
/* Function dateformat() */
/*************************/
#include <clib/locale_protos.h>
#ifdef AZTEC_C
#  include <pragmas/locale_lib.h>
#endif
int dateformat()
{
/*---------------------------------------------------------------------------
    For those operating systems which support it, this function returns a
    value which tells how national convention says that numeric dates are
    displayed.  Return values are DF_YMD, DF_DMY and DF_MDY (the meanings
    should be fairly obvious).
  ---------------------------------------------------------------------------*/
    struct Library *LocaleBase;
    struct Locale *ll;
    int result = DF_MDY;        /* the default */
    if ((LocaleBase = OpenLibrary("locale.library", 0))) {
        if (ll = OpenLocale(NULL)) {
            uch *f = ll->loc_ShortDateFormat;
            /* In this string, %y|%Y is year, %b|%B|%h|%m is month, */
            /* %d|%e is day day, and %D|%x is short for mo/da/yr.   */
            if (!strstr(f, "%D") && !strstr(f, "%x")) {
                uch *da, *mo, *yr;
                if (!(mo = strstr(f, "%b")) && !(mo = strstr(f, "%B"))
                                    && !(mo = strstr(f, "%h")))
                    mo = strstr(f, "%m");
                if (!(da = strstr(f, "%d")))
                    da = strstr(f, "%e");
                if (!(yr = strstr(f, "%y")))
                    yr = strstr(f, "%Y");
                if (yr && yr < mo)
                    result = DF_YMD;
                else if (da && da < mo)
                    result = DF_DMY;
            }
            CloseLocale(ll);
        }
        CloseLibrary(LocaleBase);
    }
    return result;
}
# endif /* 0 */
/************************/
/*  Function version()  */
/************************/
/* NOTE:  the following include depends upon the environment
 *        variable $Workbench to be set correctly.  (Set by
 *        default, by kickstart during startup)
 */
int WBversion = (int)
#include "ENV:Workbench"
;
void version(__G)
   __GDEF
{
/* Define buffers. */
   char buf1[16];  /* compiler name */
   char buf2[16];  /* revstamp */
   char buf3[16];  /* OS */
   char buf4[16];  /* Date */
/*   char buf5[16];  /* Time */
/* format "with" name strings */
#ifdef AMIGA
# ifdef __SASC
   strcpy(buf1,"SAS/C ");
# else
#  ifdef LATTICE
    strcpy(buf1,"Lattice C ");
#  else
#   ifdef AZTEC_C
     strcpy(buf1,"Manx Aztec C ");
#   else
     strcpy(buf1,"UNKNOWN ");
#   endif
#  endif
# endif
/* "under" */
  sprintf(buf3,"AmigaDOS v%d",WBversion);
#else
  strcpy(buf1,"Unknown compiler ");
  strcpy(buf3,"Unknown OS");
#endif
/* Define revision, date, and time strings.
 * NOTE:  Do not calculate run time, be sure to use time compiled.
 * Pass these strings via your makefile if undefined.
 */
#if defined(__VERSION__) && defined(__REVISION__)
  sprintf(buf2,"version %d.%d",__VERSION__,__REVISION__);
#else
# ifdef __VERSION__
  sprintf(buf2,"version %d",__VERSION__);
# else
  sprintf(buf2,"unknown version");
# endif
#endif
#ifdef __DATE__
  sprintf(buf4," on %s",__DATE__);
#else
  strcpy(buf4," unknown date");
#endif
/******
#ifdef __TIME__
  sprintf(buf5," at %s",__TIME__);
#else
  strcpy(buf5," unknown time");
#endif
******/
/* Print strings using "CompiledWith" mask defined in unzip.c (used by all).
 *  ("Compiled with %s%s for %s%s%s%s.")
 */
   printf(LoadFarString(CompiledWith),
     buf1,
     buf2,
     buf3,
     buf4,
     "",    /* buf5 not used */
     "" );  /* buf6 not used */
} /* end function version() */
#endif /* !SFX */

						