Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | merge rfe-6c0d7aec67 Adapt upstream Androwish improvements |
---|---|
Downloads: | Tarball | ZIP archive | SQL archive |
Timelines: | family | ancestors | descendants | both | zipfs |
Files: | files | file ages | folders |
SHA1: |
327ea0a2de323f6e7cd60d727aa7d82c |
User & Date: | jan.nijtmans 2017-07-14 15:03:29 |
Context
2017-09-01
| ||
14:00 | merge core-8-6-branch check-in: c3e090e484 user: jan.nijtmans tags: zipfs | |
2017-07-14
| ||
15:08 | merge zipfs check-in: 6232610ca9 user: jan.nijtmans tags: androwish | |
15:03 | merge rfe-6c0d7aec67 Adapt upstream Androwish improvements check-in: 327ea0a2de user: jan.nijtmans tags: zipfs | |
14:48 | merge core-8-6-branch Closed-Leaf check-in: e07455203e user: jan.nijtmans tags: rfe-6c0d7aec67 | |
2017-07-03
| ||
12:34 | merge rfe-6c0d7aec67 check-in: 04c2a45d71 user: jan.nijtmans tags: zipfs | |
Changes
Changes to generic/tclInt.h.
︙ | ︙ | |||
4355 4356 4357 4358 4359 4360 4361 | * * MODULE_SCOPE int TclUtfToUniChar(const char *string, Tcl_UniChar *ch); *---------------------------------------------------------------- */ #define TclUtfToUniChar(str, chPtr) \ ((((unsigned char) *(str)) < 0xC0) ? \ | | | 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 | * * MODULE_SCOPE int TclUtfToUniChar(const char *string, Tcl_UniChar *ch); *---------------------------------------------------------------- */ #define TclUtfToUniChar(str, chPtr) \ ((((unsigned char) *(str)) < 0xC0) ? \ ((*(chPtr) = (unsigned char) *(str)), 1) \ : Tcl_UtfToUniChar(str, chPtr)) /* *---------------------------------------------------------------- * Macro counterpart of the Tcl_NumUtfChars() function. To be used in speed- * -sensitive points where it pays to avoid a function call in the common case * of counting along a string of all one-byte characters. The ANSI C |
︙ | ︙ |
Changes to generic/tclPathObj.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 16 17 18 19 20 21 22 | * * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ #include "tclInt.h" #include "tclFileSystem.h" /* * Prototypes for functions defined later in this file. */ static Tcl_Obj * AppendPath(Tcl_Obj *head, Tcl_Obj *tail); static void DupFsPathInternalRep(Tcl_Obj *srcPtr, | > | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | * * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ #include "tclInt.h" #include "tclFileSystem.h" #include <assert.h> /* * Prototypes for functions defined later in this file. */ static Tcl_Obj * AppendPath(Tcl_Obj *head, Tcl_Obj *tail); static void DupFsPathInternalRep(Tcl_Obj *srcPtr, |
︙ | ︙ | |||
845 846 847 848 849 850 851 | } Tcl_Obj * TclJoinPath( int elements, Tcl_Obj * const objv[]) { | | < | | > | > | < > | > | | | | < | | > < | | | | < | < | < | < | < > > > > > > > > > > > | 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 | } Tcl_Obj * TclJoinPath( int elements, Tcl_Obj * const objv[]) { Tcl_Obj *res = NULL; int i; const Tcl_Filesystem *fsPtr = NULL; assert ( elements >= 0 ); if (elements == 0) { return Tcl_NewObj(); } assert ( elements > 0 ); if (elements == 2) { Tcl_Obj *elt = objv[0]; /* * This is a special case where we can be much more efficient, where * we are joining a single relative path onto an object that is * already of path type. The 'TclNewFSPathObj' call below creates an * object which can be normalized more efficiently. Currently we only * use the special case when we have exactly two elements, but we * could expand that in the future. * * Bugfix [a47641a0]. TclNewFSPathObj requires first argument * to be an absolute path. Added a check for that elt is absolute. */ if ((elt->typePtr == &tclFsPathType) && !((elt->bytes != NULL) && (elt->bytes[0] == '\0')) && TclGetPathType(elt, NULL, NULL, NULL) == TCL_PATH_ABSOLUTE) { Tcl_Obj *tailObj = objv[1]; Tcl_PathType type = TclGetPathType(tailObj, NULL, NULL, NULL); if (type == TCL_PATH_RELATIVE) { const char *str; int len; str = Tcl_GetStringFromObj(tailObj, &len); if (len == 0) { /* * This happens if we try to handle the root volume '/'. * There's no need to return a special path object, when * the base itself is just fine! */ return elt; } /* * If it doesn't begin with '.' and is a unix path or it a * windows path without backslashes, then we can be very * efficient here. (In fact even a windows path with * backslashes can be joined efficiently, but the path object * would not have forward slashes only, and this would * therefore contradict our 'file join' documentation). */ if (str[0] != '.' && ((tclPlatform != TCL_PLATFORM_WINDOWS) || (strchr(str, '\\') == NULL))) { /* * Finally, on Windows, 'file join' is defined to convert * all backslashes to forward slashes, so the base part * cannot have backslashes either. */ if ((tclPlatform != TCL_PLATFORM_WINDOWS) || (strchr(Tcl_GetString(elt), '\\') == NULL)) { if (PATHFLAGS(elt)) { return TclNewFSPathObj(elt, str, len); } if (TCL_PATH_ABSOLUTE != Tcl_FSGetPathType(elt)) { return TclNewFSPathObj(elt, str, len); } (void) Tcl_FSGetNormalizedPath(NULL, elt); if (elt == PATHOBJ(elt)->normPathPtr) { return TclNewFSPathObj(elt, str, len); } } } /* * Otherwise we don't have an easy join, and we must let the * more general code below handle things. */ } else if (tclPlatform == TCL_PLATFORM_UNIX) { return tailObj; } else { const char *str = TclGetString(tailObj); if (tclPlatform == TCL_PLATFORM_WINDOWS) { if (strchr(str, '\\') == NULL) { return tailObj; } } } } } assert ( res == NULL ); for (i = 0; i < elements; i++) { int driveNameLength, strEltLen, length; Tcl_PathType type; char *strElt, *ptr; Tcl_Obj *driveName = NULL; Tcl_Obj *elt = objv[i]; strElt = Tcl_GetStringFromObj(elt, &strEltLen); driveNameLength = 0; type = TclGetPathType(elt, &fsPtr, &driveNameLength, &driveName); if (type != TCL_PATH_RELATIVE) { /* * Zero out the current result. */ |
︙ | ︙ | |||
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 | * is not in normalized form */ goto noQuickReturn; } ptr++; } /* * This element is just what we want to return already; no further * manipulation is requred. */ | > > > > | > | | > | 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 | * is not in normalized form */ goto noQuickReturn; } ptr++; } if (res != NULL) { TclDecrRefCount(res); } /* * This element is just what we want to return already; no further * manipulation is requred. */ return elt; } /* * The path element was not of a suitable form to be returned as is. * We need to perform a more complex operation here. */ noQuickReturn: if (res == NULL) { res = Tcl_NewObj(); ptr = Tcl_GetStringFromObj(res, &length); } else { ptr = Tcl_GetStringFromObj(res, &length); } /* * Strip off any './' before a tilde, unless this is the beginning of * the path. */ if (length > 0 && strEltLen > 0 && (strElt[0] == '.') && |
︙ | ︙ | |||
1070 1071 1072 1073 1074 1075 1076 | int needsSep = 0; if (fsPtr->filesystemSeparatorProc != NULL) { Tcl_Obj *sep = fsPtr->filesystemSeparatorProc(res); if (sep != NULL) { separator = TclGetString(sep)[0]; | | | 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 | int needsSep = 0; if (fsPtr->filesystemSeparatorProc != NULL) { Tcl_Obj *sep = fsPtr->filesystemSeparatorProc(res); if (sep != NULL) { separator = TclGetString(sep)[0]; Tcl_DecrRefCount(sep); } /* Safety check in case the VFS driver caused sharing */ if (Tcl_IsShared(res)) { TclDecrRefCount(res); res = Tcl_DuplicateObj(res); Tcl_IncrRefCount(res); } |
︙ | ︙ | |||
1106 1107 1108 1109 1110 1111 1112 | needsSep = 1; } } length = ptr - TclGetString(res); Tcl_SetObjLength(res, length); } } | | < < < < < < < < | 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 | needsSep = 1; } } length = ptr - TclGetString(res); Tcl_SetObjLength(res, length); } } assert ( res != NULL ); return res; } /* *--------------------------------------------------------------------------- * * Tcl_FSConvertToPathType -- * |
︙ | ︙ |
Changes to generic/zipfs.c.
1 2 3 4 5 | /* * zipfs.c -- * * Implementation of the ZIP filesystem used in AndroWish. * | | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* * zipfs.c -- * * Implementation of the ZIP filesystem used in AndroWish. * * Copyright (c) 2013-2017 Christian Werner <[email protected]> * * See the file "license.terms" for information on usage and redistribution of * this file, and for a DISCLAIMER OF ALL WARRANTIES. */ #include "tclInt.h" #include "tclFileSystem.h" #include "zipfs.h" #if !defined(_WIN32) && !defined(_WIN64) #include <sys/mman.h> #endif #include <errno.h> #include <string.h> #include <sys/stat.h> |
︙ | ︙ | |||
161 162 163 164 165 166 167 | typedef struct ZipEntry { char *name; /* The full pathname of the virtual file */ ZipFile *zipfile; /* The ZIP file holding this virtual file */ long offset; /* Data offset into memory mapped ZIP file */ int nbyte; /* Uncompressed size of the virtual file */ int nbytecompr; /* Compressed size of the virtual file */ int cmeth; /* Compress method */ | | | 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | typedef struct ZipEntry { char *name; /* The full pathname of the virtual file */ ZipFile *zipfile; /* The ZIP file holding this virtual file */ long offset; /* Data offset into memory mapped ZIP file */ int nbyte; /* Uncompressed size of the virtual file */ int nbytecompr; /* Compressed size of the virtual file */ int cmeth; /* Compress method */ int isdir; /* Set to 1 if directory, -1 if root */ int depth; /* Number of slashes in path. */ int crc32; /* CRC-32 */ int timestamp; /* Modification time */ int isenc; /* True if data is encrypted */ unsigned char *data; /* File data if written */ struct ZipEntry *next; /* Next file in the same archive */ struct ZipEntry *tnext; /* Next top-level dir in archive */ |
︙ | ︙ | |||
183 184 185 186 187 188 189 | ZipFile *zipfile; /* The ZIP file holding this channel */ ZipEntry *zipentry; /* Pointer back to virtual file */ unsigned long nmax; /* Max. size for write */ unsigned long nbyte; /* Number of bytes of uncompressed data */ unsigned long nread; /* Pos of next byte to be read from the channel */ unsigned char *ubuf; /* Pointer to the uncompressed data */ int iscompr; /* True if data is compressed */ | | | 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | ZipFile *zipfile; /* The ZIP file holding this channel */ ZipEntry *zipentry; /* Pointer back to virtual file */ unsigned long nmax; /* Max. size for write */ unsigned long nbyte; /* Number of bytes of uncompressed data */ unsigned long nread; /* Pos of next byte to be read from the channel */ unsigned char *ubuf; /* Pointer to the uncompressed data */ int iscompr; /* True if data is compressed */ int isdir; /* Set to 1 if directory, -1 if root */ int isenc; /* True if data is encrypted */ int iswr; /* True if open for writing */ unsigned long keys[3]; /* Key for decryption */ } ZipChannel; /* * Global variables. |
︙ | ︙ | |||
515 516 517 518 519 520 521 | continue; } } } path[j++] = c; } if (j == 0) { | | | 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 | continue; } } } path[j++] = c; } if (j == 0) { path[j++] = '/'; } path[j] = 0; Tcl_DStringSetLength(dsPtr, j); return Tcl_DStringValue(dsPtr); } /* |
︙ | ︙ | |||
747 748 749 750 751 752 753 | zf->data = MAP_FAILED; } #endif if (zf->tofree != NULL) { Tcl_Free((char *) zf->tofree); zf->tofree = NULL; } | > | | > | 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 | zf->data = MAP_FAILED; } #endif if (zf->tofree != NULL) { Tcl_Free((char *) zf->tofree); zf->tofree = NULL; } if (zf->chan != NULL) { Tcl_Close(interp, zf->chan); zf->chan = NULL; } } /* *------------------------------------------------------------------------- * * ZipFSOpenArchive -- * |
︙ | ︙ | |||
1169 1170 1171 1172 1173 1174 1175 | } if (mntpt[0] != '\0') { z = (ZipEntry *) Tcl_Alloc(sizeof (*z)); z->name = NULL; z->tnext = NULL; z->depth = CountSlashes(mntpt); z->zipfile = zf; | | | 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 | } if (mntpt[0] != '\0') { z = (ZipEntry *) Tcl_Alloc(sizeof (*z)); z->name = NULL; z->tnext = NULL; z->depth = CountSlashes(mntpt); z->zipfile = zf; z->isdir = (zf->baseoffs == 0) ? 1 : -1; /* root marker */ z->isenc = 0; z->offset = zf->baseoffs; z->crc32 = 0; z->timestamp = 0; z->nbyte = z->nbytecompr = 0; z->cmeth = ZIP_COMPMETH_STORED; z->data = NULL; |
︙ | ︙ | |||
1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 | static int ZipChannelRead(ClientData instanceData, char *buf, int toRead, int *errloc) { ZipChannel *info = (ZipChannel *) instanceData; unsigned long nextpos; if (info->isdir) { *errloc = EISDIR; return -1; } nextpos = info->nread + toRead; if (nextpos > info->nbyte) { toRead = info->nbyte - info->nread; | > > > > > > > > > > > > > > > > > > | 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 | static int ZipChannelRead(ClientData instanceData, char *buf, int toRead, int *errloc) { ZipChannel *info = (ZipChannel *) instanceData; unsigned long nextpos; if (info->isdir < 0) { /* * Special case: when executable combined with ZIP archive file * read data in front of ZIP, i.e. the executable itself. */ nextpos = info->nread + toRead; if (nextpos > info->zipfile->baseoffs) { toRead = info->zipfile->baseoffs - info->nread; nextpos = info->zipfile->baseoffs; } if (toRead == 0) { return 0; } memcpy(buf, info->zipfile->data, toRead); info->nread = nextpos; *errloc = 0; return toRead; } if (info->isdir) { *errloc = EISDIR; return -1; } nextpos = info->nread + toRead; if (nextpos > info->nbyte) { toRead = info->nbyte - info->nread; |
︙ | ︙ | |||
1839 1840 1841 1842 1843 1844 1845 1846 | *------------------------------------------------------------------------- */ static int ZipChannelSeek(ClientData instanceData, long offset, int mode, int *errloc) { ZipChannel *info = (ZipChannel *) instanceData; | > > > > > > > | > > | | | 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 | *------------------------------------------------------------------------- */ static int ZipChannelSeek(ClientData instanceData, long offset, int mode, int *errloc) { ZipChannel *info = (ZipChannel *) instanceData; unsigned long end; if (!info->iswr && (info->isdir < 0)) { /* * Special case: when executable combined with ZIP archive file, * seek within front of ZIP, i.e. the executable itself. */ end = info->zipfile->baseoffs; } else if (info->isdir) { *errloc = EINVAL; return -1; } else { end = info->nbyte; } switch (mode) { case SEEK_CUR: offset += info->nread; break; case SEEK_END: offset += end; break; case SEEK_SET: break; default: *errloc = EINVAL; return -1; } if (offset < 0) { *errloc = EINVAL; return -1; } if (info->iswr) { if ((unsigned long) offset > info->nmax) { *errloc = EINVAL; return -1; } if ((unsigned long) offset > info->nbyte) { info->nbyte = offset; } } else if ((unsigned long) offset > end) { *errloc = EINVAL; return -1; } info->nread = (unsigned long) offset; return info->nread; } |
︙ | ︙ | |||
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 | Tcl_GlobTypeData *types) { Tcl_HashEntry *hPtr; Tcl_HashSearch search; int scnt, len, l, dirOnly = -1, prefixLen, strip = 0, matchHidden = 0; char *pat, *prefix, *path, *p; #if HAS_DRIVES char drivePrefix[3]; #endif Tcl_DString ds, dsPref; #if HAS_DRIVES if ((pattern != NULL) && (pattern[0] != '\0') && (strchr(drvletters, pattern[0]) != NULL) && (pattern[1] == ':')) { | > | 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 | Tcl_GlobTypeData *types) { Tcl_HashEntry *hPtr; Tcl_HashSearch search; int scnt, len, l, dirOnly = -1, prefixLen, strip = 0, matchHidden = 0; char *pat, *prefix, *path, *p; #if HAS_DRIVES int drive = 0; char drivePrefix[3]; #endif Tcl_DString ds, dsPref; #if HAS_DRIVES if ((pattern != NULL) && (pattern[0] != '\0') && (strchr(drvletters, pattern[0]) != NULL) && (pattern[1] == ':')) { |
︙ | ︙ | |||
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 | Tcl_DStringAppend(&dsPref, drivePrefix, -1); prefixLen = Tcl_DStringLength(&dsPref); } else { Tcl_DStringAppend(&dsPref, "/", 1); prefixLen++; } prefix = Tcl_DStringValue(&dsPref); #else Tcl_DStringAppend(&dsPref, "/", 1); prefixLen++; prefix = Tcl_DStringValue(&dsPref); #endif } if ((pattern != NULL) && ((pattern[0] == '.') || | > > > > | 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 | Tcl_DStringAppend(&dsPref, drivePrefix, -1); prefixLen = Tcl_DStringLength(&dsPref); } else { Tcl_DStringAppend(&dsPref, "/", 1); prefixLen++; } prefix = Tcl_DStringValue(&dsPref); drive = prefix[0]; if ((drive >= 'a') && (drive <= 'z')) { drive -= 'a' - 'A'; } #else Tcl_DStringAppend(&dsPref, "/", 1); prefixLen++; prefix = Tcl_DStringValue(&dsPref); #endif } if ((pattern != NULL) && ((pattern[0] == '.') || |
︙ | ︙ | |||
2545 2546 2547 2548 2549 2550 2551 | len--; } else { l++; } if ((pattern == NULL) || (pattern[0] == '\0')) { pattern = "*"; } | | | > > > > > | 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 | len--; } else { l++; } if ((pattern == NULL) || (pattern[0] == '\0')) { pattern = "*"; } for (hPtr = Tcl_FirstHashEntry(&ZipFS.zipHash, &search); hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { ZipFile *zf = (ZipFile *) Tcl_GetHashValue(hPtr); #if HAS_DRIVES if (drive && (drive != zf->mntdrv)) { continue; } #endif if (zf->mntptlen == 0) { ZipEntry *z = zf->topents; while (z != NULL) { int lenz = strlen(z->name); if ((lenz > len + 1) && |
︙ | ︙ | |||
2602 2603 2604 2605 2606 2607 2608 | Tcl_DStringLength(&dsPref))); Tcl_DStringSetLength(&dsPref, prefixLen); } else { Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(zf->mntpt, zf->mntptlen)); } } | < > > > > > | 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 | Tcl_DStringLength(&dsPref))); Tcl_DStringSetLength(&dsPref, prefixLen); } else { Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(zf->mntpt, zf->mntptlen)); } } } goto end; } if ((pattern == NULL) || (pattern[0] == '\0')) { hPtr = Tcl_FindHashEntry(&ZipFS.fileHash, path); if (hPtr != NULL) { ZipEntry *z = (ZipEntry *) Tcl_GetHashValue(hPtr); #if HAS_DRIVES if (drive && (drive != z->zipfile->mntdrv)) { goto end; } #endif if ((dirOnly < 0) || (!dirOnly && !z->isdir) || (dirOnly && z->isdir)) { if (prefix != NULL) { Tcl_DStringAppend(&dsPref, z->name, -1); Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(Tcl_DStringValue(&dsPref), |
︙ | ︙ | |||
2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 | hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { ZipEntry *z = (ZipEntry *) Tcl_GetHashValue(hPtr); if ((dirOnly >= 0) && ((dirOnly && !z->isdir) || (!dirOnly && z->isdir))) { continue; } if ((z->depth == scnt) && Tcl_StringCaseMatch(z->name, pat, 0)) { if (!matchHidden) { p = strrchr(z->name, '/'); if ((p != NULL) && (p[1] == '.')) { continue; } } | > > > > > | 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 | hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) { ZipEntry *z = (ZipEntry *) Tcl_GetHashValue(hPtr); if ((dirOnly >= 0) && ((dirOnly && !z->isdir) || (!dirOnly && z->isdir))) { continue; } #if HAS_DRIVES if (drive && (drive != z->zipfile->mntdrv)) { continue; } #endif if ((z->depth == scnt) && Tcl_StringCaseMatch(z->name, pat, 0)) { if (!matchHidden) { p = strrchr(z->name, '/'); if ((p != NULL) && (p[1] == '.')) { continue; } } |
︙ | ︙ | |||
2839 2840 2841 2842 2843 2844 2845 | while (hPtr != NULL) { zf = (ZipFile *) Tcl_GetHashValue(hPtr); /* * Volumes which overlay root are hidden. */ #if HAS_DRIVES if (zf->mntpt[0]) { | | | 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 | while (hPtr != NULL) { zf = (ZipFile *) Tcl_GetHashValue(hPtr); /* * Volumes which overlay root are hidden. */ #if HAS_DRIVES if (zf->mntpt[0]) { vol = Tcl_ObjPrintf("%c:%s", zf->mntdrv, zf->mntpt); Tcl_ListObjAppendElement(NULL, vols, vol); } #else if (zf->mntpt[0]) { vol = Tcl_NewStringObj(zf->mntpt, zf->mntptlen); Tcl_ListObjAppendElement(NULL, vols, vol); } |
︙ | ︙ | |||
3263 3264 3265 3266 3267 3268 3269 | Tcl_ConditionWait(&ZipFSCond, &ZipFSMutex, &t); Tcl_MutexUnlock(&ZipFSMutex); #endif Tcl_FSRegister(NULL, &zipfsFilesystem); Tcl_InitHashTable(&ZipFS.fileHash, TCL_STRING_KEYS); Tcl_InitHashTable(&ZipFS.zipHash, TCL_STRING_KEYS); ZipFS.initialized = ZipFS.idCount = 1; | > > | | > > > | | | | 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 | Tcl_ConditionWait(&ZipFSCond, &ZipFSMutex, &t); Tcl_MutexUnlock(&ZipFSMutex); #endif Tcl_FSRegister(NULL, &zipfsFilesystem); Tcl_InitHashTable(&ZipFS.fileHash, TCL_STRING_KEYS); Tcl_InitHashTable(&ZipFS.zipHash, TCL_STRING_KEYS); ZipFS.initialized = ZipFS.idCount = 1; #if defined(ZIPFS_IN_TCL) || defined(ZIPFS_IN_TK) if (interp != NULL) { Tcl_StaticPackage(interp, "zipfs", Tclzipfs_Init, Tclzipfs_SafeInit); } #endif } Unlock(); if (interp != NULL) { TclMakeEnsemble(interp, "zipfs", safe ? initSafeMap : initMap); Tcl_PkgProvide(interp, "zipfs", "1.0"); } return TCL_OK; #else if (interp != NULL) { Tcl_SetObjResult(interp, Tcl_NewStringObj("no zlib available", -1)); } return TCL_ERROR; #endif |
︙ | ︙ |