Subversion Repositories eduke32

Rev

Rev 5058 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5058 Rev 5059
Line 596... Line 596...
596
596
597
#if defined(_WIN32) && defined(DEBUGGINGAIDS)
597
#if defined(_WIN32) && defined(DEBUGGINGAIDS)
598
# define FILENAME_CASE_CHECK
598
# define FILENAME_CASE_CHECK
599
#endif
599
#endif
600
600
601
#ifdef FILENAME_CASE_CHECK
-
 
602
// don't free pfn if !=0 AND we Bopen()'ed the file successfully
601
static int32_t openfrompath_internal(const char *fn, char **where, int32_t flags, int32_t mode)
-
 
602
{
603
static int32_t dont_free_pfn;
603
    if (findfrompath(fn, where) < 0)
604
static char *lastpfn;
604
        return -1;
-
 
605
-
 
606
    return Bopen(*where, flags, mode);
605
#endif
607
}
606
608
607
int32_t openfrompath(const char *fn, int32_t flags, int32_t mode)
609
int32_t openfrompath(const char *fn, int32_t flags, int32_t mode)
608
{
610
{
609
    char *pfn;
611
    char *pfn = NULL;
610
    int32_t h;
-
 
611
612
612
    if (findfrompath(fn, &pfn) < 0) return -1;
613
    int32_t h = openfrompath_internal(fn, &pfn, flags, mode);
613
614
614
    h = Bopen(pfn, flags, mode);
-
 
615
#ifdef FILENAME_CASE_CHECK
-
 
616
    if (h>=0 && dont_free_pfn)
-
 
617
        lastpfn = pfn;
-
 
618
    else
615
    if (pfn)
619
#endif
-
 
620
        Bfree(pfn);
616
        Bfree(pfn);
621
617
622
    return h;
618
    return h;
623
}
619
}
624
620
Line 662... Line 658...
662
658
663
EDUKE32_STATIC_ASSERT(MAXGROUPFILES <= GRP_RESERVED_ID_START);
659
EDUKE32_STATIC_ASSERT(MAXGROUPFILES <= GRP_RESERVED_ID_START);
664
660
665
int32_t numgroupfiles = 0;
661
int32_t numgroupfiles = 0;
666
static int32_t gnumfiles[MAXGROUPFILES];
662
static int32_t gnumfiles[MAXGROUPFILES];
667
static int32_t groupfil[MAXGROUPFILES] = {-1,-1,-1,-1,-1,-1,-1,-1};
663
static intptr_t groupfil[MAXGROUPFILES] = {-1,-1,-1,-1,-1,-1,-1,-1};
668
static int32_t groupfilpos[MAXGROUPFILES];
664
static int32_t groupfilpos[MAXGROUPFILES];
-
 
665
static uint8_t groupfilgrp[MAXGROUPFILES];
669
static char *gfilelist[MAXGROUPFILES];
666
static char *gfilelist[MAXGROUPFILES];
670
static int32_t *gfileoffs[MAXGROUPFILES];
667
static int32_t *gfileoffs[MAXGROUPFILES];
671
668
672
static uint8_t filegrp[MAXOPENFILES];
669
static uint8_t filegrp[MAXOPENFILES];
673
static int32_t filepos[MAXOPENFILES];
670
static int32_t filepos[MAXOPENFILES];
Line 687... Line 684...
687
{
684
{
688
    return (filegrp[fil] == GRP_ZIP);
685
    return (filegrp[fil] == GRP_ZIP);
689
}
686
}
690
#endif
687
#endif
691
688
-
 
689
static int32_t kopen_internal(const char *filename, char **lastpfn, char searchfirst, char checkcase, char tryzip, int32_t newhandle, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos);
-
 
690
static int32_t kread_grp(int32_t handle, void *buffer, int32_t leng);
-
 
691
static int32_t klseek_grp(int32_t handle, int32_t offset, int32_t whence);
-
 
692
static void kclose_grp(int32_t handle);
-
 
693
692
int32_t initgroupfile(const char *filename)
694
int32_t initgroupfile(const char *filename)
693
{
695
{
694
    char buf[16];
696
    char buf[16];
695
    int32_t i, j, k;
-
 
696
#ifdef WITHKPLIB
-
 
697
    char *zfn;
-
 
698
#endif
-
 
699
697
700
    // translate all backslashes (0x5c) to forward slashes (0x2f)
698
    // translate all backslashes (0x5c) to forward slashes (0x2f)
701
    toupperlookup[0x5c] = 0x2f;
699
    toupperlookup[0x5c] = 0x2f;
702
700
703
#ifdef WITHKPLIB
701
    if (filename == NULL)
704
    if (findfrompath(filename, &zfn) < 0) return -1;
702
        return -1;
705
703
706
    // check to see if the file passed is a ZIP and pass it on to kplib if it is
704
    // Technically you should be able to load more zips even if your GRPs are maxed out,
-
 
705
    // but this system is already enough of a disaster.
707
    i = Bopen(zfn,BO_BINARY|BO_RDONLY,BS_IREAD);
706
    if (numgroupfiles >= MAXGROUPFILES)
708
    if (i < 0) { Bfree(zfn); return -1; }
707
        return -1;
709
708
-
 
709
    char *zfn = NULL;
-
 
710
-
 
711
    if (kopen_internal(filename, &zfn, 0, 0, 0, numgroupfiles, groupfilgrp, groupfil, groupfilpos) < 0)
-
 
712
        return -1;
-
 
713
-
 
714
#ifdef WITHKPLIB
710
    Bread(i, buf, 4);
715
    // check if ZIP
-
 
716
    if (zfn)
-
 
717
    {
-
 
718
        kread_grp(numgroupfiles, buf, 4);
711
    if (buf[0] == 0x50 && buf[1] == 0x4B && buf[2] == 0x03 && buf[3] == 0x04)
719
        if (buf[0] == 0x50 && buf[1] == 0x4B && buf[2] == 0x03 && buf[3] == 0x04)
712
    {
720
        {
713
        Bclose(i);
721
            kclose_grp(numgroupfiles);
-
 
722
714
        j = kzaddstack(zfn);
723
            kzaddstack(zfn);
715
        Bfree(zfn);
724
            Bfree(zfn);
716
        return j;
725
            return 0;
717
    }
726
        }
718
    Bfree(zfn);
-
 
719
-
 
720
    if (numgroupfiles >= MAXGROUPFILES) return(-1);
727
        klseek_grp(numgroupfiles,0,BSEEK_SET);
721
728
722
    Blseek(i,0,BSEEK_SET);
729
        Bfree(zfn);
723
    groupfil[numgroupfiles] = i;
730
    }
724
#else
731
#else
725
    groupfil[numgroupfiles] = openfrompath(filename,BO_BINARY|BO_RDONLY,BS_IREAD);
732
    if (zfn)
726
    if (groupfil[numgroupfiles] != -1)
733
        Bfree(zfn);
727
#endif
734
#endif
-
 
735
-
 
736
    // check if GRP
-
 
737
    kread_grp(numgroupfiles,buf,16);
-
 
738
    if (!Bmemcmp(buf, "KenSilverman", 12))
728
    {
739
    {
729
        groupfilpos[numgroupfiles] = 0;
-
 
730
        Bread(groupfil[numgroupfiles],buf,16);
-
 
731
        if (Bmemcmp(buf, "KenSilverman", 12))
-
 
732
        {
-
 
733
            Bclose(groupfil[numgroupfiles]);
-
 
734
            groupfil[numgroupfiles] = -1;
-
 
735
            return(-1);
-
 
736
        }
-
 
737
        gnumfiles[numgroupfiles] = B_LITTLE32(*((int32_t *)&buf[12]));
740
        gnumfiles[numgroupfiles] = B_LITTLE32(*((int32_t *)&buf[12]));
738
741
739
        gfilelist[numgroupfiles] = (char *)Xmalloc(gnumfiles[numgroupfiles]<<4);
742
        gfilelist[numgroupfiles] = (char *)Xmalloc(gnumfiles[numgroupfiles]<<4);
740
        gfileoffs[numgroupfiles] = (int32_t *)Xmalloc((gnumfiles[numgroupfiles]+1)<<2);
743
        gfileoffs[numgroupfiles] = (int32_t *)Xmalloc((gnumfiles[numgroupfiles]+1)<<2);
741
744
742
        Bread(groupfil[numgroupfiles],gfilelist[numgroupfiles],gnumfiles[numgroupfiles]<<4);
745
        kread_grp(numgroupfiles,gfilelist[numgroupfiles],gnumfiles[numgroupfiles]<<4);
743
746
744
        j = 0;
747
        int32_t j = (gnumfiles[numgroupfiles]+1)<<4, k;
745
        for (i=0; i<gnumfiles[numgroupfiles]; i++)
748
        for (int32_t i=0; i<gnumfiles[numgroupfiles]; i++)
746
        {
749
        {
747
            k = B_LITTLE32(*((int32_t *)&gfilelist[numgroupfiles][(i<<4)+12]));
750
            k = B_LITTLE32(*((int32_t *)&gfilelist[numgroupfiles][(i<<4)+12]));
748
            gfilelist[numgroupfiles][(i<<4)+12] = 0;
751
            gfilelist[numgroupfiles][(i<<4)+12] = 0;
749
            gfileoffs[numgroupfiles][i] = j;
752
            gfileoffs[numgroupfiles][i] = j;
750
            j += k;
753
            j += k;
751
        }
754
        }
752
        gfileoffs[numgroupfiles][gnumfiles[numgroupfiles]] = j;
755
        gfileoffs[numgroupfiles][gnumfiles[numgroupfiles]] = j;
753
    }
-
 
754
    numgroupfiles++;
756
        numgroupfiles++;
755
    return(groupfil[numgroupfiles-1]);
-
 
756
}
-
 
757
-
 
758
void uninitsinglegroupfile(int32_t grphandle)
-
 
759
{
-
 
760
    int32_t i, grpnum = -1;
-
 
761
-
 
762
    for (i=numgroupfiles-1; i>=0; i--)
-
 
763
        if (groupfil[i] != -1 && groupfil[i] == grphandle)
-
 
764
        {
-
 
765
            Bfree(gfilelist[i]);
-
 
766
            Bfree(gfileoffs[i]);
-
 
767
            Bclose(groupfil[i]);
-
 
768
            groupfil[i] = -1;
-
 
769
            grpnum = i;
-
 
770
            break;
757
        return 0;
771
        }
-
 
772
-
 
773
    if (grpnum == -1) return;
-
 
774
-
 
775
    // JBF 20040111
-
 
776
    numgroupfiles--;
-
 
777
-
 
778
    // move any group files following this one back
-
 
779
    for (i=grpnum+1; i<MAXGROUPFILES; i++)
-
 
780
        if (groupfil[i] != -1)
-
 
781
        {
-
 
782
            groupfil[i-1]    = groupfil[i];
-
 
783
            gnumfiles[i-1]   = gnumfiles[i];
-
 
784
            groupfilpos[i-1] = groupfilpos[i];
-
 
785
            gfilelist[i-1]   = gfilelist[i];
-
 
786
            gfileoffs[i-1]   = gfileoffs[i];
-
 
787
            groupfil[i] = -1;
-
 
788
        }
758
    }
789
759
790
    // fix up the open files that need attention
-
 
791
    for (i=0; i<MAXOPENFILES; i++)
-
 
792
    {
-
 
793
        if (filegrp[i] >= GRP_RESERVED_ID_START)         // external file or ZIPped file
-
 
794
            continue;
-
 
795
        else if (filegrp[i] == grpnum)   // close file in group we closed
-
 
796
            filehan[i] = -1;
-
 
797
        else if (filegrp[i] > grpnum)   // move back a file in a group after the one we closed
-
 
798
            filegrp[i]--;
760
    kclose_grp(numgroupfiles);
799
    }
761
    return -1;
800
}
762
}
801
763
802
void uninitgroupfile(void)
764
void uninitgroupfile(void)
803
{
765
{
804
    int32_t i;
766
    int32_t i;
Line 867... Line 829...
867
829
868
    return 1;
830
    return 1;
869
}
831
}
870
#endif
832
#endif
871
833
872
int32_t kopen4load(const char *filename, char searchfirst)
834
static int32_t kopen_internal(const char *filename, char **lastpfn, char searchfirst, char checkcase, char tryzip, int32_t newhandle, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos)
873
{
835
{
874
    int32_t  j, k, fil, newhandle = MAXOPENFILES-1;
836
    int32_t j, k, fil;
875
    char bad, *gfileptr;
837
    char bad, *gfileptr;
876
    intptr_t i;
838
    intptr_t i;
877
839
878
#ifdef FILENAME_CASE_CHECK
-
 
879
    const int32_t do_case_check = check_filename_casing_fn && check_filename_casing_fn();
-
 
880
#endif
-
 
881
-
 
882
    if (filename==NULL)
-
 
883
        return -1;
-
 
884
-
 
885
    while (filehan[newhandle] != -1)
-
 
886
    {
-
 
887
        newhandle--;
-
 
888
        if (newhandle < 0)
-
 
889
        {
-
 
890
            Bprintf("TOO MANY FILES OPEN IN FILE GROUPING SYSTEM!");
-
 
891
            Bexit(0);
-
 
892
        }
-
 
893
    }
-
 
894
-
 
895
#ifdef FILENAME_CASE_CHECK
-
 
896
    dont_free_pfn = do_case_check;
-
 
897
#endif
-
 
898
-
 
899
    if (searchfirst == 0 && (fil = openfrompath(filename,BO_BINARY|BO_RDONLY,BS_IREAD)) >= 0)
840
    if (searchfirst == 0 && (fil = openfrompath_internal(filename, lastpfn, BO_BINARY|BO_RDONLY, BS_IREAD)) >= 0)
900
    {
841
    {
901
#ifdef FILENAME_CASE_CHECK
842
#ifdef FILENAME_CASE_CHECK
902
        if (check_filename_casing_fn && check_filename_casing_fn())
843
        if (checkcase && check_filename_casing_fn && check_filename_casing_fn())
903
        {
844
        {
904
            int32_t status;
845
            int32_t status;
905
            char *cp, *lastslash;
846
            char *cp, *lastslash;
906
847
907
            // convert all slashes to backslashes because SHGetFileInfo()
848
            // convert all slashes to backslashes because SHGetFileInfo()
908
            // complains else!
849
            // complains else!
909
            lastslash = lastpfn;
850
            lastslash = *lastpfn;
910
            for (cp=lastpfn; *cp; cp++)
851
            for (cp=*lastpfn; *cp; cp++)
911
                if (*cp=='/')
852
                if (*cp=='/')
912
                {
853
                {
913
                    *cp = '\\';
854
                    *cp = '\\';
914
                    lastslash = cp;
855
                    lastslash = cp;
915
                }
856
                }
916
            if (lastslash != lastpfn)
857
            if (lastslash != *lastpfn)
917
                lastslash++;
858
                lastslash++;
918
859
919
            status = check_filename_mismatch(lastpfn, lastslash-lastpfn);
860
            status = check_filename_mismatch(*lastpfn, lastslash-*lastpfn);
920
-
 
921
            dont_free_pfn = 0;
-
 
922
861
923
            if (status == -1)
862
            if (status == -1)
924
            {
863
            {
925
//                initprintf("SHGetFileInfo failed with error code %lu\n", GetLastError());
864
//                initprintf("SHGetFileInfo failed with error code %lu\n", GetLastError());
926
            }
865
            }
927
            else if (status == 1)
866
            else if (status == 1)
928
            {
867
            {
929
                initprintf("warning: case mismatch: passed \"%s\", real \"%s\"\n",
868
                initprintf("warning: case mismatch: passed \"%s\", real \"%s\"\n",
930
                           lastslash, shinf.szDisplayName);
869
                           lastslash, shinf.szDisplayName);
931
            }
870
            }
932
-
 
933
            Bfree(lastpfn);
-
 
934
            lastpfn=NULL;
-
 
935
        }
871
        }
-
 
872
#else
-
 
873
        UNREFERENCED_PARAMETER(checkcase);
936
#endif
874
#endif
937
        filegrp[newhandle] = GRP_FILESYSTEM;
875
        arraygrp[newhandle] = GRP_FILESYSTEM;
938
        filehan[newhandle] = fil;
876
        arrayhan[newhandle] = fil;
939
        filepos[newhandle] = 0;
877
        arraypos[newhandle] = 0;
940
        return(newhandle);
878
        return newhandle;
941
    }
879
    }
942
880
943
#ifdef FILENAME_CASE_CHECK
-
 
944
    dont_free_pfn = 0;
-
 
945
#endif
-
 
946
-
 
947
    for (; toupperlookup[*filename] == '/'; filename++);
881
    for (; toupperlookup[*filename] == '/'; filename++);
948
882
949
#ifdef WITHKPLIB
883
#ifdef WITHKPLIB
-
 
884
    if (tryzip)
-
 
885
    {
950
    if ((kzcurhand != newhandle) && (kztell() >= 0))
886
        if ((kzcurhand != newhandle) && (kztell() >= 0))
951
    {
887
        {
952
        if (kzcurhand >= 0) filepos[kzcurhand] = kztell();
888
            if (kzcurhand >= 0) arraypos[kzcurhand] = kztell();
953
        kzclose();
889
            kzclose();
954
    }
890
        }
955
    if (searchfirst != 1 && (i = kzipopen(filename)) != 0)
891
        if (searchfirst != 1 && (i = kzipopen(filename)) != 0)
956
    {
892
        {
957
        kzcurhand = newhandle;
893
            kzcurhand = newhandle;
958
        filegrp[newhandle] = GRP_ZIP;
894
            arraygrp[newhandle] = GRP_ZIP;
959
        filehan[newhandle] = i;
895
            arrayhan[newhandle] = i;
960
        filepos[newhandle] = 0;
896
            arraypos[newhandle] = 0;
961
        strcpy(filenamsav[newhandle],filename);
897
            strcpy(filenamsav[newhandle],filename);
962
        return newhandle;
898
            return newhandle;
963
    }
899
        }
-
 
900
    }
-
 
901
#else
-
 
902
    UNREFERENCED_PARAMETER(tryzip);
964
#endif
903
#endif
965
904
966
    for (k=numgroupfiles-1; k>=0; k--)
905
    for (k=numgroupfiles-1; k>=0; k--)
967
    {
906
    {
968
        if (searchfirst == 1) k = 0;
907
        if (searchfirst == 1) k = 0;
Line 984... Line 923...
984
                }
923
                }
985
                if (bad) continue;
924
                if (bad) continue;
986
                if (j<13 && gfileptr[j]) continue;   // JBF: because e1l1.map might exist before e1l1
925
                if (j<13 && gfileptr[j]) continue;   // JBF: because e1l1.map might exist before e1l1
987
                if (j==13 && filename[j]) continue;   // JBF: long file name
926
                if (j==13 && filename[j]) continue;   // JBF: long file name
988
927
989
                filegrp[newhandle] = k;
928
                arraygrp[newhandle] = k;
990
                filehan[newhandle] = i;
929
                arrayhan[newhandle] = i;
991
                filepos[newhandle] = 0;
930
                arraypos[newhandle] = 0;
992
                return(newhandle);
931
                return newhandle;
993
            }
932
            }
994
        }
933
        }
995
    }
934
    }
-
 
935
996
    return(-1);
936
    return -1;
997
}
937
}
998
938
999
int32_t kread(int32_t handle, void *buffer, int32_t leng)
939
int32_t kopen4load(const char *filename, char searchfirst)
1000
{
940
{
-
 
941
    int32_t newhandle = MAXOPENFILES-1;
-
 
942
-
 
943
    if (filename==NULL)
-
 
944
        return -1;
-
 
945
-
 
946
    while (filehan[newhandle] != -1)
-
 
947
    {
-
 
948
        newhandle--;
-
 
949
        if (newhandle < 0)
-
 
950
        {
-
 
951
            Bprintf("TOO MANY FILES OPEN IN FILE GROUPING SYSTEM!");
-
 
952
            Bexit(0);
-
 
953
        }
-
 
954
    }
-
 
955
-
 
956
    char *lastpfn = NULL;
-
 
957
-
 
958
    int32_t h = kopen_internal(filename, &lastpfn, searchfirst, 1, 1, newhandle, filegrp, filehan, filepos);
-
 
959
-
 
960
    if (lastpfn)
-
 
961
        Bfree(lastpfn);
-
 
962
1001
    int32_t i;
963
    return h;
-
 
964
}
-
 
965
-
 
966
int32_t kread_internal(int32_t handle, void *buffer, int32_t leng, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos)
-
 
967
{
1002
    int32_t filenum = filehan[handle];
968
    int32_t filenum = arrayhan[handle];
1003
    int32_t groupnum = filegrp[handle];
969
    int32_t groupnum = arraygrp[handle];
1004
970
1005
    if (groupnum == GRP_FILESYSTEM) return(Bread(filenum,buffer,leng));
971
    if (groupnum == GRP_FILESYSTEM) return(Bread(filenum,buffer,leng));
1006
#ifdef WITHKPLIB
972
#ifdef WITHKPLIB
1007
    else if (groupnum == GRP_ZIP)
973
    else if (groupnum == GRP_ZIP)
1008
    {
974
    {
1009
        if (kzcurhand != handle)
975
        if (kzcurhand != handle)
1010
        {
976
        {
1011
            if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
977
            if (kztell() >= 0) { arraypos[kzcurhand] = kztell(); kzclose(); }
1012
            kzcurhand = handle;
978
            kzcurhand = handle;
1013
            kzipopen(filenamsav[handle]);
979
            kzipopen(filenamsav[handle]);
1014
            kzseek(filepos[handle],SEEK_SET);
980
            kzseek(arraypos[handle],SEEK_SET);
1015
        }
981
        }
1016
        return(kzread(buffer,leng));
982
        return(kzread(buffer,leng));
1017
    }
983
    }
1018
#endif
984
#endif
1019
985
1020
    if (groupfil[groupnum] != -1)
986
    if (EDUKE32_PREDICT_FALSE(groupfil[groupnum] == -1))
-
 
987
        return 0;
-
 
988
-
 
989
    int32_t rootgroupnum = groupnum;
-
 
990
    int32_t i = 0;
-
 
991
    while (groupfilgrp[rootgroupnum] != GRP_FILESYSTEM)
-
 
992
    {
-
 
993
        i += gfileoffs[groupfilgrp[rootgroupnum]][groupfil[rootgroupnum]];
-
 
994
        rootgroupnum = groupfilgrp[rootgroupnum];
-
 
995
    }
-
 
996
    if (EDUKE32_PREDICT_TRUE(groupfil[rootgroupnum] != -1))
1021
    {
997
    {
1022
        i = gfileoffs[groupnum][filenum]+filepos[handle];
998
        i += gfileoffs[groupnum][filenum]+arraypos[handle];
1023
        if (i != groupfilpos[groupnum])
999
        if (i != groupfilpos[rootgroupnum])
1024
        {
1000
        {
1025
            Blseek(groupfil[groupnum],i+((gnumfiles[groupnum]+1)<<4),BSEEK_SET);
1001
            Blseek(groupfil[rootgroupnum],i,BSEEK_SET);
1026
            groupfilpos[groupnum] = i;
1002
            groupfilpos[rootgroupnum] = i;
1027
        }
1003
        }
1028
        leng = min(leng,(gfileoffs[groupnum][filenum+1]-gfileoffs[groupnum][filenum])-filepos[handle]);
1004
        leng = min(leng,(gfileoffs[groupnum][filenum+1]-gfileoffs[groupnum][filenum])-arraypos[handle]);
1029
        leng = Bread(groupfil[groupnum],buffer,leng);
1005
        leng = Bread(groupfil[rootgroupnum],buffer,leng);
1030
        filepos[handle] += leng;
1006
        arraypos[handle] += leng;
1031
        groupfilpos[groupnum] += leng;
1007
        groupfilpos[rootgroupnum] += leng;
1032
        return(leng);
1008
        return(leng);
1033
    }
1009
    }
1034
1010
1035
    return(0);
1011
    return(0);
1036
}
1012
}
1037
1013
1038
int32_t klseek(int32_t handle, int32_t offset, int32_t whence)
1014
int32_t klseek_internal(int32_t handle, int32_t offset, int32_t whence, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos)
1039
{
1015
{
1040
    int32_t i, groupnum;
1016
    int32_t i, groupnum;
1041
1017
1042
    groupnum = filegrp[handle];
1018
    groupnum = arraygrp[handle];
1043
1019
1044
    if (groupnum == GRP_FILESYSTEM) return(Blseek(filehan[handle],offset,whence));
1020
    if (groupnum == GRP_FILESYSTEM) return(Blseek(arrayhan[handle],offset,whence));
1045
#ifdef WITHKPLIB
1021
#ifdef WITHKPLIB
1046
    else if (groupnum == GRP_ZIP)
1022
    else if (groupnum == GRP_ZIP)
1047
    {
1023
    {
1048
        if (kzcurhand != handle)
1024
        if (kzcurhand != handle)
1049
        {
1025
        {
1050
            if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
1026
            if (kztell() >= 0) { arraypos[kzcurhand] = kztell(); kzclose(); }
1051
            kzcurhand = handle;
1027
            kzcurhand = handle;
1052
            kzipopen(filenamsav[handle]);
1028
            kzipopen(filenamsav[handle]);
1053
            kzseek(filepos[handle],SEEK_SET);
1029
            kzseek(arraypos[handle],SEEK_SET);
1054
        }
1030
        }
1055
        return(kzseek(offset,whence));
1031
        return(kzseek(offset,whence));
1056
    }
1032
    }
1057
#endif
1033
#endif
1058
1034
1059
    if (groupfil[groupnum] != -1)
1035
    if (groupfil[groupnum] != -1)
1060
    {
1036
    {
1061
        switch (whence)
1037
        switch (whence)
1062
        {
1038
        {
1063
        case BSEEK_SET:
1039
        case BSEEK_SET:
1064
            filepos[handle] = offset; break;
1040
            arraypos[handle] = offset; break;
1065
        case BSEEK_END:
1041
        case BSEEK_END:
1066
            i = filehan[handle];
1042
            i = arrayhan[handle];
1067
            filepos[handle] = (gfileoffs[groupnum][i+1]-gfileoffs[groupnum][i])+offset;
1043
            arraypos[handle] = (gfileoffs[groupnum][i+1]-gfileoffs[groupnum][i])+offset;
1068
            break;
1044
            break;
1069
        case BSEEK_CUR:
1045
        case BSEEK_CUR:
1070
            filepos[handle] += offset; break;
1046
            arraypos[handle] += offset; break;
1071
        }
1047
        }
1072
        return(filepos[handle]);
1048
        return(arraypos[handle]);
1073
    }
1049
    }
1074
    return(-1);
1050
    return(-1);
1075
}
1051
}
1076
1052
1077
int32_t kfilelength(int32_t handle)
1053
int32_t kfilelength_internal(int32_t handle, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos)
1078
{
1054
{
1079
    int32_t i, groupnum;
1055
    int32_t i, groupnum;
1080
1056
1081
    groupnum = filegrp[handle];
1057
    groupnum = arraygrp[handle];
1082
    if (groupnum == GRP_FILESYSTEM)
1058
    if (groupnum == GRP_FILESYSTEM)
1083
    {
1059
    {
1084
        // return(filelength(filehan[handle]))
1060
        // return(filelength(arrayhan[handle]))
1085
        return Bfilelength(filehan[handle]);
1061
        return Bfilelength(arrayhan[handle]);
1086
    }
1062
    }
1087
#ifdef WITHKPLIB
1063
#ifdef WITHKPLIB
1088
    else if (groupnum == GRP_ZIP)
1064
    else if (groupnum == GRP_ZIP)
1089
    {
1065
    {
1090
        if (kzcurhand != handle)
1066
        if (kzcurhand != handle)
1091
        {
1067
        {
1092
            if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
1068
            if (kztell() >= 0) { arraypos[kzcurhand] = kztell(); kzclose(); }
1093
            kzcurhand = handle;
1069
            kzcurhand = handle;
1094
            kzipopen(filenamsav[handle]);
1070
            kzipopen(filenamsav[handle]);
1095
            kzseek(filepos[handle],SEEK_SET);
1071
            kzseek(arraypos[handle],SEEK_SET);
1096
        }
1072
        }
1097
        return kzfilelength();
1073
        return kzfilelength();
1098
    }
1074
    }
1099
#endif
1075
#endif
1100
    i = filehan[handle];
1076
    i = arrayhan[handle];
1101
    return(gfileoffs[groupnum][i+1]-gfileoffs[groupnum][i]);
1077
    return(gfileoffs[groupnum][i+1]-gfileoffs[groupnum][i]);
1102
}
1078
}
1103
1079
1104
int32_t ktell(int32_t handle)
1080
int32_t ktell_internal(int32_t handle, uint8_t *arraygrp, intptr_t *arrayhan, int32_t *arraypos)
1105
{
1081
{
1106
    int32_t groupnum = filegrp[handle];
1082
    int32_t groupnum = arraygrp[handle];
1107
1083
1108
    if (groupnum == GRP_FILESYSTEM) return(Blseek(filehan[handle],0,BSEEK_CUR));
1084
    if (groupnum == GRP_FILESYSTEM) return(Blseek(arrayhan[handle],0,BSEEK_CUR));
1109
#ifdef WITHKPLIB
1085
#ifdef WITHKPLIB
1110
    else if (groupnum == GRP_ZIP)
1086
    else if (groupnum == GRP_ZIP)
1111
    {
1087
    {
1112
        if (kzcurhand != handle)
1088
        if (kzcurhand != handle)
1113
        {
1089
        {
1114
            if (kztell() >= 0) { filepos[kzcurhand] = kztell(); kzclose(); }
1090
            if (kztell() >= 0) { arraypos[kzcurhand] = kztell(); kzclose(); }
1115
            kzcurhand = handle;
1091
            kzcurhand = handle;
1116
            kzipopen(filenamsav[handle]);
1092
            kzipopen(filenamsav[handle]);
1117
            kzseek(filepos[handle],SEEK_SET);
1093
            kzseek(arraypos[handle],SEEK_SET);
1118
        }
1094
        }
1119
        return kztell();
1095
        return kztell();
1120
    }
1096
    }
1121
#endif
1097
#endif
1122
    if (groupfil[groupnum] != -1)
1098
    if (groupfil[groupnum] != -1)
1123
        return filepos[handle];
1099
        return arraypos[handle];
1124
    return(-1);
1100
    return(-1);
1125
}
1101
}
1126
1102
1127
void kclose(int32_t handle)
1103
void kclose_internal(int32_t handle, uint8_t *arraygrp, intptr_t *arrayhan)
1128
{
1104
{
1129
    if (handle < 0) return;
1105
    if (handle < 0) return;
1130
    if (filegrp[handle] == GRP_FILESYSTEM) Bclose(filehan[handle]);
1106
    if (arraygrp[handle] == GRP_FILESYSTEM) Bclose(arrayhan[handle]);
1131
#ifdef WITHKPLIB
1107
#ifdef WITHKPLIB
1132
    else if (filegrp[handle] == GRP_ZIP)
1108
    else if (arraygrp[handle] == GRP_ZIP)
1133
    {
1109
    {
1134
        kzclose();
1110
        kzclose();
1135
        kzcurhand = -1;
1111
        kzcurhand = -1;
1136
    }
1112
    }
1137
#endif
1113
#endif
1138
    filehan[handle] = -1;
1114
    arrayhan[handle] = -1;
-
 
1115
}
-
 
1116
-
 
1117
int32_t kread(int32_t handle, void *buffer, int32_t leng)
-
 
1118
{
-
 
1119
    return kread_internal(handle, buffer, leng, filegrp, filehan, filepos);
-
 
1120
}
-
 
1121
int32_t klseek(int32_t handle, int32_t offset, int32_t whence)
-
 
1122
{
-
 
1123
    return klseek_internal(handle, offset, whence, filegrp, filehan, filepos);
-
 
1124
}
-
 
1125
int32_t kfilelength(int32_t handle)
-
 
1126
{
-
 
1127
    return kfilelength_internal(handle, filegrp, filehan, filepos);
-
 
1128
}
-
 
1129
int32_t ktell(int32_t handle)
-
 
1130
{
-
 
1131
    return ktell_internal(handle, filegrp, filehan, filepos);
-
 
1132
}
-
 
1133
void kclose(int32_t handle)
-
 
1134
{
-
 
1135
    return kclose_internal(handle, filegrp, filehan);
-
 
1136
}
-
 
1137
-
 
1138
static int32_t kread_grp(int32_t handle, void *buffer, int32_t leng)
-
 
1139
{
-
 
1140
    return kread_internal(handle, buffer, leng, groupfilgrp, groupfil, groupfilpos);
-
 
1141
}
-
 
1142
static int32_t klseek_grp(int32_t handle, int32_t offset, int32_t whence)
-
 
1143
{
-
 
1144
    return klseek_internal(handle, offset, whence, groupfilgrp, groupfil, groupfilpos);
-
 
1145
}
-
 
1146
static void kclose_grp(int32_t handle)
-
 
1147
{
-
 
1148
    return kclose_internal(handle, groupfilgrp, groupfil);
1139
}
1149
}
1140
1150
1141
static int32_t klistaddentry(CACHE1D_FIND_REC **rec, const char *name, int32_t type, int32_t source)
1151
static int32_t klistaddentry(CACHE1D_FIND_REC **rec, const char *name, int32_t type, int32_t source)
1142
{
1152
{
1143
    CACHE1D_FIND_REC *r = NULL, *attach = NULL;
1153
    CACHE1D_FIND_REC *r = NULL, *attach = NULL;