fixed line endings.
authorkramm <kramm>
Mon, 15 Nov 2004 11:22:56 +0000 (11:22 +0000)
committerkramm <kramm>
Mon, 15 Nov 2004 11:22:56 +0000 (11:22 +0000)
installer/depack.c
installer/depack.h

index 3f3343d..e43360e 100644 (file)
-/* depack.c\r
-\r
-   Part of the swftools installer.\r
-   \r
-   Copyright (c) 1997-2004 Matthias Kramm <kramm@quiss.org> \r
\r
-   This program is free software; you can redistribute it and/or modify\r
-   it under the terms of the GNU General Public License as published by\r
-   the Free Software Foundation; either version 2 of the License, or\r
-   (at your option) any later version.\r
-\r
-   This program is distributed in the hope that it will be useful,\r
-   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
-   GNU General Public License for more details.\r
-\r
-   You should have received a copy of the GNU General Public License\r
-   along with this program; if not, write to the Free Software\r
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */\r
-\r
-#include "stdlib.h"\r
-#include "stdio.h"\r
-#include "depack.h"\r
-\r
-U32 dbittab[] = {\r
-    0x1,       0x2,       0x4,       0x8,\r
-    0x10,      0x20,      0x40,      0x80,\r
-    0x100,     0x200,     0x400,     0x800,\r
-    0x1000,    0x2000,    0x4000,    0x8000,\r
-    0x10000,   0x20000,   0x40000,   0x80000, \r
-    0x100000,  0x200000,  0x400000,  0x800000,\r
-    0x1000000, 0x2000000, 0x4000000, 0x8000000,\r
-    0x10000000,0x20000000,0x40000000,0x80000000\r
-};\r
-\r
-static void* malloc_z(int len)\r
-{\r
-    void* buf = malloc(len);\r
-    if(buf == 0) {\r
-       fprintf(stderr, "\nout of memory\n");\r
-       exit(1);\r
-    }\r
-    memset(buf, 0, len);\r
-    return buf;\r
-}\r
-\r
-typedef struct _dpackead {\r
-    int back;\r
-    int len;\r
-} dpackead_t;\r
-\r
-typedef struct _tree {   \r
-    int depth;\r
-    U8  bits[17];\r
-    U32 base[17];\r
-} tree_t;\r
-\r
-typedef struct _depack_internal\r
-{\r
-    int DMEMSIZE;\r
-    int DMEMSIZEA;\r
-\r
-    tree_t T_REP;\r
-    tree_t T_STORE;\r
-    tree_t T_CNUM;\r
-    tree_t T_BACK;\r
-    tree_t T_BACK2;\r
-    tree_t T_BACK3;\r
-\r
-    dpackead_t dpackead;\r
-\r
-    void*reader;\r
-    readfunc_t readfunc;\r
-    void*writer;\r
-    writefunc_t writefunc;\r
-\r
-    U8* mem;\r
-    int mempos;\r
-    int pos;\r
-    U8 c;\r
-    U32 b;\r
-} depack_internal_t;\r
-\r
-void depack_destroy(depack_t*d)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-    free(i->mem);i->mem=0;\r
-    free(d->internal);d->internal=0;i=0;\r
-}\r
-\r
-static readbytes(depack_t*d, int num)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-\r
-    if(i->mempos+num<=i->DMEMSIZE) {\r
-       i->readfunc(i->reader, &i->mem[i->mempos],num);\r
-       i->writefunc(i->writer, &i->mem[i->mempos],num);\r
-    } else {\r
-       i->readfunc(i->reader, &i->mem[i->mempos],i->DMEMSIZE - i->mempos);\r
-       i->writefunc(i->writer, &i->mem[i->mempos],i->DMEMSIZE - i->mempos);\r
-       i->readfunc(i->reader, &i->mem[0],num-(i->DMEMSIZE - i->mempos));\r
-       i->writefunc(i->writer, &i->mem[0],num-(i->DMEMSIZE - i->mempos));\r
-    }\r
-    i->mempos=(i->mempos+num)&i->DMEMSIZEA;\r
-    i->pos+=num;\r
-}\r
-\r
-int move(U8*dest, U8*src, int len)\r
-{\r
-    if(len) do {\r
-       *dest=*src;\r
-       src++;\r
-       dest++;\r
-    } while(--len);\r
-}\r
-\r
-static lookback(depack_t*d, int back,int len)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-\r
-    int x,z=(i->mempos-back)&i->DMEMSIZEA;\r
-    char fail=0;\r
-\r
-    if(i->mempos+len <= i->DMEMSIZE && \r
-       z+len <= i->DMEMSIZE) \r
-    {\r
-       move(&i->mem[i->mempos],&i->mem[z],len);\r
-       i->writefunc(i->writer, &i->mem[i->mempos],len);\r
-       i->mempos=(i->mempos+len)&i->DMEMSIZEA;\r
-    } else {\r
-       for(x=0;x<len;x++) {\r
-           i->mem[i->mempos]=i->mem[z];\r
-           i->writefunc(i->writer, &i->mem[i->mempos],1);\r
-           i->mempos=(i->mempos+1)&i->DMEMSIZEA;\r
-           z=(z+1)&i->DMEMSIZEA;\r
-       }\r
-    }\r
-    i->pos += len;\r
-}\r
-\r
-static inline U8 readbit(depack_internal_t*i)\r
-{\r
-    i->c&=31;\r
-    if(i->c==0) i->readfunc(i->reader, &i->b,4);\r
-    return (i->b>>(31-i->c++))&1;\r
-}\r
-\r
-static inline U32 readval(depack_internal_t*i,int b)\r
-{\r
-    unsigned v=0;\r
-    signed char l;\r
-    for(l=b-1;l>=0;l--)\r
-       v|=readbit(i)<<l;\r
-    return v;\r
-}\r
-\r
-static tree_t gettree(depack_t*d)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-\r
-    int l;\r
-    int x,y,z=0,b=0,r;\r
-    tree_t tree;\r
-    memset(&tree, 0, sizeof(tree));\r
-   \r
-    tree.depth = readval(i,4)+1;\r
-\r
-    for(x=0;x<tree.depth;x++)\r
-    {\r
-       tree.base[x]=z;\r
-       r=0;while(!readbit(i)) r++;\r
-       if(readbit(i)) r=-r;\r
-       b+=r;\r
-       tree.bits[x]=b;\r
-       z+=dbittab[b];\r
-    }\r
-    tree.base[tree.depth]=z;\r
-    tree.bits[tree.depth]=0;\r
-    return tree;\r
-\r
-/*    for(z=0;z<=l;z++)\r
-    {\r
-       if(i->ttree[n].bits[z]>16) \r
-           printf(".");\r
-       else                       \r
-           printf("%c","0123456789abcdefg"[ttree[n].bits[z]]);\r
-    }\r
-    printf("\n");*/\r
-}\r
-\r
-static void showtree(tree_t tree)\r
-{\r
-    int t;\r
-    int last=0;\r
-    int lastbits = 0;\r
-    for(t=0;t<=tree.depth;t++)\r
-    {\r
-       if(t>0)\r
-           printf("[%d] %d: %05x-%05x (%d=%d+%d+1)\n",t,lastbits, last,tree.base[t],lastbits+(t-1)+1, lastbits,t-1);\r
-       last=tree.base[t];\r
-       lastbits = tree.bits[t];\r
-    }\r
-}\r
-\r
-static int gettreeval(depack_t*d, tree_t*tree)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-\r
-    U8 x=0;\r
-    while(!readbit(i)) x++;\r
-    if(x<17) return tree->base[x]+readval(i, tree->bits[x]);\r
-    else     return -1;\r
-}\r
-\r
-static int get_memsize(int b)\r
-{\r
-    int t,c=1;\r
-    for(t=0;;t++) {\r
-       if(c>=b) return c;\r
-       c<<=1;\r
-    }\r
-    return 0;\r
-}\r
-\r
-void depack_init(depack_t*d, void*reader, readfunc_t readfunc)\r
-{\r
-    d->internal = malloc_z(sizeof(depack_internal_t));\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-    if(i==0) {\r
-       fprintf(stderr, "depacker not initialized yet"); exit(1);\r
-    }\r
-\r
-    i->reader = reader;\r
-    i->readfunc = readfunc;\r
-\r
-    i->mempos=0;\r
-    i->pos=0;\r
-    i->b=i->c=0;\r
-\r
-    i->readfunc(i->reader,&i->dpackead.back, 4);\r
-    i->readfunc(i->reader,&i->dpackead.len, 4);\r
-\r
-    i->DMEMSIZE = get_memsize(i->dpackead.len);\r
-    i->DMEMSIZEA = i->DMEMSIZE-1;\r
-    i->mem = malloc_z(i->DMEMSIZE);\r
-\r
-    i->T_REP = gettree(d);\r
-    i->T_STORE = gettree(d);\r
-    i->T_CNUM = gettree(d);\r
-    //showtree(i->T_CNUM);\r
-    i->T_BACK = gettree(d);\r
-    //showtree(i->T_BACK);\r
-    i->T_BACK2 = gettree(d);\r
-    //showtree(i->T_BACK);\r
-    i->T_BACK3 = gettree(d);\r
-    //showtree(i->T_BACK3);\r
-\r
-    d->size = i->dpackead.len;\r
-}\r
-\r
-void depack_process(depack_t*d, void*writer,writefunc_t writefunc)\r
-{\r
-    depack_internal_t*i = (depack_internal_t*)d->internal;\r
-    i->writer = writer;\r
-    i->writefunc = writefunc;\r
-    while(i->pos<i->dpackead.len)\r
-    {\r
-       int store,rep,x;\r
-\r
-       store=gettreeval(d,&i->T_STORE)+1;\r
-\r
-       readbytes(d,store);\r
-\r
-       if(i->pos<i->dpackead.len)\r
-       {\r
-           rep = gettreeval(d,&i->T_REP)+1;\r
-\r
-           for(x=0;x<rep;x++)\r
-           {\r
-               int back,len;\r
-               len = gettreeval(d,&i->T_CNUM)+1;\r
-\r
-               if(len == 1) back = readval(i,3)+1;\r
-               if(len == 2) back = gettreeval(d,&i->T_BACK2)+1;\r
-               if(len == 3) back = gettreeval(d,&i->T_BACK3)+1;\r
-               if(len >= 4) back = gettreeval(d,&i->T_BACK)+1;\r
-\r
-               lookback(d,back,len);\r
-           }\r
-       }\r
-    }\r
-\r
-    if(i->pos!=i->dpackead.len) {\r
-       fprintf(stderr, "Internal error");\r
-       exit(1);\r
-    }\r
-}\r
-\r
-/*\r
-\r
-                mov eax,[b1]\r
-                mov ebx,[b2]\r
-                shld eax,ebx,cl\r
-                mov [b1],eax\r
-                shr ebx,cl\r
-                mov [b2],ebx\r
-                sub cnt,cl\r
-                cmp cnt,32-8\r
-                ja jj\r
-mm:             xor eax,eax\r
-                call read\r
-                shl eax,[cnt]\r
-                or  [b2],eax\r
-                add cnt,8\r
-                cmp cnt,32-8\r
-                jb mm\r
-jj:\r
-\r
-*/\r
-\r
+/* depack.c
+
+   Part of the swftools installer.
+   
+   Copyright (c) 1997-2004 Matthias Kramm <kramm@quiss.org> 
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include "stdlib.h"
+#include "stdio.h"
+#include "depack.h"
+
+U32 dbittab[] = {
+    0x1,       0x2,       0x4,       0x8,
+    0x10,      0x20,      0x40,      0x80,
+    0x100,     0x200,     0x400,     0x800,
+    0x1000,    0x2000,    0x4000,    0x8000,
+    0x10000,   0x20000,   0x40000,   0x80000, 
+    0x100000,  0x200000,  0x400000,  0x800000,
+    0x1000000, 0x2000000, 0x4000000, 0x8000000,
+    0x10000000,0x20000000,0x40000000,0x80000000
+};
+
+static void* malloc_z(int len)
+{
+    void* buf = malloc(len);
+    if(buf == 0) {
+       fprintf(stderr, "\nout of memory\n");
+       exit(1);
+    }
+    memset(buf, 0, len);
+    return buf;
+}
+
+typedef struct _dpackead {
+    int back;
+    int len;
+} dpackead_t;
+
+typedef struct _tree {   
+    int depth;
+    U8  bits[17];
+    U32 base[17];
+} tree_t;
+
+typedef struct _depack_internal
+{
+    int DMEMSIZE;
+    int DMEMSIZEA;
+
+    tree_t T_REP;
+    tree_t T_STORE;
+    tree_t T_CNUM;
+    tree_t T_BACK;
+    tree_t T_BACK2;
+    tree_t T_BACK3;
+
+    dpackead_t dpackead;
+
+    void*reader;
+    readfunc_t readfunc;
+    void*writer;
+    writefunc_t writefunc;
+
+    U8* mem;
+    int mempos;
+    int pos;
+    U8 c;
+    U32 b;
+} depack_internal_t;
+
+void depack_destroy(depack_t*d)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+    free(i->mem);i->mem=0;
+    free(d->internal);d->internal=0;i=0;
+}
+
+static readbytes(depack_t*d, int num)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+
+    if(i->mempos+num<=i->DMEMSIZE) {
+       i->readfunc(i->reader, &i->mem[i->mempos],num);
+       i->writefunc(i->writer, &i->mem[i->mempos],num);
+    } else {
+       i->readfunc(i->reader, &i->mem[i->mempos],i->DMEMSIZE - i->mempos);
+       i->writefunc(i->writer, &i->mem[i->mempos],i->DMEMSIZE - i->mempos);
+       i->readfunc(i->reader, &i->mem[0],num-(i->DMEMSIZE - i->mempos));
+       i->writefunc(i->writer, &i->mem[0],num-(i->DMEMSIZE - i->mempos));
+    }
+    i->mempos=(i->mempos+num)&i->DMEMSIZEA;
+    i->pos+=num;
+}
+
+int move(U8*dest, U8*src, int len)
+{
+    if(len) do {
+       *dest=*src;
+       src++;
+       dest++;
+    } while(--len);
+}
+
+static lookback(depack_t*d, int back,int len)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+
+    int x,z=(i->mempos-back)&i->DMEMSIZEA;
+    char fail=0;
+
+    if(i->mempos+len <= i->DMEMSIZE && 
+       z+len <= i->DMEMSIZE) 
+    {
+       move(&i->mem[i->mempos],&i->mem[z],len);
+       i->writefunc(i->writer, &i->mem[i->mempos],len);
+       i->mempos=(i->mempos+len)&i->DMEMSIZEA;
+    } else {
+       for(x=0;x<len;x++) {
+           i->mem[i->mempos]=i->mem[z];
+           i->writefunc(i->writer, &i->mem[i->mempos],1);
+           i->mempos=(i->mempos+1)&i->DMEMSIZEA;
+           z=(z+1)&i->DMEMSIZEA;
+       }
+    }
+    i->pos += len;
+}
+
+static inline U8 readbit(depack_internal_t*i)
+{
+    i->c&=31;
+    if(i->c==0) i->readfunc(i->reader, &i->b,4);
+    return (i->b>>(31-i->c++))&1;
+}
+
+static inline U32 readval(depack_internal_t*i,int b)
+{
+    unsigned v=0;
+    signed char l;
+    for(l=b-1;l>=0;l--)
+       v|=readbit(i)<<l;
+    return v;
+}
+
+static tree_t gettree(depack_t*d)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+
+    int l;
+    int x,y,z=0,b=0,r;
+    tree_t tree;
+    memset(&tree, 0, sizeof(tree));
+   
+    tree.depth = readval(i,4)+1;
+
+    for(x=0;x<tree.depth;x++)
+    {
+       tree.base[x]=z;
+       r=0;while(!readbit(i)) r++;
+       if(readbit(i)) r=-r;
+       b+=r;
+       tree.bits[x]=b;
+       z+=dbittab[b];
+    }
+    tree.base[tree.depth]=z;
+    tree.bits[tree.depth]=0;
+    return tree;
+
+/*    for(z=0;z<=l;z++)
+    {
+       if(i->ttree[n].bits[z]>16) 
+           printf(".");
+       else                       
+           printf("%c","0123456789abcdefg"[ttree[n].bits[z]]);
+    }
+    printf("\n");*/
+}
+
+static void showtree(tree_t tree)
+{
+    int t;
+    int last=0;
+    int lastbits = 0;
+    for(t=0;t<=tree.depth;t++)
+    {
+       if(t>0)
+           printf("[%d] %d: %05x-%05x (%d=%d+%d+1)\n",t,lastbits, last,tree.base[t],lastbits+(t-1)+1, lastbits,t-1);
+       last=tree.base[t];
+       lastbits = tree.bits[t];
+    }
+}
+
+static int gettreeval(depack_t*d, tree_t*tree)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+
+    U8 x=0;
+    while(!readbit(i)) x++;
+    if(x<17) return tree->base[x]+readval(i, tree->bits[x]);
+    else     return -1;
+}
+
+static int get_memsize(int b)
+{
+    int t,c=1;
+    for(t=0;;t++) {
+       if(c>=b) return c;
+       c<<=1;
+    }
+    return 0;
+}
+
+void depack_init(depack_t*d, void*reader, readfunc_t readfunc)
+{
+    d->internal = malloc_z(sizeof(depack_internal_t));
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+    if(i==0) {
+       fprintf(stderr, "depacker not initialized yet"); exit(1);
+    }
+
+    i->reader = reader;
+    i->readfunc = readfunc;
+
+    i->mempos=0;
+    i->pos=0;
+    i->b=i->c=0;
+
+    i->readfunc(i->reader,&i->dpackead.back, 4);
+    i->readfunc(i->reader,&i->dpackead.len, 4);
+
+    i->DMEMSIZE = get_memsize(i->dpackead.len);
+    i->DMEMSIZEA = i->DMEMSIZE-1;
+    i->mem = malloc_z(i->DMEMSIZE);
+
+    i->T_REP = gettree(d);
+    i->T_STORE = gettree(d);
+    i->T_CNUM = gettree(d);
+    //showtree(i->T_CNUM);
+    i->T_BACK = gettree(d);
+    //showtree(i->T_BACK);
+    i->T_BACK2 = gettree(d);
+    //showtree(i->T_BACK);
+    i->T_BACK3 = gettree(d);
+    //showtree(i->T_BACK3);
+
+    d->size = i->dpackead.len;
+}
+
+void depack_process(depack_t*d, void*writer,writefunc_t writefunc)
+{
+    depack_internal_t*i = (depack_internal_t*)d->internal;
+    i->writer = writer;
+    i->writefunc = writefunc;
+    while(i->pos<i->dpackead.len)
+    {
+       int store,rep,x;
+
+       store=gettreeval(d,&i->T_STORE)+1;
+
+       readbytes(d,store);
+
+       if(i->pos<i->dpackead.len)
+       {
+           rep = gettreeval(d,&i->T_REP)+1;
+
+           for(x=0;x<rep;x++)
+           {
+               int back,len;
+               len = gettreeval(d,&i->T_CNUM)+1;
+
+               if(len == 1) back = readval(i,3)+1;
+               if(len == 2) back = gettreeval(d,&i->T_BACK2)+1;
+               if(len == 3) back = gettreeval(d,&i->T_BACK3)+1;
+               if(len >= 4) back = gettreeval(d,&i->T_BACK)+1;
+
+               lookback(d,back,len);
+           }
+       }
+    }
+
+    if(i->pos!=i->dpackead.len) {
+       fprintf(stderr, "Internal error");
+       exit(1);
+    }
+}
+
+/*
+
+                mov eax,[b1]
+                mov ebx,[b2]
+                shld eax,ebx,cl
+                mov [b1],eax
+                shr ebx,cl
+                mov [b2],ebx
+                sub cnt,cl
+                cmp cnt,32-8
+                ja jj
+mm:             xor eax,eax
+                call read
+                shl eax,[cnt]
+                or  [b2],eax
+                add cnt,8
+                cmp cnt,32-8
+                jb mm
+jj:
+
+*/
+
 
index 028ab0c..1341c26 100644 (file)
@@ -1,41 +1,41 @@
-/* depack.h\r
-\r
-   Part of the swftools installer.\r
-   \r
-   Copyright (c) 2004 Matthias Kramm <kramm@quiss.org> \r
\r
-   This program is free software; you can redistribute it and/or modify\r
-   it under the terms of the GNU General Public License as published by\r
-   the Free Software Foundation; either version 2 of the License, or\r
-   (at your option) any later version.\r
-\r
-   This program is distributed in the hope that it will be useful,\r
-   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
-   GNU General Public License for more details.\r
-\r
-   You should have received a copy of the GNU General Public License\r
-   along with this program; if not, write to the Free Software\r
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */\r
-\r
-#ifndef Depack_h\r
-#define Depack_h\r
-\r
-typedef unsigned long int U32;\r
-typedef unsigned char U8;\r
-\r
-typedef struct {\r
-    void*internal;\r
-    int pos;\r
-    int size;\r
-} depack_t;\r
-\r
-typedef void (*writefunc_t)(void*writer, void*mem, int len);\r
-typedef void (*readfunc_t)(void*reader, void*mem, int len);\r
-\r
-void depack_init(depack_t*d, void*reader, readfunc_t);\r
-void depack_process(depack_t*d, void*writer, writefunc_t);\r
-void depack_destroy(depack_t*d);\r
-\r
-#endif //Depack_h\r
+/* depack.h
+
+   Part of the swftools installer.
+   
+   Copyright (c) 2004 Matthias Kramm <kramm@quiss.org> 
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#ifndef Depack_h
+#define Depack_h
+
+typedef unsigned long int U32;
+typedef unsigned char U8;
+
+typedef struct {
+    void*internal;
+    int pos;
+    int size;
+} depack_t;
+
+typedef void (*writefunc_t)(void*writer, void*mem, int len);
+typedef void (*readfunc_t)(void*reader, void*mem, int len);
+
+void depack_init(depack_t*d, void*reader, readfunc_t);
+void depack_process(depack_t*d, void*writer, writefunc_t);
+void depack_destroy(depack_t*d);
+
+#endif //Depack_h