~ UNZIP532.BCK  UNZIP532.BCK(BACKUP/LOG [...]*.*; [-]UNZIP532.BCK/SAV GOATHUNTER "sٛV7.1 _GHUNT1:: _$1$VDA0: V6.2 ~ 8*[SCRATCH.UNZIP]ACORN.DIR;1+,./ 4-0123 KPWO569qbћ79qbћ89 6ԛGHJIACORN.C  CONTENTS. MAKEFILE.README.RISCOS.C#RISCOS.H RUNME1ST. SRCRENAME."SWIVEN.H0SWIVEN.S7*[SCRATCH.UNZIP.ACORN]ACORN.C;1+, .4/ 444-0@123KPWO556?3d7?3d89 6ԛGHJh/*--------------------------------------------------------------------------- acorn.c RISCOS-specific routines for use with Info-ZIP's UnZip 5.2 and later. Contains: do_wild() <-- generic enough to put in fileio.c? mapattr() mapname() checkdir() mkdir() isRISCOSexfield() setRISCOSexfield() printRISCOSexfield() close_outfile() stamp_file() version() ---------------------------------------------------------------------------*/ #define UNZIP_INTERNAL #include "^.unzip.h" #include "riscos.h" #define FTYPE_FFF (1<<17) /* set filetype to &FFF when extracting */ static int created_dir; /* used in mapname(), checkdir() */ static int renamed_fullpath; /* ditto */ extern int mkdir(char *path, int mode); #ifndef SFX /**********************/ /* Function do_wild() */ /* for porting: dir separator; match(ignore_case) */ /**********************/ char *do_wild(__G__ wildspec) __GDEF char *wildspec; /* only used first time on a given dir */ { static DIR *dir = (DIR *)NULL; static char *dirname, *wildname, matchname[FILNAMSIZ]; static int firstcall=TRUE, have_dirname, dirnamelen; struct dirent *file; /* 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 (firstcall) { /* first call: must initialize everything */ firstcall = FALSE; /* break the wildspec into a directory part and a wildcard filename */ if ((wildname = strrchr(wildspec, '.')) == (char *)NULL) { dirname = "."; dirnamelen = 1; have_dirname = FALSE; wildname = wildspec; } else { ++wildname; /* point at character after '/' */ dirnamelen = wildname - wildspec; if ((dirname = (char *)malloc(dirnamelen+1)) == (char *)NULL) { Info(slide, 0x201, ((char *)slide, "warning: cannot allocate wildcard buffers\n")); strcpy(matchname, wildspec); return matchname; /* but maybe filespec was not a wildcard */ } strncpy(dirname, wildspec, dirnamelen); dirname[dirnamelen] = '\0'; /* terminate for strcpy below */ have_dirname = TRUE; } if ((dir = opendir(dirname)) != (DIR *)NULL) { while ((file = readdir(dir)) != (struct dirent *)NULL) { if (file->d_name[0] == '/' && wildname[0] != '/') continue; /* Unix: '*' and '?' do not match leading dot */ if (match(file->d_name, wildname, 0)) { /* 0 == case sens. */ if (have_dirname) { strcpy(matchname, dirname); strcpy(matchname+dirnamelen, file->d_name); } else strcpy(matchname, file->d_name); return matchname; } } /* if we get to here directory is exhausted, so close it */ closedir(dir); dir = (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(matchname, wildspec); return matchname; } /* last time through, might have failed opendir but returned raw wildspec */ if (dir == (DIR *)NULL) { firstcall = TRUE; /* nothing left to try--reset for new wildspec */ if (have_dirname) free(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(dir)) != (struct dirent *)NULL) if (match(file->d_name, wildname, 0)) { /* 0 == don't ignore case */ if (have_dirname) { /* strcpy(matchname, dirname); */ strcpy(matchname+dirnamelen, file->d_name); } else strcpy(matchname, file->d_name); return matchname; } closedir(dir); /* have read at least one dir entry; nothing left */ dir = (DIR *)NULL; firstcall = TRUE; /* reset for new wildspec */ if (have_dirname) free(dirname); return (char *)NULL; } /* end function do_wild() */ #endif /* !SFX */ /**********************/ /* Function mapattr() */ /**********************/ int mapattr(__G) __GDEF { ulg tmp = G.crec.external_file_attributes; switch (G.pInfo->hostnum) { case UNIX_: case VMS_: case ACORN_: case ATARI_: case BEOS_: case QDOS_: G.pInfo->file_attr = (unsigned)(tmp >> 16); break; case AMIGA_: tmp = (unsigned)(tmp>>17 & 7); /* Amiga RWE bits */ G.pInfo->file_attr = (unsigned)(tmp<<6 | tmp<<3 | tmp); break; /* all remaining cases: expand MSDOS read-only bit into write perms */ case FS_FAT_: case FS_HPFS_: case FS_NTFS_: case MAC_: case TOPS20_: default: tmp = !(tmp & 1) << 1; /* read-only bit --> write perms bits */ G.pInfo->file_attr = (unsigned)(0444 | tmp<<6 | tmp<<3 | tmp); break; } /* end switch (host-OS-created-by) */ G.pInfo->file_attr&=0xFFFF; G.pInfo->file_attr|=(0xFFDu<<20); if (G.filename[strlen(G.filename)-4]==',') { int ftype=strtol(G.filename+strlen(G.filename)-3,NULL,16)&0xFFF; G.pInfo->file_attr&=0x000FFFFF; G.pInfo->file_attr|=(ftype<<20); } else if (G.crec.internal_file_attributes & 1) { G.pInfo->file_attr&=0x000FFFFF; G.pInfo->file_attr|=(0xFFFu<<20); } return 0; } /* end function mapattr() */ /************************/ /* Function mapname() */ /************************/ /* return 0 if no error, 1 if caution (filename */ int mapname(__G__ renamed) /* truncated), 2 if warning (skip file because */ __GDEF /* dir doesn't exist), 3 if error (skip file), */ int renamed; /* or 10 if out of memory (skip file) */ { /* [also IZ_VOL_LABEL, IZ_CREATED_DIR] */ char pathcomp[FILNAMSIZ]; /* path-component buffer */ char *pp, *cp=(char *)NULL; /* character pointers */ char *lastsemi=(char *)NULL; /* pointer to last semi-colon in pathcomp */ int quote = FALSE; /* flags */ int error = 0; register unsigned workch; /* hold the character being tested */ char *checkswap=NULL; /* pointer the the extension to check or NULL */ /*--------------------------------------------------------------------------- Initialize various pointers and counters and stuff. ---------------------------------------------------------------------------*/ if (G.pInfo->vollabel) return IZ_VOL_LABEL; /* can't set disk volume labels in Unix */ /* can create path as long as not just freshening, or if user told us */ G.create_dirs = (!G.fflag || renamed); created_dir = FALSE; /* not yet */ /* user gave full pathname: don't prepend rootpath */ renamed_fullpath = (renamed && (*G.filename == '/')); if (checkdir(__G__ (char *)NULL, INIT) == 10) return 10; /* initialize path buffer, unless no memory */ *pathcomp = '\0'; /* initialize translation buffer */ pp = pathcomp; /* point to translation buffer */ if (G.jflag) /* junking directories */ cp = (char *)strrchr(G.filename, '/'); if (cp == (char *)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) { if (quote) { /* if character quoted, */ *pp++ = (char)workch; /* include it literally */ quote = FALSE; } else switch (workch) { case '/': /* can assume -j flag not given */ *pp = '\0'; if ((error = checkdir(__G__ pathcomp, APPEND_DIR)) > 1) return error; pp = pathcomp; /* reset conversion buffer for next piece */ lastsemi = (char *)NULL; /* leave directory semi-colons alone */ checkswap=NULL; /* reset checking when starting a new leafname */ break; case ';': /* VMS version (or DEC-20 attrib?) */ lastsemi = pp; *pp++ = ';'; /* keep for now; remove VMS ";##" */ break; /* later, if requested */ case '\026': /* control-V quote for special chars */ quote = TRUE; /* set flag for next character */ break; case ' ': /* change spaces to hard-spaces */ *pp++ = 160; break; case ':': /* change ':' to '' */ *pp++ = ''; break; case '&': /* change '&' to 'E' */ *pp++ = 'E'; break; case '@': /* change '@' to 'A' */ *pp++ = 'A'; break; case '.': *pp++ = '/'; checkswap=pp; break; default: /* allow European characters in filenames: */ if (isprint(workch) || (128 <= workch && workch <= 254)) *pp++ = (char)workch; } /* end switch */ } /* end while loop */ *pp = '\0'; /* done with pathcomp: terminate it */ /* if not saving them, remove VMS version numbers (appended ";###") */ if (!G.V_flag && lastsemi) { pp = lastsemi + 1; while (isdigit((uch)(*pp))) ++pp; if (*pp == '\0') /* only digits between ';' and end: nuke */ *lastsemi = '\0'; } /*--------------------------------------------------------------------------- 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 (created_dir) { if (QCOND2) { Info(slide, 0, ((char *)slide, " creating: %s\n", 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 == '\0') { Info(slide, 1, ((char *)slide, "mapname: conversion of %s failed\n", G.filename)); return 3; } if (checkswap!=NULL) { if (checkext(checkswap)) { if ((error = checkdir(__G__ checkswap, APPEND_DIR)) > 1) return error; *(checkswap-1)=0; /* remove extension from pathcomp */ } } if (pathcomp[strlen(pathcomp)-4]==',') { /* remove the filetype extension */ /* the filetype should be already set by mapattr() */ pathcomp[strlen(pathcomp)-4]=0; } checkdir(__G__ pathcomp, APPEND_NAME); /* returns 1 if truncated: care? */ 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_NAME) truncated filename * 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 */ { 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 ('\0') */ # 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. ---------------------------------------------------------------------------*/ if (FUNCTION == APPEND_DIR) { int too_long = FALSE; #ifdef SHORT_NAMES char *old_end = end; #endif Trace((stderr, "appending dir segment [%s]\n", pathcomp)); while ((*end = *pathcomp++) != '\0') ++end; #ifdef SHORT_NAMES /* path components restricted to 14 chars, typically */ if ((end-old_end) > FILENAME_MAX) /* GRR: proper constant? */ *(end = old_end + FILENAME_MAX) = '\0'; #endif /* GRR: could do better check, see if overrunning buffer as we go: * check end-buildpath after each append, set warning variable if * within 20 of FILNAMSIZ; then if var set, do careful check when * appending. Clear variable when begin new path. */ if ((end-buildpath) > FILNAMSIZ-3) /* need '/', one-char name, '\0' */ too_long = TRUE; /* check if extracting directory? */ if (stat(buildpath, &G.statbuf)) { /* path doesn't exist */ if (!G.create_dirs) { /* told not to create (freshening) */ free(buildpath); return 2; /* path doesn't exist: nothing to do */ } if (too_long) { Info(slide, 1, ((char *)slide, "checkdir error: path too long: %s\n", buildpath)); fflush(stderr); free(buildpath); return 4; /* no room for filenames: fatal */ } if (mkdir(buildpath, 0777) == -1) { /* create the directory */ Info(slide, 1, ((char *)slide, "checkdir error: cannot create %s\n\ unable to process %s.\n", buildpath, G.filename)); free(buildpath); return 3; /* path didn't exist, tried to create, failed */ } created_dir = TRUE; } else if (!S_ISDIR(G.statbuf.st_mode)) { Info(slide, 1, ((char *)slide, "checkdir error: %s exists but is not directory\n\ unable to process %s.\n", buildpath, G.filename)); free(buildpath); return 3; /* path existed but wasn't dir */ } if (too_long) { Info(slide, 1, ((char *)slide, "checkdir error: path too long: %s\n", buildpath)); free(buildpath); return 4; /* no room for filenames: fatal */ } *end++ = '.'; /************* was '/' *************/ *end = '\0'; Trace((stderr, "buildpath now = [%s]\n", buildpath)); return 0; } /* end if (FUNCTION == APPEND_DIR) */ /*--------------------------------------------------------------------------- GETPATH: copy full path to the string pointed at by pathcomp, and free buildpath. ---------------------------------------------------------------------------*/ if (FUNCTION == GETPATH) { strcpy(pathcomp, buildpath); Trace((stderr, "getting and freeing path [%s]\n", pathcomp)); free(buildpath); buildpath = end = (char *)NULL; return 0; } /*--------------------------------------------------------------------------- APPEND_NAME: assume the path component is the filename; append it and return without checking for existence. ---------------------------------------------------------------------------*/ if (FUNCTION == APPEND_NAME) { #ifdef SHORT_NAMES char *old_end = end; #endif Trace((stderr, "appending filename [%s]\n", pathcomp)); while ((*end = *pathcomp++) != '\0') { ++end; #ifdef SHORT_NAMES /* truncate name at 14 characters, typically */ if ((end-old_end) > FILENAME_MAX) /* GRR: proper constant? */ *(end = old_end + FILENAME_MAX) = '\0'; #endif if ((end-buildpath) >= FILNAMSIZ) { *--end = '\0'; Info(slide, 0x201, ((char *)slide, "checkdir warning: path too long; truncating\n\ %s\n -> %s\n", G.filename, buildpath)); return 1; /* filename truncated */ } } Trace((stderr, "buildpath now = [%s]\n", 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. ---------------------------------------------------------------------------*/ /* GRR: for VMS and TOPS-20, add up to 13 to strlen */ if (FUNCTION == INIT) { Trace((stderr, "initializing buildpath to ")); if ((buildpath = (char *)malloc(strlen(G.filename)+rootlen+1)) == (char *)NULL) return 10; if ((rootlen > 0) && !renamed_fullpath) { strcpy(buildpath, rootpath); end = buildpath + rootlen; } else { *buildpath = '\0'; end = buildpath; } Trace((stderr, "[%s]\n", buildpath)); return 0; } /*--------------------------------------------------------------------------- ROOT: if appropriate, store the path in rootpath and create it if neces- sary; 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 == (char *)NULL) { rootlen = 0; return 0; } if ((rootlen = strlen(pathcomp)) > 0) { if (pathcomp[rootlen-1] == '.') { /****** was '/' ********/ pathcomp[--rootlen] = '\0'; } if (rootlen > 0 && (stat(pathcomp, &G.statbuf) || !S_ISDIR(G.statbuf.st_mode))) { /* path does not exist */ if (!G.create_dirs /* || isshexp(pathcomp) */ ) { rootlen = 0; return 2; /* skip (or 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: %s\n", pathcomp)); rootlen = 0; /* path didn't exist, tried to create, and */ return 3; /* failed: file exists, or 2+ levels required */ } } if ((rootpath = (char *)malloc(rootlen+2)) == (char *)NULL) { rootlen = 0; return 10; } strcpy(rootpath, pathcomp); rootpath[rootlen++] = '.'; /*********** was '/' *************/ rootpath[rootlen] = '\0'; Trace((stderr, "rootpath now = [%s]\n", rootpath)); } return 0; } #endif /* !SFX || SFX_EXDIR */ /*--------------------------------------------------------------------------- END: free rootpath, immediately prior to program exit. ---------------------------------------------------------------------------*/ if (FUNCTION == END) { Trace((stderr, "freeing rootpath\n")); if (rootlen > 0) { free(rootpath); rootlen = 0; } return 0; } return 99; /* should never reach */ } /* end function checkdir() */ /********************/ /* Function mkdir() */ /********************/ int mkdir(path, mode) char *path; int mode; /* ignored */ /* * returns: 0 - successful * -1 - failed (errno not set, however) */ { return (SWI_OS_File_8(path) == NULL)? 0 : -1; } /*********************************/ /* extra_field-related functions */ /*********************************/ int isRISCOSexfield(void *extra_field) { if (extra_field!=NULL) { extra_block *block=(extra_block *)extra_field; return(block->ID==SPARKID && (block->size==24 || block->size==20) && block->ID_2==SPARKID_2); } else return FALSE; } void setRISCOSexfield(char *path, void *extra_field) { if (extra_field!=NULL) { extra_block *block=(extra_block *)extra_field; SWI_OS_File_1(path,block->loadaddr,block->execaddr,block->attr); } } void printRISCOSexfield(int isdir, void *extra_field) { extra_block *block=(extra_block *)extra_field; printf("\n This file has RISC OS file informations in the local extra field.\n"); if (isdir) { /* I prefer not to print this string... should change later... */ /* printf(" The file is a directory.\n");*/ } else if ((block->loadaddr & 0xFFF00000) != 0xFFF00000) { printf(" Load address: %.8X\n",block->loadaddr); printf(" Exec address: %.8X\n",block->execaddr); } else { /************* should change this to use OS_FSControl 18 to get filetype string ************/ char tmpstr[16]; char ftypestr[32]; int flen; sprintf(tmpstr,"File$Type_%03x",(block->loadaddr & 0x000FFF00) >> 8); if (SWI_OS_ReadVarVal(tmpstr,ftypestr,32,&flen)==NULL) { ftypestr[flen]=0; printf(" Filetype: %s (&%.3X)\n",ftypestr,(block->loadaddr & 0x000FFF00) >> 8); } else { printf(" Filetype: &%.3X\n",(block->loadaddr & 0x000FFF00) >> 8); } } printf(" Access: "); if (block->attr & (1<<3)) printf("L"); if (block->attr & (1<<0)) printf("W"); if (block->attr & (1<<1)) printf("R"); printf("/"); if (block->attr & (1<<4)) printf("w"); if (block->attr & (1<<5)) printf("r"); printf("\n\n"); } /****************************/ /* Function close_outfile() */ /****************************/ void close_outfile(__G) __GDEF { fclose(G.outfile); if (isRISCOSexfield(G.extra_field)) { setRISCOSexfield(G.filename, G.extra_field); } else { int loadaddr,execaddr,attr; int mode=G.pInfo->file_attr&0xffff; /* chmod equivalent mode */ time_t m_time; #ifdef USE_EF_UT_TIME iztimes z_utime; #endif #ifdef USE_EF_UT_TIME if (G.extra_field && (ef_scan_for_izux(G.extra_field, G.lrec.extra_field_length, 0, G.lrec.last_mod_file_date, &z_utime, NULL) & EB_UT_FL_MTIME)) { TTrace((stderr, "close_outfile: Unix e.f. modif. time = %ld\n", z_utime.mtime)); m_time = z_utime.mtime; } else #endif /* USE_EF_UT_TIME */ m_time = dos_to_unix_time(G.lrec.last_mod_file_date, G.lrec.last_mod_file_time); /* set the file's modification time */ SWI_OS_File_5(G.filename,NULL,&loadaddr,NULL,NULL,&attr); loadaddr=0xfff00000U | ((((m_time>>8) * 100)>>24) + 0x33); execaddr=m_time * 100 + 0x6e996a00U; loadaddr|=((G.pInfo->file_attr&0xFFF00000) >> 12); attr=(attr&0xffffff00) | ((mode&0400) >> 8) | ((mode&0200) >> 6) | ((mode&0004) << 2) | ((mode&0002) << 4); SWI_OS_File_1(G.filename,loadaddr,execaddr,attr); } } /* end function close_outfile() */ #ifdef TIMESTAMP /***************************/ /* Function stamp_file() */ /***************************/ int stamp_file(fname, modtime) ZCONST char *fname; time_t modtime; { int loadaddr, execaddr, attr; /* set the file's modification time */ if (SWI_OS_File_5((char *)fname, NULL, &loadaddr, NULL, NULL, &attr) != NULL) return -1; loadaddr=0xfff00000U | ((((modtime>>8) * 100)>>24) + 0x33); execaddr=modtime * 100 + 0x6e996a00U; return (SWI_OS_File_1((char *)fname, loadaddr, execaddr, attr) == NULL) ? 0 : -1; } /* end function stamp_file() */ #endif /* TIMESTAP */ #ifndef SFX /************************/ /* Function version() */ /************************/ void version(__G) __GDEF { sprintf((char *)slide, LoadFarString(CompiledWith), #ifdef __GNUC__ "gcc ", __VERSION__, #else # ifdef __CC_NORCROFT "Norcroft ", "cc", # else "cc", "", # endif #endif "RISC OS", " (Acorn Computers Ltd)", #ifdef __DATE__ " on ", __DATE__ #else "", "" #endif ); (*G.message)((zvoid *)&G, slide, (ulg)strlen((char *)slide), 0); } /* end function version() */ #endif /* !SFX */ 8 *[SCRATCH.UNZIP.ACORN]CONTENTS.;1+,./ 4 -0@123KPWO56*9F7*9F89 6ԛGHJContents of the "acorn" subdirectory for UnZip 5.3 and later: acorn.c.acorn Acorn-specific resources acorn.c.riscos mainly file-handling routines for FileCore-based filesystems acorn.Contents this file acorn.h.riscos acorn.h.swiven acorn.README notes about Acorn-specific features acorn.RunMe1st Obey file to move files into suitable place for compilation on RISC OS machines acorn.s.swiven SWI veneers acorn.srcrename small executable that converts files from Unix style to RISC OS style, used by RunMe1st Notes: Use the "RunMe1st" file (it is an Obey file) to convert all the files from "filename/[chs]" to "[chs].filename" (so that UnZip could be easily compiled under RISC OS). It will also set the correct makefile. To compile just set the CSD to the main UnZip directory and run 'amu'. Currently only the Acorn C V5 compiler has been tested but probably also Acorn C V4 and the Acorn Assembler V2 will be able to compile UnZip. 3 *[SCRATCH.UNZIP.ACORN]MAKEFILE.;1+,./ 4T-0@123KPWO 56Q*J7Q*J89 6ԛGHJ# Makefile for UnZip, UnZipSFX, ZipInfo and fUnZip (5.2 or later) # last modified: 18 Apr 96 # add -g to CC to debug # add -d to BIND to debug CC = cc BIND = link AS = $(CC) -c ASM = objasm SQUEEZE = squeeze -v E = # flags # CFLAGS flags for C compile # LFLAGS1 flags after output file spec, before obj file list # LFLAGS2 flags after obj file list (libraries, etc) # LIB = CFLAGS = -throwback -wn CFLAGS = $(CFLAGS) -IC:,@. ASMFLAGS = -Throwback -Stamp -NoCache -CloseExec -quit LFLAGS1 = LFLAGS2 = $(LIB) C:o.Stubs # object file lists OBJS1 = unzip.o crc32.o crctab.o crypt.o envargs.o explode.o OBJS2 = extract.o fileio.o globals.o inflate.o list.o match.o OBJS3 = process.o ttyio.o unreduce.o unshrink.o zipinfo.o OBJS = $(OBJS1) $(OBJS2) $(OBJS3) riscos.o swiven.o acorn.o OBJF = funzip.o crc32.o crypt_.o globals_.o inflate_.o ttyio_.o \ riscos.o swiven.o OBJX = unzipsfx.o crc32.o crctab.o crypt.o extract_.o fileio.o globals.o \ inflate.o match.o process_.o ttyio.o acorn_.o swiven.o riscos_.o UNZIP_H = unzip.h unzpriv.h globals.h acorn/riscos.h acorn/swiven.h all: unzip funzip unzipsfx install: unzip funzip unzipsfx $(SQUEEZE) unzip %.unzip $(SQUEEZE) funzip %.funzip $(SQUEEZE) unzipsfx unzipsfx copy %.unzip %.zipinfo ~CVF # suffix rules .SUFFIXES: .o .c .c.o: $(CC) $(CFLAGS) -c $< .s.o: $(ASM) $(ASMFLAGS) -from @*.s -to @*.o # rules for unzip and funzip crc32.o: crc32.c $(UNZIP_H) zip.h crctab.o: crctab.c $(UNZIP_H) zip.h crypt.o: crypt.c $(UNZIP_H) zip.h crypt.h ttyio.h envargs.o: envargs.c $(UNZIP_H) explode.o: explode.c $(UNZIP_H) extract.o: extract.c $(UNZIP_H) crypt.h fileio.o: fileio.c $(UNZIP_H) crypt.h ttyio.h ebcdic.h funzip.o: funzip.c $(UNZIP_H) crypt.h ttyio.h tables.h globals.o: globals.c $(UNZIP_H) inflate.o: inflate.c inflate.h $(UNZIP_H) list.o: list.c $(UNZIP_H) match.o: match.c $(UNZIP_H) process.o: proce~ UNZIP532.BCK [SCRATCH.UNZIP.ACORN]MAKEFILE.;1 Uss.c $(UNZIP_H) ttyio.o: ttyio.c $(UNZIP_H) zip.h crypt.h ttyio.h unreduce.o: unreduce.c $(UNZIP_H) unshrink.o: unshrink.c $(UNZIP_H) unzip.o: unzip.c $(UNZIP_H) crypt.h version.h consts.h zipinfo.o: zipinfo.c $(UNZIP_H) crypt_.o: crypt.c $(UNZIP_H) zip.h crypt.h ttyio.h $(CC) $(CFLAGS) -DFUNZIP -c c.crypt -o o.crypt_ extract_.o: extract.c $(UNZIP_H) crypt.h $(CC) $(CFLAGS) -DSFX -c c.extract -o o.extract_ globals_.o: globals.c $(UNZIP_H) $(CC) $(CFLAGS) -DFUNZIP -c c.globals -o o.globals_ inflate_.o: inflate.c inflate.h $(UNZIP_H) crypt.h $(CC) $(CFLAGS) -DFUNZIP -c c.inflate -o o.inflate_ process_.o: process.c $(UNZIP_H) $(CC) $(CFLAGS) -DSFX -c c.process -o o.process_ ttyio_.o: ttyio.c $(UNZIP_H) zip.h crypt.h ttyio.h $(CC) $(CFLAGS) -DFUNZIP -c c.ttyio -o o.ttyio_ unzipsfx.o: unzip.c $(UNZIP_H) crypt.h version.h consts.h $(CC) $(CFLAGS) -DSFX -c c.unzip -o o.unzipsfx acorn.o: acorn/acorn.c $(UNZIP_H) $(CC) $(CFLAGS) -c acorn/acorn.c acorn_.o: acorn/acorn.c $(UNZIP_H) $(CC) $(CFLAGS) -c -DSFX -DSFX_EXDIR -o acorn_.o acorn/acorn.c riscos.o: acorn/riscos.c $(UNZIP_H) $(CC) $(CFLAGS) -c acorn/riscos.c riscos_.o: acorn/riscos.c $(UNZIP_H) $(CC) $(CFLAGS) -c -DSFX -DSFX_EXDIR -o riscos_.o acorn/riscos.c swiven.o: acorn/swiven.s $(ASM) $(ASMFLAGS) -from acorn.s.swiven -to o.swiven unzip: $(OBJS) $(BIND) -o unzip$(E) $(LFLAGS1) $(OBJS) $(LFLAGS2) funzip: $(OBJF) $(BIND) -o funzip$(E) $(LFLAGS1) $(OBJF) $(LFLAGS2) unzipsfx: $(OBJX) $(BIND) -o unzipsfx$(E) $(LFLAGS1) $(OBJX) $(LFLAGS2) clean: ;remove unzip; remove funzip; remove zipinfo; remove unzipsfx; create o.!fake! 0 wipe o.* ~cf # end of Makefile *[SCRATCH.UNZIP.ACORN]README.;1+,./ 4-0@123KPWO56)J7)J89 6ԛGHJ Acorn-specific usage instructions --------------------------------- As zipfiles can come from a variety of sources apart from Acorn machines, consideration had to be given to the handling of dot-extensions, a la DOSFILE.TXT, unix-filename.tar.gz . What was decided that they would be extracted as DOSFILE/TXT and unix-filename/tar/gz, and then truncated to 10-characters, for FileCore compliance. This can quickly be altered for any new releases of FileCore that Acorn may make for longer filenames. Unfortunately, this means that you must be REALLY careful about extracting files from archives. The files dummy_source.c and dummy_source.h will both be extracted as dummy_sour UnZip will prompt you for confirmation of the over-writing of these files, but you must be really careful unless you wish to lose files! Also, because UnZip is a unix-ported program, the filenames are CASE SENSITIVE. *unzip new/zip newfile will extract 'newfile', but not 'NewFile', 'NEWFILE' or any other combinations. However, you can use the -C option to force operations to disregard the case of filenames. The Acorn UnZip port has an additional feature to cope with the extraction of files containing 'c' code. As you may be aware, Acorn Desktop C requires all files called "foo.c" to be renamed to "c.foo", ie "foo" in a directory called "c". To cope with this, a colon-separated environment variable has been set up called "Unzip$Exts". Any extensions found in this variable will be extracted to directories named after the extension, with the extension stripped. For example: *Set Unzip$Exts "c:h:o:s" will extract all the files called 'foo.c' to a directory called 'c'. This can be used to include "c:h:o:s:txt" to pull all the text files out to a separate directory. UnZip fully supports SparkFS Extra Field. This means that zipfiles created with SparkFS or Zip (on RISC OS) will be correctly unzipped, including filetypes. UnZipSFX can be used to create self-extracting archives. To use it, just create a common zipfile using Zip (or SparkFS), then load the UnZipSFX executable into an editor (eg. Edit, Zap), go with the caret the end of the file (using CTRL-CursorDown) and drag the zipfile to the editor window (in other words, append the zipfile to the UnZipSFX executable). Now, saving the resulting file (with filetype Absolute (&FF8)), you have a self-extracting archive (ie. double-clicking on it will unzip the contents of the original zipfile to the currently selected directory). g*[SCRATCH.UNZIP.ACORN]RISCOS.C;1+,#. / 4 -0@123KPWO56789 6ԛGHJ/* riscos.c */ #include #include #include /* #define NO_UNZIPH_STUFF */ #define UNZIP_INTERNAL #include "unzip.h" #include "riscos.h" #define MAXEXT 16 char *exts2swap = ""; /* Extensions to swap (actually, directory names) */ int stat(char *filename,struct stat *res) { int attr; /* object attributes */ int load; /* load address */ int exec; /* exec address */ int type; /* type: 0 not found, 1 file, 2 dir, 3 image */ if (!res) return -1; if (SWI_OS_File_5(filename,&type,&load,&exec,(int *)&res->st_size,&attr)!=NULL) return -1; if (type==0) return -1; res->st_dev=0; res->st_ino=0; res->st_nlink=0; res->st_uid=1; res->st_gid=1; res->st_rdev=0; res->st_blksize=1024; res->st_mode = ((attr & 0001) << 8) | ((attr & 0002) << 6) | ((attr & 0020) >> 2) | ((attr & 0040) >> 4); switch (type) { case 1: /* File */ res->st_mode |= S_IFREG; break; case 2: /* Directory */ res->st_mode |= S_IFDIR | 0700; break; case 3: /* Image file */ if (G.scanimage) res->st_mode |= S_IFDIR | 0700; else res->st_mode |= S_IFREG; break; } if ((((unsigned int) load) >> 20) == 0xfff) { /* date stamped file */ register unsigned int t1, t2, tc; t1 = (unsigned int) (exec); t2 = (unsigned int) (load & 0xff); tc = 0x6e996a00U; if (t1 < tc) t2--; t1 -= tc; t2 -= 0x33; /* 00:00:00 Jan. 1 1970 = 0x336e996a00 */ t1 = (t1 / 100) + (t2 * 42949673U); /* 0x100000000 / 100 = 42949672.96 */ t1 -= (t2 / 25); /* compensate for .04 error */ res->st_atime = res->st_mtime = res->st_ctime = t1; } else res->st_atime = res->st_mtime = res->st_ctime = 0; return 0; } #ifndef SFX DIR *opendir(char *dirname) { DIR *thisdir; int type; int attr; os_error *er; thisdir=(DIR *)malloc(sizeof(DIR)); if (thisdir==NULL) return NULL; thisdir->dirname=(char *)malloc(strlen(dirname)+1); if (thisdir->dirname==NULL) { free(thisdir); return NULL; } strcpy(thisdir->dirname,dirname); if (thisdir->dirname[strlen(thisdir->dirname)-1]=='.') thisdir->dirname[strlen(thisdir->dirname)-1]=0; if (er=SWI_OS_File_5(thisdir->dirname,&type,NULL,NULL,NULL,&attr),er!=NULL || type<=1 || (type==3 && !G.scanimage)) { free(thisdir->dirname); free(thisdir); return NULL; } thisdir->buf=malloc(DIR_BUFSIZE); if (thisdir->buf==NULL) { free(thisdir->dirname); free(thisdir); return NULL; } thisdir->size=DIR_BUFSIZE; thisdir->offset=0; thisdir->read=0; return thisdir; } struct dirent *readdir(DIR *d) { static struct dirent dent; if (d->read==0) { /* no more objects read in the buffer */ if (d->offset==-1) { /* no more objects to read */ return NULL; } d->read=255; if (SWI_OS_GBPB_9(d->dirname,d->buf,&d->read,&d->offset,DIR_BUFSIZE,NULL)!=NULL) return NULL; if (d->read==0) { d->offset=-1; return NULL; } d->read--; d->act=(char *)d->buf; } else { /* some object is ready in buffer */ d->read--; d->act=(char *)(d->act+strlen(d->act)+1); } strcpy(dent.d_name,d->act); dent.d_namlen=strlen(dent.d_name); return &dent; } void closedir(DIR *d) { if (d->buf!=NULL) free(d->buf); if (d->dirname!=NULL) free(d->dirname); free(d); } int unlink(f) char *f; /* file to delete */ /* Delete the file *f, returning non-zero on failure. */ { os_error *er; char canon[256]; int size=255; er=SWI_OS_FSControl_37(f,canon,&size); if (er==NULL) { er=SWI_OS_FSControl_27(canon,0x100); } else { er=SWI_OS_FSControl_27(f,0x100); } return (int)er; } int rmdir(char *d) { int objtype; char *s; int len; len = strlen(d); if ((s = malloc(len + 1)) == NULL) return -1; strcpy(s,d); if (s[len-1]=='.') s[len-1]=0; if (SWI_OS_File_5(s,&objtype,NULL,NULL,NULL,NULL)!=NULL) { free(s); return -1; } if (objtype<2 || (!G.scanimage && objtype==3)) { /* this is a file or it doesn't exist */ free(s); return -1; } if (SWI_OS_File_6(s)!=NULL) { free(s); return -1; } free(s); return 0; } #endif /* !SFX */ int chmod(char *file, int mode) { /*************** NOT YET IMPLEMENTED!!!!!! ******************/ /* I don't know if this will be needed or not... */ file=file; mode=mode; return 0; } void setfiletype(char *fname,int ftype) { char str[256]; sprintf(str,"SetType %s &%3.3X",fname,ftype); SWI_OS_CLI(str); } void getRISCOSexts(char *envstr) { char *envptr; /* value returned by getenv */ envptr = getenv(envstr); if (envptr == NULL || *envptr == 0) return; exts2swap=malloc(1+strlen(envptr)); if (exts2swap == NULL) return; strcpy(exts2swap, envptr); } int checkext(char *suff) { register char *extptr=exts2swap; register char *suffptr; register int e,s; while(*extptr) { suffptr=suff; e=*extptr; s=*suffptr; while (e && e!=':' && s && s!='.' && s!='/' && e==s) { e=*++extptr; s=*++suffptr; } if (e==':') e=0; if (s=='.' || s=='/') s=0; if (!e && !s) { return 1; } while(*extptr!=':' && *extptr!='\0') /* skip to next extension */ extptr++; if (*extptr!='\0') extptr++; } return 0; } void swapext(char *name, char *exptr) { char ext[MAXEXT]; register char *p1=exptr+1; register char *p2=ext; int extchar=*exptr; while(*p1 && *p1!='.' && *p1!='/') *p2++=*p1++; *p2=0; p2=exptr-1; p1--; while(p2 >= name) *p1--=*p2--; p1=name; p2=ext; while(*p2) *p1++=*p2++; *p1=(extchar=='/'?'.':'/'); } void remove_prefix(void) { SWI_DDEUtils_Prefix(NULL); } void set_prefix(void) { char *pref; int size=0; if (SWI_OS_FSControl_37("@",pref,&size)!=NULL) return; size=1-size; if (pref=malloc(size),pref!=NULL) { if (SWI_OS_FSControl_37("@",pref,&size)!=NULL) { free(pref); return; } if (SWI_DDEUtils_Prefix(pref)==NULL) { atexit(remove_prefix); } free(pref); } } #ifdef localtime # undef localtime #endif #ifdef gmtime # undef gmtime #endif /* Acorn's implementation of localtime() and gmtime() * doesn't consider the timezone offset, so we have to * add it before calling the library functions */ struct tm *riscos_localtime(const time_t *timer) { time_t localt=*timer; localt+=SWI_Read_Timezone()/100; return localtime(&localt); } struct tm *riscos_gmtime(const time_t *timer) { time_t localt=*timer; localt+=SWI_Read_Timezone()/100; return gmtime(&localt); } *[SCRATCH.UNZIP.ACORN]RISCOS.H;1+,./ 4A-0@123KPWO56?3d7?3d89 6ԛGHJ /* riscos.h */ #ifndef __riscos_h #define __riscos_h #include typedef struct { int errnum; char errmess[252]; } os_error; #ifndef __swiven_h # include "swiven.h" #endif #define MAXPATHLEN 256 #define MAXFILENAMELEN 64 /* should be 11 for ADFS, 13 for DOS, 64 seems a sensible value... */ #define DIR_BUFSIZE 1024 /* this should be enough to read a whole E-Format directory */ struct stat { unsigned int st_dev; int st_ino; unsigned int st_mode; int st_nlink; unsigned short st_uid; unsigned short st_gid; unsigned int st_rdev; unsigned int st_size; unsigned int st_blksize; time_t st_atime; time_t st_mtime; time_t st_ctime; }; typedef struct { char *dirname; void *buf; int size; char *act; int offset; int read; } DIR; struct dirent { unsigned int d_off; /* offset of next disk directory entry */ int d_fileno; /* file number of entry */ size_t d_reclen; /* length of this record */ size_t d_namlen; /* length of d_name */ char d_name[MAXFILENAMELEN]; /* name */ }; typedef struct { int load_addr; int exec_addr; int lenght; int attrib; int objtype; char name[13]; } riscos_direntry; #define SPARKID 0x4341 /* = "AC" */ #define SPARKID_2 0x30435241 /* = "ARC0" */ typedef struct { short ID; short size; int ID_2; int loadaddr; int execaddr; int attr; int zero; } extra_block; #define S_IFMT 0770000 #define S_IFDIR 0040000 #define S_IFREG 0100000 /* 0200000 in UnixLib !?!?!?!? */ #ifndef S_IEXEC # define S_IEXEC 0000100 # define S_IWRITE 0000200 # define S_IREAD 0000400 #endif #ifndef NO_UNZIPH_STUFF # include # ifndef DATE_FORMAT # define DATE_FORMAT DF_DMY # endif # define lenEOL 1 # define PutNativeEOL *q++ = native(LF); # define USE_STRM_INPUT # define USE_FWRITE # define PIPE_ERROR (errno == 9999) /* always false */ # define isatty(x) (TRUE) /* used in funzip.c to find if stdin redirected: should find a better way, now just work as if stdin never redirected */ # define USE_EF_UT_TIME # if (!defined(NOTIMESTAMP) && !defined(TIMESTAMP)) # define TIMESTAMP # endif # define localtime riscos_localtime # define gmtime riscos_gmtime #endif /* !NO_UNZIPH_STUFF */ #define _raw_getc() SWI_OS_ReadC() extern char *exts2swap; /* Extensions to swap */ int stat(char *filename,struct stat *res); DIR *opendir(char *dirname); struct dirent *readdir(DIR *d); void closedir(DIR *d); int unlink(char *f); int rmdir(char *d); int chmod(char *file, int mode); void setfiletype(char *fname,int ftype); void getRISCOSexts(char *envstr); int checkext(char *suff); void swapext(char *name, char *exptr); void remove_prefix(void); void set_prefix(void); struct tm *riscos_localtime(const time_t *timer); struct tm *riscos_gmtime(const time_t *timer); #endif _ *[SCRATCH.UNZIP.ACORN]RUNME1ST.;1+,./ 4d-0@123KPWO56 H7 H89 6ԛGHJ| This Obey file prepares the UnZip port for a Desktop C re-compile. | Run it and it will copy all the needed files into the correct | place. | Set the correct type of 'srcrename' so that the only requirement | for the user is to set 'RunMe1st' to Obey SetType .srcrename FF8 | Run 'srcrename' on the main UnZip directory with recursion enabled /.srcrename -r -e c:h:s:o .^ | Create the 'o' directory CDir .^.o | Put the Makefile in its correct place and set the correct filetype SetType .makefile FE1 Copy .makefile .^.makefile ~C ~V F !*[SCRATCH.UNZIP.ACORN]SRCRENAME.;1+,". / 4 o-0@123KPWO 56#yF7#yF89 6ԛGHJN L0  4S0S2(@ߺ^o40j˚aSnb3hanc#4Ns1|k^돩JY媿ٺiÙ^>EDOF_q@LJHĚEƚn?oX/}ƚ-o*Ě:,pE@rIԈaSnf3rN"TSCbflzR;F99Jg?$7vؙęTKLYC9A;EAHZH皪જ+eC l6␘ԙ㘙ԙlԺfa4nN!u83gP7ݺԪEZ<6i\],+KCҚ7+XҚ=W6{,DT*}7~ԭl2salnb 4Xz" 𙻚 薙֔˩ әљ #ɟǙ a ng3sQyOY̚=+'BMGQH$NL/sI,84D5,?6Kw왬ī}FȚ|ND9)lWca4nN[ )I?v6i>?6H6i»\aob4w޺&/% - 0H'ފ(/&.@ (1ahne3qTPR?y8I