/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* append.c -- append to archive */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* append.c -- append to archive */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
int
encode_lzhuf(infp, outfp, size, original_size_var, packed_size_var,
- name, hdr_method)
- FILE *infp;
- FILE *outfp;
- long size;
- long *original_size_var;
- long *packed_size_var;
- char *name;
- char *hdr_method;
+ name, hdr_method)
+ FILE *infp;
+ FILE *outfp;
+ long size;
+ long *original_size_var;
+ long *packed_size_var;
+ char *name;
+ char *hdr_method;
{
- static int method = -1;
+ static int method = -1;
unsigned int crc;
- if (method < 0) {
- method = compress_method;
- if (method > 0)
- method = encode_alloc(method);
- }
+ if (method < 0) {
+ method = compress_method;
+ if (method > 0)
+ method = encode_alloc(method);
+ }
- interface.method = method;
+ interface.method = method;
- if (interface.method > 0) {
- interface.infile = infp;
- interface.outfile = outfp;
- interface.original = size;
- start_indicator(name, size, "Freezing", 1 << dicbit);
- crc = encode(&interface);
- *packed_size_var = interface.packed;
- *original_size_var = interface.original;
- } else {
- copyfile(infp, outfp, size, 0, &crc);
- *packed_size_var = *original_size_var = size;
- }
- memcpy(hdr_method, "-lh -", 5);
- hdr_method[3] = interface.method + '0';
+ if (interface.method > 0) {
+ interface.infile = infp;
+ interface.outfile = outfp;
+ interface.original = size;
+ start_indicator(name, size, "Freezing", 1 << dicbit);
+ crc = encode(&interface);
+ *packed_size_var = interface.packed;
+ *original_size_var = interface.original;
+ } else {
+ copyfile(infp, outfp, size, 0, &crc);
+ *packed_size_var = *original_size_var = size;
+ }
+ memcpy(hdr_method, "-lh -", 5);
+ hdr_method[3] = interface.method + '0';
- finish_indicator2(name, "Frozen",
- (int) ((*packed_size_var * 100L) / *original_size_var));
- return crc;
+ finish_indicator2(name, "Frozen",
+ (int) ((*packed_size_var * 100L) / *original_size_var));
+ return crc;
}
/* ------------------------------------------------------------------------ */
void
start_indicator(name, size, msg, def_indicator_threshold)
- char *name;
- long size;
- char *msg;
- long def_indicator_threshold;
+ char *name;
+ long size;
+ char *msg;
+ long def_indicator_threshold;
{
#ifdef NEED_INCREMENTAL_INDICATOR
- long i;
- int m;
+ long i;
+ int m;
#endif
- if (quiet)
- return;
+ if (quiet)
+ return;
#ifdef NEED_INCREMENTAL_INDICATOR
- switch (quiet_mode) {
- case 0:
- m = MAX_INDICATOR_COUNT - strlen(name);
- if (m < 1) /* Bug Fixed by N.Watazaki */
- m = 3; /* (^_^) */
- printf("\r%s\t- %s : ", name, msg);
- indicator_threshold =
- ((size + (m * def_indicator_threshold - 1)) /
- (m * def_indicator_threshold) *
- def_indicator_threshold);
- if (indicator_threshold)
- i = ((size + (indicator_threshold - 1)) / indicator_threshold);
- else
- i = 0;
- while (i--)
- putchar('.');
- indicator_count = 0;
- printf("\r%s\t- %s : ", name, msg);
- break;
- case 1:
- printf("\r%s :", name);
- break;
- }
+ switch (quiet_mode) {
+ case 0:
+ m = MAX_INDICATOR_COUNT - strlen(name);
+ if (m < 1) /* Bug Fixed by N.Watazaki */
+ m = 3; /* (^_^) */
+ printf("\r%s\t- %s : ", name, msg);
+ indicator_threshold =
+ ((size + (m * def_indicator_threshold - 1)) /
+ (m * def_indicator_threshold) *
+ def_indicator_threshold);
+ if (indicator_threshold)
+ i = ((size + (indicator_threshold - 1)) / indicator_threshold);
+ else
+ i = 0;
+ while (i--)
+ putchar('.');
+ indicator_count = 0;
+ printf("\r%s\t- %s : ", name, msg);
+ break;
+ case 1:
+ printf("\r%s :", name);
+ break;
+ }
#else
- printf("%s\t- ", name);
+ printf("%s\t- ", name);
#endif
- fflush(stdout);
- reading_size = 0L;
+ fflush(stdout);
+ reading_size = 0L;
}
/* ------------------------------------------------------------------------ */
#ifdef NEED_INCREMENTAL_INDICATOR
void
put_indicator(count)
- long int count;
+ long int count;
{
reading_size += count;
- if (!quiet && indicator_threshold) {
- while (reading_size > indicator_count) {
- putchar('o');
- fflush(stdout);
- indicator_count += indicator_threshold;
- }
- }
+ if (!quiet && indicator_threshold) {
+ while (reading_size > indicator_count) {
+ putchar('o');
+ fflush(stdout);
+ indicator_count += indicator_threshold;
+ }
+ }
}
#endif
/* ------------------------------------------------------------------------ */
void
finish_indicator2(name, msg, pcnt)
- char *name;
- char *msg;
- int pcnt;
+ char *name;
+ char *msg;
+ int pcnt;
{
- if (quiet)
- return;
+ if (quiet)
+ return;
- if (pcnt > 100)
- pcnt = 100; /* (^_^) */
+ if (pcnt > 100)
+ pcnt = 100; /* (^_^) */
#ifdef NEED_INCREMENTAL_INDICATOR
- printf("\r%s\t- %s(%d%%)\n", name, msg, pcnt);
+ printf("\r%s\t- %s(%d%%)\n", name, msg, pcnt);
#else
- printf("%s\n", msg);
+ printf("%s\n", msg);
#endif
- fflush(stdout);
+ fflush(stdout);
}
/* ------------------------------------------------------------------------ */
void
finish_indicator(name, msg)
- char *name;
- char *msg;
+ char *name;
+ char *msg;
{
- if (quiet)
- return;
+ if (quiet)
+ return;
#ifdef NEED_INCREMENTAL_INDICATOR
- printf("\r%s\t- %s\n", name, msg);
+ printf("\r%s\t- %s\n", name, msg);
#else
- printf("%s\n", msg);
+ printf("%s\n", msg);
#endif
- fflush(stdout);
+ fflush(stdout);
}
/* Local Variables: */
/* tab-width : 4 */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* crcio.c -- crc input / output */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* crcio.c -- crc input / output */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
void
make_crctable( /* void */ )
{
- unsigned int i, j, r;
-
- for (i = 0; i <= UCHAR_MAX; i++) {
- r = i;
- for (j = 0; j < CHAR_BIT; j++)
- if (r & 1)
- r = (r >> 1) ^ CRCPOLY;
- else
- r >>= 1;
- crctable[i] = r;
- }
+ unsigned int i, j, r;
+
+ for (i = 0; i <= UCHAR_MAX; i++) {
+ r = i;
+ for (j = 0; j < CHAR_BIT; j++)
+ if (r & 1)
+ r = (r >> 1) ^ CRCPOLY;
+ else
+ r >>= 1;
+ crctable[i] = r;
+ }
}
/* ------------------------------------------------------------------------ */
unsigned int
calccrc(crc, p, n)
unsigned int crc;
- unsigned char *p;
- unsigned int n;
+ unsigned char *p;
+ unsigned int n;
{
- while (n-- > 0)
- crc = UPDATE_CRC(crc, *p++);
- return crc;
+ while (n-- > 0)
+ crc = UPDATE_CRC(crc, *p++);
+ return crc;
}
/* ------------------------------------------------------------------------ */
int
fread_crc(crcp, p, n, fp)
unsigned int *crcp;
- unsigned char *p;
- int n;
- FILE *fp;
+ unsigned char *p;
+ int n;
+ FILE *fp;
{
- if (text_mode)
- n = fread_txt(p, n, fp);
- else
- n = fread(p, 1, n, fp);
+ if (text_mode)
+ n = fread_txt(p, n, fp);
+ else
+ n = fread(p, 1, n, fp);
- *crcp = calccrc(*crcp, p, n);
+ *crcp = calccrc(*crcp, p, n);
#ifdef NEED_INCREMENTAL_INDICATOR
- put_indicator(n);
+ put_indicator(n);
#endif
- return n;
+ return n;
}
/* ------------------------------------------------------------------------ */
void
fwrite_crc(crcp, p, n, fp)
unsigned int *crcp;
- unsigned char *p;
- int n;
- FILE *fp;
+ unsigned char *p;
+ int n;
+ FILE *fp;
{
- *crcp = calccrc(*crcp, p, n);
+ *crcp = calccrc(*crcp, p, n);
#ifdef NEED_INCREMENTAL_INDICATOR
- put_indicator(n);
+ put_indicator(n);
#endif
- if (verify_mode)
- return;
-
- if (fp) {
- if (text_mode) {
- if (fwrite_txt(p, n, fp))
- fatal_error("File write error");
- }
- else {
- if (fwrite(p, 1, n, fp) < n)
- fatal_error("File write error");
- }
- }
+ if (verify_mode)
+ return;
+
+ if (fp) {
+ if (text_mode) {
+ if (fwrite_txt(p, n, fp))
+ fatal_error("File write error");
+ }
+ else {
+ if (fwrite(p, 1, n, fp) < n)
+ fatal_error("File write error");
+ }
+ }
}
/* ------------------------------------------------------------------------ */
void
init_code_cache( /* void */ )
-{ /* called from copyfile() in util.c */
+{ /* called from copyfile() in util.c */
#ifdef EUC
- putc_euc_cache = EOF;
+ putc_euc_cache = EOF;
#endif
- getc_euc_cache = EOF;
+ getc_euc_cache = EOF;
}
/* ------------------------------------------------------------------------ */
#ifdef EUC
int
putc_euc(c, fd)
- int c;
- FILE *fd;
+ int c;
+ FILE *fd;
{
- int d;
-
- if (putc_euc_cache == EOF) {
- if (!euc_mode || c < 0x81 || c > 0xFC) {
- return putc(c, fd);
- }
- if (c >= 0xA0 && c < 0xE0) {
- if (putc(0x8E, fd) == EOF) return EOF; /* single shift */
- return putc(c, fd);
- }
- putc_euc_cache = c; /* save first byte */
- return c;
- }
- d = putc_euc_cache;
- putc_euc_cache = EOF;
- if (d >= 0xA0)
- d -= 0xE0 - 0xA0;
- if (c > 0x9E) {
- c = c - 0x9F + 0x21;
- d = (d - 0x81) * 2 + 0x22;
- }
- else {
- if (c > 0x7E)
- c--;
- c -= 0x1F;
- d = (d - 0x81) * 2 + 0x21;
- }
- if (putc(0x80 | d, fd) == EOF) return EOF;
- return putc(0x80 | c, fd);
+ int d;
+
+ if (putc_euc_cache == EOF) {
+ if (!euc_mode || c < 0x81 || c > 0xFC) {
+ return putc(c, fd);
+ }
+ if (c >= 0xA0 && c < 0xE0) {
+ if (putc(0x8E, fd) == EOF) return EOF; /* single shift */
+ return putc(c, fd);
+ }
+ putc_euc_cache = c; /* save first byte */
+ return c;
+ }
+ d = putc_euc_cache;
+ putc_euc_cache = EOF;
+ if (d >= 0xA0)
+ d -= 0xE0 - 0xA0;
+ if (c > 0x9E) {
+ c = c - 0x9F + 0x21;
+ d = (d - 0x81) * 2 + 0x22;
+ }
+ else {
+ if (c > 0x7E)
+ c--;
+ c -= 0x1F;
+ d = (d - 0x81) * 2 + 0x21;
+ }
+ if (putc(0x80 | d, fd) == EOF) return EOF;
+ return putc(0x80 | c, fd);
}
#endif
/* ------------------------------------------------------------------------ */
int
fwrite_txt(p, n, fp)
- unsigned char *p;
- int n;
- FILE *fp;
+ unsigned char *p;
+ int n;
+ FILE *fp;
{
- while (--n >= 0) {
- if (*p != '\015' && *p != '\032') {
+ while (--n >= 0) {
+ if (*p != '\015' && *p != '\032') {
#ifdef EUC
- if (putc_euc(*p, fp) == EOF)
+ if (putc_euc(*p, fp) == EOF)
break;
#else
- if (putc(*p, fp) == EOF)
+ if (putc(*p, fp) == EOF)
break;
#endif
- }
+ }
- prev_char = *p++;
- }
- return (ferror(fp));
+ prev_char = *p++;
+ }
+ return (ferror(fp));
}
/* ------------------------------------------------------------------------ */
int
fread_txt(p, n, fp)
- unsigned char *p;
- int n;
- FILE *fp;
+ unsigned char *p;
+ int n;
+ FILE *fp;
{
- int c;
- int cnt = 0;
-
- while (cnt < n) {
- if (getc_euc_cache != EOF) {
- c = getc_euc_cache;
- getc_euc_cache = EOF;
- }
- else {
- if ((c = fgetc(fp)) == EOF)
- break;
- if (c == '\n') {
- getc_euc_cache = c;
- ++origsize;
- c = '\r';
- }
+ int c;
+ int cnt = 0;
+
+ while (cnt < n) {
+ if (getc_euc_cache != EOF) {
+ c = getc_euc_cache;
+ getc_euc_cache = EOF;
+ }
+ else {
+ if ((c = fgetc(fp)) == EOF)
+ break;
+ if (c == '\n') {
+ getc_euc_cache = c;
+ ++origsize;
+ c = '\r';
+ }
#ifdef EUC
- else if (euc_mode && (c == 0x8E || (0xA0 < c && c < 0xFF))) {
- int d = fgetc(fp);
- if (d == EOF) {
- *p++ = c;
- cnt++;
- break;
- }
- if (c == 0x8E) { /* single shift (KANA) */
- if ((0x20 < d && d < 0x7F) || (0xA0 < d && d < 0xFF))
- c = d | 0x80;
- else
- getc_euc_cache = d;
- }
- else {
- if (0xA0 < d && d < 0xFF) { /* if GR */
- c &= 0x7F; /* convert to MS-kanji */
- d &= 0x7F;
- if (!(c & 1)) {
- c--;
- d += 0x7F - 0x21;
- }
- if ((d += 0x40 - 0x21) > 0x7E)
- d++;
- if ((c = (c >> 1) + 0x71) >= 0xA0)
- c += 0xE0 - 0xA0;
- }
- getc_euc_cache = d;
- }
- }
+ else if (euc_mode && (c == 0x8E || (0xA0 < c && c < 0xFF))) {
+ int d = fgetc(fp);
+ if (d == EOF) {
+ *p++ = c;
+ cnt++;
+ break;
+ }
+ if (c == 0x8E) { /* single shift (KANA) */
+ if ((0x20 < d && d < 0x7F) || (0xA0 < d && d < 0xFF))
+ c = d | 0x80;
+ else
+ getc_euc_cache = d;
+ }
+ else {
+ if (0xA0 < d && d < 0xFF) { /* if GR */
+ c &= 0x7F; /* convert to MS-kanji */
+ d &= 0x7F;
+ if (!(c & 1)) {
+ c--;
+ d += 0x7F - 0x21;
+ }
+ if ((d += 0x40 - 0x21) > 0x7E)
+ d++;
+ if ((c = (c >> 1) + 0x71) >= 0xA0)
+ c += 0xE0 - 0xA0;
+ }
+ getc_euc_cache = d;
+ }
+ }
#endif
- }
- *p++ = c;
- cnt++;
- }
- return cnt;
+ }
+ *p++ = c;
+ cnt++;
+ }
+ return cnt;
}
-
-/* Local Variables: */
-/* tab-width : 4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* dhuf.c -- Dynamic Hufffman routine */
-/* */
-/* Modified H.Yoshizaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* dhuf.c -- Dynamic Hufffman routine */
+/* */
+/* Modified H.Yoshizaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
static short child[TREESIZE], parent[TREESIZE], block[TREESIZE], edge[TREESIZE], stock[TREESIZE],
- s_node[TREESIZE / 2]; /* Changed N.Watazaki */
-/* node[..] -> s_node[..] */
+ s_node[TREESIZE / 2]; /* Changed N.Watazaki */
+/* node[..] -> s_node[..] */
static unsigned short freq[TREESIZE];
void
start_c_dyn( /* void */ )
{
- int i, j, f;
+ int i, j, f;
- n1 = (n_max >= 256 + maxmatch - THRESHOLD + 1) ? 512 : n_max - 1;
- for (i = 0; i < TREESIZE_C; i++) {
- stock[i] = i;
- block[i] = 0;
- }
- for (i = 0, j = n_max * 2 - 2; i < n_max; i++, j--) {
- freq[j] = 1;
- child[j] = ~i;
- s_node[i] = j;
- block[j] = 1;
- }
- avail = 2;
- edge[1] = n_max - 1;
- i = n_max * 2 - 2;
- while (j >= 0) {
- f = freq[j] = freq[i] + freq[i - 1];
- child[j] = i;
- parent[i] = parent[i - 1] = j;
- if (f == freq[j + 1]) {
- edge[block[j] = block[j + 1]] = j;
- }
- else {
- edge[block[j] = stock[avail++]] = j;
- }
- i -= 2;
- j--;
- }
+ n1 = (n_max >= 256 + maxmatch - THRESHOLD + 1) ? 512 : n_max - 1;
+ for (i = 0; i < TREESIZE_C; i++) {
+ stock[i] = i;
+ block[i] = 0;
+ }
+ for (i = 0, j = n_max * 2 - 2; i < n_max; i++, j--) {
+ freq[j] = 1;
+ child[j] = ~i;
+ s_node[i] = j;
+ block[j] = 1;
+ }
+ avail = 2;
+ edge[1] = n_max - 1;
+ i = n_max * 2 - 2;
+ while (j >= 0) {
+ f = freq[j] = freq[i] + freq[i - 1];
+ child[j] = i;
+ parent[i] = parent[i - 1] = j;
+ if (f == freq[j + 1]) {
+ edge[block[j] = block[j + 1]] = j;
+ }
+ else {
+ edge[block[j] = stock[avail++]] = j;
+ }
+ i -= 2;
+ j--;
+ }
}
/* ------------------------------------------------------------------------ */
static void
start_p_dyn( /* void */ )
{
- freq[ROOT_P] = 1;
- child[ROOT_P] = ~(N_CHAR);
- s_node[N_CHAR] = ROOT_P;
- edge[block[ROOT_P] = stock[avail++]] = ROOT_P;
- most_p = ROOT_P;
- total_p = 0;
- nn = 1 << dicbit;
- nextcount = 64;
+ freq[ROOT_P] = 1;
+ child[ROOT_P] = ~(N_CHAR);
+ s_node[N_CHAR] = ROOT_P;
+ edge[block[ROOT_P] = stock[avail++]] = ROOT_P;
+ most_p = ROOT_P;
+ total_p = 0;
+ nn = 1 << dicbit;
+ nextcount = 64;
}
/* ------------------------------------------------------------------------ */
void
decode_start_dyn( /* void */ )
{
- n_max = 286;
- maxmatch = MAXMATCH;
- init_getbits();
+ n_max = 286;
+ maxmatch = MAXMATCH;
+ init_getbits();
init_code_cache();
- start_c_dyn();
- start_p_dyn();
+ start_c_dyn();
+ start_p_dyn();
}
/* ------------------------------------------------------------------------ */
static void
reconst(start, end)
- int start;
- int end;
+ int start;
+ int end;
{
- int i, j, k, l, b;
- unsigned int f, g;
+ int i, j, k, l, b;
+ unsigned int f, g;
- for (i = j = start; i < end; i++) {
- if ((k = child[i]) < 0) {
- freq[j] = (freq[i] + 1) / 2;
- child[j] = k;
- j++;
- }
- if (edge[b = block[i]] == i) {
- stock[--avail] = b;
- }
- }
- j--;
- i = end - 1;
- l = end - 2;
- while (i >= start) {
- while (i >= l) {
- freq[i] = freq[j];
- child[i] = child[j];
- i--, j--;
- }
- f = freq[l] + freq[l + 1];
- for (k = start; f < freq[k]; k++);
- while (j >= k) {
- freq[i] = freq[j];
- child[i] = child[j];
- i--, j--;
- }
- freq[i] = f;
- child[i] = l + 1;
- i--;
- l -= 2;
- }
- f = 0;
- for (i = start; i < end; i++) {
- if ((j = child[i]) < 0)
- s_node[~j] = i;
- else
- parent[j] = parent[j - 1] = i;
- if ((g = freq[i]) == f) {
- block[i] = b;
- }
- else {
- edge[b = block[i] = stock[avail++]] = i;
- f = g;
- }
- }
+ for (i = j = start; i < end; i++) {
+ if ((k = child[i]) < 0) {
+ freq[j] = (freq[i] + 1) / 2;
+ child[j] = k;
+ j++;
+ }
+ if (edge[b = block[i]] == i) {
+ stock[--avail] = b;
+ }
+ }
+ j--;
+ i = end - 1;
+ l = end - 2;
+ while (i >= start) {
+ while (i >= l) {
+ freq[i] = freq[j];
+ child[i] = child[j];
+ i--, j--;
+ }
+ f = freq[l] + freq[l + 1];
+ for (k = start; f < freq[k]; k++);
+ while (j >= k) {
+ freq[i] = freq[j];
+ child[i] = child[j];
+ i--, j--;
+ }
+ freq[i] = f;
+ child[i] = l + 1;
+ i--;
+ l -= 2;
+ }
+ f = 0;
+ for (i = start; i < end; i++) {
+ if ((j = child[i]) < 0)
+ s_node[~j] = i;
+ else
+ parent[j] = parent[j - 1] = i;
+ if ((g = freq[i]) == f) {
+ block[i] = b;
+ }
+ else {
+ edge[b = block[i] = stock[avail++]] = i;
+ f = g;
+ }
+ }
}
/* ------------------------------------------------------------------------ */
static int
swap_inc(p)
- int p;
+ int p;
{
- int b, q, r, s;
+ int b, q, r, s;
- b = block[p];
- if ((q = edge[b]) != p) { /* swap for leader */
- r = child[p];
- s = child[q];
- child[p] = s;
- child[q] = r;
- if (r >= 0)
- parent[r] = parent[r - 1] = q;
- else
- s_node[~r] = q;
- if (s >= 0)
- parent[s] = parent[s - 1] = p;
- else
- s_node[~s] = p;
- p = q;
- goto Adjust;
- }
- else if (b == block[p + 1]) {
+ b = block[p];
+ if ((q = edge[b]) != p) { /* swap for leader */
+ r = child[p];
+ s = child[q];
+ child[p] = s;
+ child[q] = r;
+ if (r >= 0)
+ parent[r] = parent[r - 1] = q;
+ else
+ s_node[~r] = q;
+ if (s >= 0)
+ parent[s] = parent[s - 1] = p;
+ else
+ s_node[~s] = p;
+ p = q;
+ goto Adjust;
+ }
+ else if (b == block[p + 1]) {
Adjust:
- edge[b]++;
- if (++freq[p] == freq[p - 1]) {
- block[p] = block[p - 1];
- }
- else {
- edge[block[p] = stock[avail++]] = p; /* create block */
- }
- }
- else if (++freq[p] == freq[p - 1]) {
- stock[--avail] = b; /* delete block */
- block[p] = block[p - 1];
- }
- return parent[p];
+ edge[b]++;
+ if (++freq[p] == freq[p - 1]) {
+ block[p] = block[p - 1];
+ }
+ else {
+ edge[block[p] = stock[avail++]] = p; /* create block */
+ }
+ }
+ else if (++freq[p] == freq[p - 1]) {
+ stock[--avail] = b; /* delete block */
+ block[p] = block[p - 1];
+ }
+ return parent[p];
}
/* ------------------------------------------------------------------------ */
static void
update_c(p)
- int p;
+ int p;
{
- int q;
+ int q;
- if (freq[ROOT_C] == 0x8000) {
- reconst(0, n_max * 2 - 1);
- }
- freq[ROOT_C]++;
- q = s_node[p];
- do {
- q = swap_inc(q);
- } while (q != ROOT_C);
+ if (freq[ROOT_C] == 0x8000) {
+ reconst(0, n_max * 2 - 1);
+ }
+ freq[ROOT_C]++;
+ q = s_node[p];
+ do {
+ q = swap_inc(q);
+ } while (q != ROOT_C);
}
/* ------------------------------------------------------------------------ */
static void
update_p(p)
- int p;
+ int p;
{
- int q;
+ int q;
- if (total_p == 0x8000) {
- reconst(ROOT_P, most_p + 1);
- total_p = freq[ROOT_P];
- freq[ROOT_P] = 0xffff;
- }
- q = s_node[p + N_CHAR];
- while (q != ROOT_P) {
- q = swap_inc(q);
- }
- total_p++;
+ if (total_p == 0x8000) {
+ reconst(ROOT_P, most_p + 1);
+ total_p = freq[ROOT_P];
+ freq[ROOT_P] = 0xffff;
+ }
+ q = s_node[p + N_CHAR];
+ while (q != ROOT_P) {
+ q = swap_inc(q);
+ }
+ total_p++;
}
/* ------------------------------------------------------------------------ */
static void
make_new_node(p)
- int p;
+ int p;
{
- int q, r;
+ int q, r;
- r = most_p + 1;
- q = r + 1;
- s_node[~(child[r] = child[most_p])] = r;
- child[q] = ~(p + N_CHAR);
- child[most_p] = q;
- freq[r] = freq[most_p];
- freq[q] = 0;
- block[r] = block[most_p];
- if (most_p == ROOT_P) {
- freq[ROOT_P] = 0xffff;
- edge[block[ROOT_P]]++;
- }
- parent[r] = parent[q] = most_p;
- edge[block[q] = stock[avail++]] = s_node[p + N_CHAR] = most_p = q;
- update_p(p);
+ r = most_p + 1;
+ q = r + 1;
+ s_node[~(child[r] = child[most_p])] = r;
+ child[q] = ~(p + N_CHAR);
+ child[most_p] = q;
+ freq[r] = freq[most_p];
+ freq[q] = 0;
+ block[r] = block[most_p];
+ if (most_p == ROOT_P) {
+ freq[ROOT_P] = 0xffff;
+ edge[block[ROOT_P]]++;
+ }
+ parent[r] = parent[q] = most_p;
+ edge[block[q] = stock[avail++]] = s_node[p + N_CHAR] = most_p = q;
+ update_p(p);
}
/* ------------------------------------------------------------------------ */
static void
encode_c_dyn(c)
- unsigned int c;
+ unsigned int c;
{
- unsigned int bits;
- int p, d, cnt;
+ unsigned int bits;
+ int p, d, cnt;
- d = c - n1;
- if (d >= 0) {
- c = n1;
- }
- cnt = bits = 0;
- p = s_node[c];
- do {
- bits >>= 1;
- if (p & 1) {
- bits |= 0x80000000L;
- }
- cnt++;
- } while ((p = parent[p]) != ROOT_C);
- if (cnt <= 16) {
- putcode(cnt, bits >> 16);
- } else {
- putcode(16, bits >> 16);
- putbits(cnt - 16, bits);
- }
- if (d >= 0)
- putbits(8, d);
- update_c(c);
+ d = c - n1;
+ if (d >= 0) {
+ c = n1;
+ }
+ cnt = bits = 0;
+ p = s_node[c];
+ do {
+ bits >>= 1;
+ if (p & 1) {
+ bits |= 0x80000000L;
+ }
+ cnt++;
+ } while ((p = parent[p]) != ROOT_C);
+ if (cnt <= 16) {
+ putcode(cnt, bits >> 16);
+ } else {
+ putcode(16, bits >> 16);
+ putbits(cnt - 16, bits);
+ }
+ if (d >= 0)
+ putbits(8, d);
+ update_c(c);
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_c_dyn( /* void */ )
{
- int c;
- short buf, cnt;
+ int c;
+ short buf, cnt;
- c = child[ROOT_C];
- buf = bitbuf;
- cnt = 0;
- do {
- c = child[c - (buf < 0)];
- buf <<= 1;
- if (++cnt == 16) {
- fillbuf(16);
- buf = bitbuf;
- cnt = 0;
- }
- } while (c > 0);
- fillbuf(cnt);
- c = ~c;
- update_c(c);
- if (c == n1)
- c += getbits(8);
- return c;
+ c = child[ROOT_C];
+ buf = bitbuf;
+ cnt = 0;
+ do {
+ c = child[c - (buf < 0)];
+ buf <<= 1;
+ if (++cnt == 16) {
+ fillbuf(16);
+ buf = bitbuf;
+ cnt = 0;
+ }
+ } while (c > 0);
+ fillbuf(cnt);
+ c = ~c;
+ update_c(c);
+ if (c == n1)
+ c += getbits(8);
+ return c;
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_p_dyn( /* void */ )
{
- int c;
- short buf, cnt;
+ int c;
+ short buf, cnt;
- while (count > nextcount) {
- make_new_node(nextcount / 64);
- if ((nextcount += 64) >= nn)
- nextcount = 0xffffffff;
- }
- c = child[ROOT_P];
- buf = bitbuf;
- cnt = 0;
- while (c > 0) {
- c = child[c - (buf < 0)];
- buf <<= 1;
- if (++cnt == 16) {
- fillbuf(16);
- buf = bitbuf;
- cnt = 0;
- }
- }
- fillbuf(cnt);
- c = (~c) - N_CHAR;
- update_p(c);
+ while (count > nextcount) {
+ make_new_node(nextcount / 64);
+ if ((nextcount += 64) >= nn)
+ nextcount = 0xffffffff;
+ }
+ c = child[ROOT_P];
+ buf = bitbuf;
+ cnt = 0;
+ while (c > 0) {
+ c = child[c - (buf < 0)];
+ buf <<= 1;
+ if (++cnt == 16) {
+ fillbuf(16);
+ buf = bitbuf;
+ cnt = 0;
+ }
+ }
+ fillbuf(cnt);
+ c = (~c) - N_CHAR;
+ update_p(c);
- return (c << 6) + getbits(6);
+ return (c << 6) + getbits(6);
}
/* ------------------------------------------------------------------------ */
/* lh1 */
void
output_dyn(code, pos)
- unsigned int code;
- unsigned int pos;
+ unsigned int code;
+ unsigned int pos;
{
- encode_c_dyn(code);
- if (code >= 0x100) {
- encode_p_st0(pos);
- }
+ encode_c_dyn(code);
+ if (code >= 0x100) {
+ encode_p_st0(pos);
+ }
}
/* ------------------------------------------------------------------------ */
void
encode_end_dyn( /* void */ )
{
- putcode(7, 0);
+ putcode(7, 0);
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* extract.c -- extrcat from archive */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* extract.c -- extrcat from archive */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
int
decode_lzhuf(infp, outfp, original_size, packed_size, name, method)
- FILE *infp;
- FILE *outfp;
- long original_size;
- long packed_size;
- char *name;
- int method;
+ FILE *infp;
+ FILE *outfp;
+ long original_size;
+ long packed_size;
+ char *name;
+ int method;
{
unsigned int crc;
- interface.method = method;
- interface.dicbit = 13; /* method + 8; -lh5- */
- interface.infile = infp;
- interface.outfile = outfp;
- interface.original = original_size;
- interface.packed = packed_size;
+ interface.method = method;
+ interface.dicbit = 13; /* method + 8; -lh5- */
+ interface.infile = infp;
+ interface.outfile = outfp;
+ interface.original = original_size;
+ interface.packed = packed_size;
- switch (method) {
- case LZHUFF0_METHOD_NUM:
- case LARC4_METHOD_NUM:
- start_indicator(name, original_size
- ,verify_mode ? "Testing " : "Melting ", 2048);
- copyfile(infp, (verify_mode ? NULL : outfp), original_size, 2, &crc);
- break;
- case LARC_METHOD_NUM: /* -lzs- */
- interface.dicbit = 11;
- start_indicator(name, original_size
- ,verify_mode ? "Testing " : "Melting "
- ,1 << interface.dicbit);
- crc = decode(&interface);
- break;
- case LZHUFF1_METHOD_NUM: /* -lh1- */
- case LZHUFF4_METHOD_NUM: /* -lh4- */
- case LARC5_METHOD_NUM: /* -lz5- */
- interface.dicbit = 12;
- start_indicator(name, original_size
- ,verify_mode ? "Testing " : "Melting "
- ,1 << interface.dicbit);
- crc = decode(&interface);
- break;
- case LZHUFF6_METHOD_NUM: /* -lh6- */ /* Added N.Watazaki (^_^) */
+ switch (method) {
+ case LZHUFF0_METHOD_NUM:
+ case LARC4_METHOD_NUM:
+ start_indicator(name, original_size
+ ,verify_mode ? "Testing " : "Melting ", 2048);
+ copyfile(infp, (verify_mode ? NULL : outfp), original_size, 2, &crc);
+ break;
+ case LARC_METHOD_NUM: /* -lzs- */
+ interface.dicbit = 11;
+ start_indicator(name, original_size
+ ,verify_mode ? "Testing " : "Melting "
+ ,1 << interface.dicbit);
+ crc = decode(&interface);
+ break;
+ case LZHUFF1_METHOD_NUM: /* -lh1- */
+ case LZHUFF4_METHOD_NUM: /* -lh4- */
+ case LARC5_METHOD_NUM: /* -lz5- */
+ interface.dicbit = 12;
+ start_indicator(name, original_size
+ ,verify_mode ? "Testing " : "Melting "
+ ,1 << interface.dicbit);
+ crc = decode(&interface);
+ break;
+ case LZHUFF6_METHOD_NUM: /* -lh6- */ /* Added N.Watazaki (^_^) */
#ifdef SUPPORT_LH7
- case LZHUFF7_METHOD_NUM: /* -lh7- */
+ case LZHUFF7_METHOD_NUM: /* -lh7- */
#endif
- interface.dicbit = (method - LZHUFF6_METHOD_NUM) + 15;
-
- default:
- start_indicator(name, original_size
- ,verify_mode ? "Testing " : "Melting "
- ,1 << interface.dicbit);
- crc = decode(&interface);
- }
- finish_indicator(name, verify_mode ? "Tested " : "Melted ");
+ interface.dicbit = (method - LZHUFF6_METHOD_NUM) + 15;
+
+ default:
+ start_indicator(name, original_size
+ ,verify_mode ? "Testing " : "Melting "
+ ,1 << interface.dicbit);
+ crc = decode(&interface);
+ }
+ finish_indicator(name, verify_mode ? "Tested " : "Melted ");
- return crc;
+ return crc;
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* header.c -- header manipulate functions */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Original Y.Tagawa */
-/* modified 1991.12.16 M.Oki */
-/* Ver. 1.10 Symbolic Link added 1993.10.01 N.Watazaki */
-/* Ver. 1.13b Symbolic Link Bug Fix 1994.08.22 N.Watazaki */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14i bug fixed 2000.10.06 t.okamoto */
+/* LHa for UNIX */
+/* header.c -- header manipulate functions */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Original Y.Tagawa */
+/* modified 1991.12.16 M.Oki */
+/* Ver. 1.10 Symbolic Link added 1993.10.01 N.Watazaki */
+/* Ver. 1.13b Symbolic Link Bug Fix 1994.08.22 N.Watazaki */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14i bug fixed 2000.10.06 t.okamoto */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
static char *get_ptr;
-#define GET_BYTE() (*get_ptr++ & 0xff)
+#define GET_BYTE() (*get_ptr++ & 0xff)
#if DUMP_HEADER
static char *start_ptr;
#define get_byte() dump_get_byte()
#define skip_bytes(len) dump_skip_bytes(len)
#else
-#define setup_get(PTR) (get_ptr = (PTR))
-#define get_byte() GET_BYTE()
+#define setup_get(PTR) (get_ptr = (PTR))
+#define get_byte() GET_BYTE()
#define skip_bytes(len) (get_ptr += (len))
#endif
-#define put_ptr get_ptr
-#define setup_put(PTR) (put_ptr = (PTR))
-#define put_byte(c) (*put_ptr++ = (char)(c))
+#define put_ptr get_ptr
+#define setup_put(PTR) (put_ptr = (PTR))
+#define put_byte(c) (*put_ptr++ = (char)(c))
int optional_archive_kanji_code = NONE;
int optional_system_kanji_code = NONE;
/* ------------------------------------------------------------------------ */
int
calc_sum(p, len)
- register char *p;
- register int len;
+ register char *p;
+ register int len;
{
- register int sum;
+ register int sum;
- for (sum = 0; len; len--)
- sum += *p++;
+ for (sum = 0; len; len--)
+ sum += *p++;
- return sum & 0xff;
+ return sum & 0xff;
}
#if DUMP_HEADER
static int
get_word()
{
- int b0, b1;
+ int b0, b1;
int w;
#if DUMP_HEADER
if (verbose_listing && verbose > 1)
printf("%02d %2d: ", get_ptr - start_ptr, 2);
#endif
- b0 = GET_BYTE();
- b1 = GET_BYTE();
+ b0 = GET_BYTE();
+ b1 = GET_BYTE();
w = (b1 << 8) + b0;
#if DUMP_HEADER
if (verbose_listing && verbose > 1)
printf("%d(0x%04x)\n", w, w);
#endif
- return w;
+ return w;
}
/* ------------------------------------------------------------------------ */
static void
put_word(v)
- unsigned int v;
+ unsigned int v;
{
- put_byte(v);
- put_byte(v >> 8);
+ put_byte(v);
+ put_byte(v >> 8);
}
/* ------------------------------------------------------------------------ */
static long
get_longword()
{
- long b0, b1, b2, b3;
+ long b0, b1, b2, b3;
long l;
#if DUMP_HEADER
if (verbose_listing && verbose > 1)
printf("%02d %2d: ", get_ptr - start_ptr, 4);
#endif
- b0 = GET_BYTE();
- b1 = GET_BYTE();
- b2 = GET_BYTE();
- b3 = GET_BYTE();
+ b0 = GET_BYTE();
+ b1 = GET_BYTE();
+ b2 = GET_BYTE();
+ b3 = GET_BYTE();
l = (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
#if DUMP_HEADER
if (verbose_listing && verbose > 1)
printf("%ld(0x%08lx)\n", l, l);
#endif
- return l;
+ return l;
}
/* ------------------------------------------------------------------------ */
static void
put_longword(v)
- long v;
+ long v;
{
- put_byte(v);
- put_byte(v >> 8);
- put_byte(v >> 16);
- put_byte(v >> 24);
+ put_byte(v);
+ put_byte(v >> 8);
+ put_byte(v >> 16);
+ put_byte(v >> 24);
}
static int
{
#ifdef HAVE_TZSET
#if defined(_MINIX)
- extern long timezone; /* not defined in time.h */
+ extern long timezone; /* not defined in time.h */
#endif
- tzset();
- return timezone;
+ tzset();
+ return timezone;
#elif HAVE_FTIME
- struct timeb buf;
+ struct timeb buf;
- ftime(&buf);
- return buf.timezone * 60L;
+ ftime(&buf);
+ return buf.timezone * 60L;
#elif HAVE_STRUCT_TM_TM_GMTOFF
- time_t tt;
+ time_t tt;
- time(&tt);
- return -localtime(&tt)->tm_gmtoff;
+ time(&tt);
+ return -localtime(&tt)->tm_gmtoff;
#elif GETTIMEOFDAY_HAS_2ND_ARG
- struct timeval tp;
- struct timezone tzp;
- gettimeofday(&tp, &tzp);/* specific to 4.3BSD */
- /*
- * return (tzp.tz_minuteswest * 60L + (tzp.tz_dsttime != 0 ? 60L *
- * 60L : 0));
- */
- return (tzp.tz_minuteswest * 60L);
+ struct timeval tp;
+ struct timezone tzp;
+ gettimeofday(&tp, &tzp);/* specific to 4.3BSD */
+ /*
+ * return (tzp.tz_minuteswest * 60L + (tzp.tz_dsttime != 0 ? 60L *
+ * 60L : 0));
+ */
+ return (tzp.tz_minuteswest * 60L);
#else
/* Compile error will be caused */
CANNOT GET TIMEZONE INFORMATION ON YOUR SYSTEM.
/* ------------------------------------------------------------------------ */
static time_t
generic_to_unix_stamp(t)
- long t;
+ long t;
{
#if defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL)
- struct tm dostm;
-
- /*
- * special case: if MSDOS format date and time were zero, then we
- * set time to be zero here too.
- */
- if (t == 0)
- return (time_t) 0;
-
- dostm.tm_sec = (t & 0x1f) * 2;
- dostm.tm_min = t >> 5 & 0x3f;
- dostm.tm_hour = t >> 11 & 0x1f;
- dostm.tm_mday = t >> 16 & 0x1f;
- dostm.tm_mon = (t >> (16+5) & 0x0f) - 1; /* 0..11 */
- dostm.tm_year = (t >> (16+9) & 0x7f) + 80;
- dostm.tm_isdst = -1;
+ struct tm dostm;
+
+ /*
+ * special case: if MSDOS format date and time were zero, then we
+ * set time to be zero here too.
+ */
+ if (t == 0)
+ return (time_t) 0;
+
+ dostm.tm_sec = (t & 0x1f) * 2;
+ dostm.tm_min = t >> 5 & 0x3f;
+ dostm.tm_hour = t >> 11 & 0x1f;
+ dostm.tm_mday = t >> 16 & 0x1f;
+ dostm.tm_mon = (t >> (16+5) & 0x0f) - 1; /* 0..11 */
+ dostm.tm_year = (t >> (16+9) & 0x7f) + 80;
+ dostm.tm_isdst = -1;
#if HAVE_MKTIME
- return (time_t) mktime(&dostm);
+ return (time_t) mktime(&dostm);
#else /* HAVE_TIMELOCAL is defined */
- return (time_t) timelocal(&dostm);
+ return (time_t) timelocal(&dostm);
#endif
-#else /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
- int year, month, day, hour, min, sec;
- long longtime;
- static unsigned int dsboy[12] = {0, 31, 59, 90, 120, 151,
- 181, 212, 243, 273, 304, 334};
- unsigned int days;
-
- /*
- * special case: if MSDOS format date and time were zero, then we
- * set time to be zero here too.
- */
- if (t == 0)
- return (time_t) 0;
-
- year = ((int) (t >> 16 + 9) & 0x7f) + 1980;
- month = (int) (t >> 16 + 5) & 0x0f; /* 1..12 means Jan..Dec */
- day = (int) (t >> 16) & 0x1f; /* 1..31 means 1st,...31st */
-
- hour = ((int) t >> 11) & 0x1f;
- min = ((int) t >> 5) & 0x3f;
- sec = ((int) t & 0x1f) * 2;
-
- /* Calculate days since 1970.01.01 */
- days = (365 * (year - 1970) + /* days due to whole years */
- (year - 1970 + 1) / 4 + /* days due to leap years */
- dsboy[month - 1] + /* days since beginning of this year */
- day - 1); /* days since beginning of month */
-
- if ((year % 4 == 0) &&
- (year % 100 != 0 || year % 400 == 0) && /* 1999.5.24 t.oka */
- (month >= 3)) /* if this is a leap year and month */
- days++; /* is March or later, add a day */
-
- /* Knowing the days, we can find seconds */
- longtime = (((days * 24) + hour) * 60 + min) * 60 + sec;
- longtime += gettz(); /* adjust for timezone */
-
- /* LONGTIME is now the time in seconds, since 1970/01/01 00:00:00. */
- return (time_t) longtime;
-#endif /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
+#else /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
+ int year, month, day, hour, min, sec;
+ long longtime;
+ static unsigned int dsboy[12] = {0, 31, 59, 90, 120, 151,
+ 181, 212, 243, 273, 304, 334};
+ unsigned int days;
+
+ /*
+ * special case: if MSDOS format date and time were zero, then we
+ * set time to be zero here too.
+ */
+ if (t == 0)
+ return (time_t) 0;
+
+ year = ((int) (t >> 16 + 9) & 0x7f) + 1980;
+ month = (int) (t >> 16 + 5) & 0x0f; /* 1..12 means Jan..Dec */
+ day = (int) (t >> 16) & 0x1f; /* 1..31 means 1st,...31st */
+
+ hour = ((int) t >> 11) & 0x1f;
+ min = ((int) t >> 5) & 0x3f;
+ sec = ((int) t & 0x1f) * 2;
+
+ /* Calculate days since 1970.01.01 */
+ days = (365 * (year - 1970) + /* days due to whole years */
+ (year - 1970 + 1) / 4 + /* days due to leap years */
+ dsboy[month - 1] + /* days since beginning of this year */
+ day - 1); /* days since beginning of month */
+
+ if ((year % 4 == 0) &&
+ (year % 100 != 0 || year % 400 == 0) && /* 1999.5.24 t.oka */
+ (month >= 3)) /* if this is a leap year and month */
+ days++; /* is March or later, add a day */
+
+ /* Knowing the days, we can find seconds */
+ longtime = (((days * 24) + hour) * 60 + min) * 60 + sec;
+ longtime += gettz(); /* adjust for timezone */
+
+ /* LONGTIME is now the time in seconds, since 1970/01/01 00:00:00. */
+ return (time_t) longtime;
+#endif /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
}
/* ------------------------------------------------------------------------ */
static long
unix_to_generic_stamp(t)
- time_t t;
+ time_t t;
{
- struct tm *tm = localtime(&t);
-
- return ((((long) (tm->tm_year - 80)) << 25) +
- (((long) (tm->tm_mon + 1)) << 21) +
- (((long) tm->tm_mday) << 16) +
- (long) ((tm->tm_hour << 11) +
- (tm->tm_min << 5) +
- (tm->tm_sec / 2)));
+ struct tm *tm = localtime(&t);
+
+ return ((((long) (tm->tm_year - 80)) << 25) +
+ (((long) (tm->tm_mon + 1)) << 21) +
+ (((long) tm->tm_mday) << 16) +
+ (long) ((tm->tm_hour << 11) +
+ (tm->tm_min << 5) +
+ (tm->tm_sec / 2)));
}
static unsigned long
}
/* ------------------------------------------------------------------------ */
-/* build header functions */
+/* build header functions */
/* ------------------------------------------------------------------------ */
/*
system_kanji_code,
archive_delim, system_delim, filename_case);
- if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
+ if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
char *p;
/* split symbolic link */
p = strchr(hdr->name, '|');
/* skip SFX header */
boolean
skip_msdos_sfx1_code(fp)
- FILE *fp;
+ FILE *fp;
{
- unsigned char buffer[64 * 1024]; /* SFX header size */
- unsigned char *p;
- int n;
+ unsigned char buffer[64 * 1024]; /* SFX header size */
+ unsigned char *p;
+ int n;
- n = fread(buffer, 1, sizeof(buffer), fp);
+ n = fread(buffer, 1, sizeof(buffer), fp);
- for (p = buffer; p < buffer + n; p++) {
- if (! (p[I_METHOD]=='-' && p[I_METHOD+1]=='l' && p[I_METHOD+4]=='-'))
+ for (p = buffer; p < buffer + n; p++) {
+ if (! (p[I_METHOD]=='-' && p[I_METHOD+1]=='l' && p[I_METHOD+4]=='-'))
continue;
- /* found "-l??-" keyword (as METHOD type string) */
+ /* found "-l??-" keyword (as METHOD type string) */
/* size and checksum validate check */
fseek(fp, (p - buffer) - n, SEEK_CUR);
return TRUE;
}
- }
+ }
- fseek(fp, -n, SEEK_CUR);
- return FALSE;
+ fseek(fp, -n, SEEK_CUR);
+ return FALSE;
}
/* ------------------------------------------------------------------------ */
void
init_header(name, v_stat, hdr)
- char *name;
- struct stat *v_stat;
- LzHeader *hdr;
+ char *name;
+ struct stat *v_stat;
+ LzHeader *hdr;
{
- int len;
+ int len;
memset(hdr, 0, sizeof(LzHeader));
but need set for empty files */
memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STORAGE);
- hdr->packed_size = 0;
- hdr->original_size = v_stat->st_size;
- hdr->attribute = GENERIC_ATTRIBUTE;
- hdr->header_level = header_level;
- strcpy(hdr->name, name);
- len = strlen(name);
- hdr->crc = 0x0000;
- hdr->extend_type = EXTEND_UNIX;
- hdr->unix_last_modified_stamp = v_stat->st_mtime;
- /* since 00:00:00 JAN.1.1970 */
+ hdr->packed_size = 0;
+ hdr->original_size = v_stat->st_size;
+ hdr->attribute = GENERIC_ATTRIBUTE;
+ hdr->header_level = header_level;
+ strcpy(hdr->name, name);
+ len = strlen(name);
+ hdr->crc = 0x0000;
+ hdr->extend_type = EXTEND_UNIX;
+ hdr->unix_last_modified_stamp = v_stat->st_mtime;
+ /* since 00:00:00 JAN.1.1970 */
#ifdef NOT_COMPATIBLE_MODE
- /* Please need your modification in this space. */
+ /* Please need your modification in this space. */
#else
- hdr->unix_mode = v_stat->st_mode;
+ hdr->unix_mode = v_stat->st_mode;
#endif
- hdr->unix_uid = v_stat->st_uid;
- hdr->unix_gid = v_stat->st_gid;
+ hdr->unix_uid = v_stat->st_uid;
+ hdr->unix_gid = v_stat->st_gid;
#if INCLUDE_OWNER_NAME_IN_HEADER
#if HAVE_GETPWUID
}
#endif
#endif /* INCLUDE_OWNER_NAME_IN_HEADER */
- if (is_directory(v_stat)) {
- memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
- hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
- hdr->original_size = 0;
- if (len > 0 && hdr->name[len - 1] != '/')
- strcpy(&hdr->name[len++], "/");
- }
+ if (is_directory(v_stat)) {
+ memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
+ hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
+ hdr->original_size = 0;
+ if (len > 0 && hdr->name[len - 1] != '/')
+ strcpy(&hdr->name[len++], "/");
+ }
#ifdef S_IFLNK
- if (is_symlink(v_stat)) {
- memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
- hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
- hdr->original_size = 0;
- readlink(name, hdr->realname, sizeof(hdr->realname));
- }
+ if (is_symlink(v_stat)) {
+ memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
+ hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
+ hdr->original_size = 0;
+ readlink(name, hdr->realname, sizeof(hdr->realname));
+ }
#endif
}
archive_delim = "\\";
}
- if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
+ if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
char *p;
p = strchr(hdr->name, '|');
if (p) {
/*
* SJIS <-> EUC ÊÑ´¹´Ø¿ô
- * ¡ÖÆüËܸì¾ðÊó½èÍý¡× ¥½¥Õ¥È¥Ð¥ó¥¯(³ô)
- * ¤è¤êÈ´¿è(by Koji Arai)
+ * ¡ÖÆüËܸì¾ðÊó½èÍý¡× ¥½¥Õ¥È¥Ð¥ó¥¯(³ô)
+ * ¤è¤êÈ´¿è(by Koji Arai)
*/
void
euc2sjis(int *p1, int *p2)
*p2 |= 0x80;
}
#endif /* MULTIBYTE_FILENAME */
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* compile-command:"gcc -c header.c" */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* huf.c -- new static Huffman */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14i Support LH7 & Bug Fixed 2000.10. 6 t.okamoto */
+/* LHa for UNIX */
+/* huf.c -- new static Huffman */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14i Support LH7 & Bug Fixed 2000.10. 6 t.okamoto */
/* ------------------------------------------------------------------------ */
#include "lha.h"
static unsigned int bufsiz;
static unsigned short blocksize;
static unsigned short output_pos, output_mask;
-static int pbit;
-static int np;
+static int pbit;
+static int np;
/* ------------------------------------------------------------------------ */
-/* Encording */
+/* Encording */
/* ------------------------------------------------------------------------ */
static void
count_t_freq(/*void*/)
{
- short i, k, n, count;
-
- for (i = 0; i < NT; i++)
- t_freq[i] = 0;
- n = NC;
- while (n > 0 && c_len[n - 1] == 0)
- n--;
- i = 0;
- while (i < n) {
- k = c_len[i++];
- if (k == 0) {
- count = 1;
- while (i < n && c_len[i] == 0) {
- i++;
- count++;
- }
- if (count <= 2)
- t_freq[0] += count;
- else if (count <= 18)
- t_freq[1]++;
- else if (count == 19) {
- t_freq[0]++;
- t_freq[1]++;
- }
- else
- t_freq[2]++;
- } else
- t_freq[k + 2]++;
- }
+ short i, k, n, count;
+
+ for (i = 0; i < NT; i++)
+ t_freq[i] = 0;
+ n = NC;
+ while (n > 0 && c_len[n - 1] == 0)
+ n--;
+ i = 0;
+ while (i < n) {
+ k = c_len[i++];
+ if (k == 0) {
+ count = 1;
+ while (i < n && c_len[i] == 0) {
+ i++;
+ count++;
+ }
+ if (count <= 2)
+ t_freq[0] += count;
+ else if (count <= 18)
+ t_freq[1]++;
+ else if (count == 19) {
+ t_freq[0]++;
+ t_freq[1]++;
+ }
+ else
+ t_freq[2]++;
+ } else
+ t_freq[k + 2]++;
+ }
}
/* ------------------------------------------------------------------------ */
static void
write_pt_len(n, nbit, i_special)
- short n;
- short nbit;
- short i_special;
+ short n;
+ short nbit;
+ short i_special;
{
- short i, k;
-
- while (n > 0 && pt_len[n - 1] == 0)
- n--;
- putbits(nbit, n);
- i = 0;
- while (i < n) {
- k = pt_len[i++];
- if (k <= 6)
- putbits(3, k);
- else
- putbits(k - 3, USHRT_MAX << 1);
- if (i == i_special) {
- while (i < 6 && pt_len[i] == 0)
- i++;
- putbits(2, i - 3);
- }
- }
+ short i, k;
+
+ while (n > 0 && pt_len[n - 1] == 0)
+ n--;
+ putbits(nbit, n);
+ i = 0;
+ while (i < n) {
+ k = pt_len[i++];
+ if (k <= 6)
+ putbits(3, k);
+ else
+ putbits(k - 3, USHRT_MAX << 1);
+ if (i == i_special) {
+ while (i < 6 && pt_len[i] == 0)
+ i++;
+ putbits(2, i - 3);
+ }
+ }
}
/* ------------------------------------------------------------------------ */
static void
write_c_len(/*void*/)
{
- short i, k, n, count;
-
- n = NC;
- while (n > 0 && c_len[n - 1] == 0)
- n--;
- putbits(CBIT, n);
- i = 0;
- while (i < n) {
- k = c_len[i++];
- if (k == 0) {
- count = 1;
- while (i < n && c_len[i] == 0) {
- i++;
- count++;
- }
- if (count <= 2) {
- for (k = 0; k < count; k++)
- putcode(pt_len[0], pt_code[0]);
- }
- else if (count <= 18) {
- putcode(pt_len[1], pt_code[1]);
- putbits(4, count - 3);
- }
- else if (count == 19) {
- putcode(pt_len[0], pt_code[0]);
- putcode(pt_len[1], pt_code[1]);
- putbits(4, 15);
- }
- else {
- putcode(pt_len[2], pt_code[2]);
- putbits(CBIT, count - 20);
- }
- }
- else
- putcode(pt_len[k + 2], pt_code[k + 2]);
- }
+ short i, k, n, count;
+
+ n = NC;
+ while (n > 0 && c_len[n - 1] == 0)
+ n--;
+ putbits(CBIT, n);
+ i = 0;
+ while (i < n) {
+ k = c_len[i++];
+ if (k == 0) {
+ count = 1;
+ while (i < n && c_len[i] == 0) {
+ i++;
+ count++;
+ }
+ if (count <= 2) {
+ for (k = 0; k < count; k++)
+ putcode(pt_len[0], pt_code[0]);
+ }
+ else if (count <= 18) {
+ putcode(pt_len[1], pt_code[1]);
+ putbits(4, count - 3);
+ }
+ else if (count == 19) {
+ putcode(pt_len[0], pt_code[0]);
+ putcode(pt_len[1], pt_code[1]);
+ putbits(4, 15);
+ }
+ else {
+ putcode(pt_len[2], pt_code[2]);
+ putbits(CBIT, count - 20);
+ }
+ }
+ else
+ putcode(pt_len[k + 2], pt_code[k + 2]);
+ }
}
/* ------------------------------------------------------------------------ */
static void
encode_c(c)
- short c;
+ short c;
{
- putcode(c_len[c], c_code[c]);
+ putcode(c_len[c], c_code[c]);
}
/* ------------------------------------------------------------------------ */
static void
encode_p(p)
- unsigned short p;
+ unsigned short p;
{
- unsigned short c, q;
+ unsigned short c, q;
- c = 0;
- q = p;
- while (q) {
- q >>= 1;
- c++;
- }
- putcode(pt_len[c], pt_code[c]);
- if (c > 1)
- putbits(c - 1, p);
+ c = 0;
+ q = p;
+ while (q) {
+ q >>= 1;
+ c++;
+ }
+ putcode(pt_len[c], pt_code[c]);
+ if (c > 1)
+ putbits(c - 1, p);
}
/* ------------------------------------------------------------------------ */
static void
send_block( /* void */ )
{
- unsigned char flags;
- unsigned short i, k, root, pos, size;
-
- root = make_tree(NC, c_freq, c_len, c_code);
- size = c_freq[root];
- putbits(16, size);
- if (root >= NC) {
- count_t_freq();
- root = make_tree(NT, t_freq, pt_len, pt_code);
- if (root >= NT) {
- write_pt_len(NT, TBIT, 3);
- } else {
- putbits(TBIT, 0);
- putbits(TBIT, root);
- }
- write_c_len();
- } else {
- putbits(TBIT, 0);
- putbits(TBIT, 0);
- putbits(CBIT, 0);
- putbits(CBIT, root);
- }
- root = make_tree(np, p_freq, pt_len, pt_code);
- if (root >= np) {
- write_pt_len(np, pbit, -1);
- }
- else {
- putbits(pbit, 0);
- putbits(pbit, root);
- }
- pos = 0;
- for (i = 0; i < size; i++) {
- if (i % CHAR_BIT == 0)
- flags = buf[pos++];
- else
- flags <<= 1;
- if (flags & (1 << (CHAR_BIT - 1))) {
- encode_c(buf[pos++] + (1 << CHAR_BIT));
- k = buf[pos++] << CHAR_BIT;
- k += buf[pos++];
- encode_p(k);
- } else
- encode_c(buf[pos++]);
- if (unpackable)
- return;
- }
- for (i = 0; i < NC; i++)
- c_freq[i] = 0;
- for (i = 0; i < np; i++)
- p_freq[i] = 0;
+ unsigned char flags;
+ unsigned short i, k, root, pos, size;
+
+ root = make_tree(NC, c_freq, c_len, c_code);
+ size = c_freq[root];
+ putbits(16, size);
+ if (root >= NC) {
+ count_t_freq();
+ root = make_tree(NT, t_freq, pt_len, pt_code);
+ if (root >= NT) {
+ write_pt_len(NT, TBIT, 3);
+ } else {
+ putbits(TBIT, 0);
+ putbits(TBIT, root);
+ }
+ write_c_len();
+ } else {
+ putbits(TBIT, 0);
+ putbits(TBIT, 0);
+ putbits(CBIT, 0);
+ putbits(CBIT, root);
+ }
+ root = make_tree(np, p_freq, pt_len, pt_code);
+ if (root >= np) {
+ write_pt_len(np, pbit, -1);
+ }
+ else {
+ putbits(pbit, 0);
+ putbits(pbit, root);
+ }
+ pos = 0;
+ for (i = 0; i < size; i++) {
+ if (i % CHAR_BIT == 0)
+ flags = buf[pos++];
+ else
+ flags <<= 1;
+ if (flags & (1 << (CHAR_BIT - 1))) {
+ encode_c(buf[pos++] + (1 << CHAR_BIT));
+ k = buf[pos++] << CHAR_BIT;
+ k += buf[pos++];
+ encode_p(k);
+ } else
+ encode_c(buf[pos++]);
+ if (unpackable)
+ return;
+ }
+ for (i = 0; i < NC; i++)
+ c_freq[i] = 0;
+ for (i = 0; i < np; i++)
+ p_freq[i] = 0;
}
/* ------------------------------------------------------------------------ */
/* lh4, 5, 6 */
void
output_st1(c, p)
- unsigned short c;
- unsigned short p;
+ unsigned short c;
+ unsigned short p;
{
- static unsigned short cpos;
-
- output_mask >>= 1;
- if (output_mask == 0) {
- output_mask = 1 << (CHAR_BIT - 1);
- if (output_pos >= bufsiz - 3 * CHAR_BIT) {
- send_block();
- if (unpackable)
- return;
- output_pos = 0;
- }
- cpos = output_pos++;
- buf[cpos] = 0;
- }
- buf[output_pos++] = (unsigned char) c;
- c_freq[c]++;
- if (c >= (1 << CHAR_BIT)) {
- buf[cpos] |= output_mask;
- buf[output_pos++] = (unsigned char) (p >> CHAR_BIT);
- buf[output_pos++] = (unsigned char) p;
- c = 0;
- while (p) {
- p >>= 1;
- c++;
- }
- p_freq[c]++;
- }
+ static unsigned short cpos;
+
+ output_mask >>= 1;
+ if (output_mask == 0) {
+ output_mask = 1 << (CHAR_BIT - 1);
+ if (output_pos >= bufsiz - 3 * CHAR_BIT) {
+ send_block();
+ if (unpackable)
+ return;
+ output_pos = 0;
+ }
+ cpos = output_pos++;
+ buf[cpos] = 0;
+ }
+ buf[output_pos++] = (unsigned char) c;
+ c_freq[c]++;
+ if (c >= (1 << CHAR_BIT)) {
+ buf[cpos] |= output_mask;
+ buf[output_pos++] = (unsigned char) (p >> CHAR_BIT);
+ buf[output_pos++] = (unsigned char) p;
+ c = 0;
+ while (p) {
+ p >>= 1;
+ c++;
+ }
+ p_freq[c]++;
+ }
}
/* ------------------------------------------------------------------------ */
unsigned char *
alloc_buf( /* void */ )
{
- bufsiz = 16 * 1024 *2; /* 65408U; */ /* t.okamoto */
- while ((buf = (unsigned char *) malloc(bufsiz)) == NULL) {
- bufsiz = (bufsiz / 10) * 9;
- if (bufsiz < 4 * 1024)
+ bufsiz = 16 * 1024 *2; /* 65408U; */ /* t.okamoto */
+ while ((buf = (unsigned char *) malloc(bufsiz)) == NULL) {
+ bufsiz = (bufsiz / 10) * 9;
+ if (bufsiz < 4 * 1024)
fatal_error("Not enough memory");
- }
- return buf;
+ }
+ return buf;
}
/* ------------------------------------------------------------------------ */
void
encode_start_st1( /* void */ )
{
- int i;
+ int i;
switch (dicbit) {
case LZHUFF4_DICBIT:
assert(0);
}
- for (i = 0; i < NC; i++)
- c_freq[i] = 0;
- for (i = 0; i < np; i++)
- p_freq[i] = 0;
- output_pos = output_mask = 0;
- init_putbits();
+ for (i = 0; i < NC; i++)
+ c_freq[i] = 0;
+ for (i = 0; i < np; i++)
+ p_freq[i] = 0;
+ output_pos = output_mask = 0;
+ init_putbits();
init_code_cache();
- buf[0] = 0;
+ buf[0] = 0;
}
/* ------------------------------------------------------------------------ */
void
encode_end_st1( /* void */ )
{
- if (!unpackable) {
- send_block();
- putbits(CHAR_BIT - 1, 0); /* flush remaining bits */
- }
+ if (!unpackable) {
+ send_block();
+ putbits(CHAR_BIT - 1, 0); /* flush remaining bits */
+ }
}
/* ------------------------------------------------------------------------ */
-/* decoding */
+/* decoding */
/* ------------------------------------------------------------------------ */
static void
read_pt_len(nn, nbit, i_special)
- short nn;
- short nbit;
- short i_special;
+ short nn;
+ short nbit;
+ short i_special;
{
- int i, c, n;
-
- n = getbits(nbit);
- if (n == 0) {
- c = getbits(nbit);
- for (i = 0; i < nn; i++)
- pt_len[i] = 0;
- for (i = 0; i < 256; i++)
- pt_table[i] = c;
- }
- else {
- i = 0;
- while (i < n) {
- c = bitbuf >> (16 - 3);
- if (c == 7) {
- unsigned short mask = 1 << (16 - 4);
- while (mask & bitbuf) {
- mask >>= 1;
- c++;
- }
- }
- fillbuf((c < 7) ? 3 : c - 3);
- pt_len[i++] = c;
- if (i == i_special) {
- c = getbits(2);
- while (--c >= 0)
- pt_len[i++] = 0;
- }
- }
- while (i < nn)
- pt_len[i++] = 0;
- make_table(nn, pt_len, 8, pt_table);
- }
+ int i, c, n;
+
+ n = getbits(nbit);
+ if (n == 0) {
+ c = getbits(nbit);
+ for (i = 0; i < nn; i++)
+ pt_len[i] = 0;
+ for (i = 0; i < 256; i++)
+ pt_table[i] = c;
+ }
+ else {
+ i = 0;
+ while (i < n) {
+ c = bitbuf >> (16 - 3);
+ if (c == 7) {
+ unsigned short mask = 1 << (16 - 4);
+ while (mask & bitbuf) {
+ mask >>= 1;
+ c++;
+ }
+ }
+ fillbuf((c < 7) ? 3 : c - 3);
+ pt_len[i++] = c;
+ if (i == i_special) {
+ c = getbits(2);
+ while (--c >= 0)
+ pt_len[i++] = 0;
+ }
+ }
+ while (i < nn)
+ pt_len[i++] = 0;
+ make_table(nn, pt_len, 8, pt_table);
+ }
}
/* ------------------------------------------------------------------------ */
static void
read_c_len( /* void */ )
{
- short i, c, n;
-
- n = getbits(CBIT);
- if (n == 0) {
- c = getbits(CBIT);
- for (i = 0; i < NC; i++)
- c_len[i] = 0;
- for (i = 0; i < 4096; i++)
- c_table[i] = c;
- } else {
- i = 0;
- while (i < n) {
- c = pt_table[bitbuf >> (16 - 8)];
- if (c >= NT) {
- unsigned short mask = 1 << (16 - 9);
- do {
- if (bitbuf & mask)
- c = right[c];
- else
- c = left[c];
- mask >>= 1;
- } while (c >= NT);
- }
- fillbuf(pt_len[c]);
- if (c <= 2) {
- if (c == 0)
- c = 1;
- else if (c == 1)
- c = getbits(4) + 3;
- else
- c = getbits(CBIT) + 20;
- while (--c >= 0)
- c_len[i++] = 0;
- }
- else
- c_len[i++] = c - 2;
- }
- while (i < NC)
- c_len[i++] = 0;
- make_table(NC, c_len, 12, c_table);
- }
+ short i, c, n;
+
+ n = getbits(CBIT);
+ if (n == 0) {
+ c = getbits(CBIT);
+ for (i = 0; i < NC; i++)
+ c_len[i] = 0;
+ for (i = 0; i < 4096; i++)
+ c_table[i] = c;
+ } else {
+ i = 0;
+ while (i < n) {
+ c = pt_table[bitbuf >> (16 - 8)];
+ if (c >= NT) {
+ unsigned short mask = 1 << (16 - 9);
+ do {
+ if (bitbuf & mask)
+ c = right[c];
+ else
+ c = left[c];
+ mask >>= 1;
+ } while (c >= NT);
+ }
+ fillbuf(pt_len[c]);
+ if (c <= 2) {
+ if (c == 0)
+ c = 1;
+ else if (c == 1)
+ c = getbits(4) + 3;
+ else
+ c = getbits(CBIT) + 20;
+ while (--c >= 0)
+ c_len[i++] = 0;
+ }
+ else
+ c_len[i++] = c - 2;
+ }
+ while (i < NC)
+ c_len[i++] = 0;
+ make_table(NC, c_len, 12, c_table);
+ }
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_c_st1( /*void*/ )
{
- unsigned short j, mask;
+ unsigned short j, mask;
- if (blocksize == 0) {
- blocksize = getbits(16);
- read_pt_len(NT, TBIT, 3);
- read_c_len();
- read_pt_len(np, pbit, -1);
- }
- blocksize--;
- j = c_table[bitbuf >> 4];
- if (j < NC)
- fillbuf(c_len[j]);
- else {
- fillbuf(12);
- mask = 1 << (16 - 1);
- do {
- if (bitbuf & mask)
- j = right[j];
- else
- j = left[j];
- mask >>= 1;
- } while (j >= NC);
- fillbuf(c_len[j] - 12);
- }
- return j;
+ if (blocksize == 0) {
+ blocksize = getbits(16);
+ read_pt_len(NT, TBIT, 3);
+ read_c_len();
+ read_pt_len(np, pbit, -1);
+ }
+ blocksize--;
+ j = c_table[bitbuf >> 4];
+ if (j < NC)
+ fillbuf(c_len[j]);
+ else {
+ fillbuf(12);
+ mask = 1 << (16 - 1);
+ do {
+ if (bitbuf & mask)
+ j = right[j];
+ else
+ j = left[j];
+ mask >>= 1;
+ } while (j >= NC);
+ fillbuf(c_len[j] - 12);
+ }
+ return j;
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_p_st1( /* void */ )
{
- unsigned short j, mask;
-
- j = pt_table[bitbuf >> (16 - 8)];
- if (j < np)
- fillbuf(pt_len[j]);
- else {
- fillbuf(8);
- mask = 1 << (16 - 1);
- do {
- if (bitbuf & mask)
- j = right[j];
- else
- j = left[j];
- mask >>= 1;
- } while (j >= np);
- fillbuf(pt_len[j] - 8);
- }
- if (j != 0)
- j = (1 << (j - 1)) + getbits(j - 1);
- return j;
+ unsigned short j, mask;
+
+ j = pt_table[bitbuf >> (16 - 8)];
+ if (j < np)
+ fillbuf(pt_len[j]);
+ else {
+ fillbuf(8);
+ mask = 1 << (16 - 1);
+ do {
+ if (bitbuf & mask)
+ j = right[j];
+ else
+ j = left[j];
+ mask >>= 1;
+ } while (j >= np);
+ fillbuf(pt_len[j] - 8);
+ }
+ if (j != 0)
+ j = (1 << (j - 1)) + getbits(j - 1);
+ return j;
}
/* ------------------------------------------------------------------------ */
assert(0);
}
- init_getbits();
+ init_getbits();
init_code_cache();
- blocksize = 0;
+ blocksize = 0;
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* larc.c -- extra *.lzs */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* larc.c -- extra *.lzs */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
unsigned short
decode_c_lzs( /*void*/ )
{
- if (getbits(1)) {
- return getbits(8);
- }
- else {
- matchpos = getbits(11);
- return getbits(4) + 0x100;
- }
+ if (getbits(1)) {
+ return getbits(8);
+ }
+ else {
+ matchpos = getbits(11);
+ return getbits(4) + 0x100;
+ }
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_p_lzs( /*void*/ )
{
- return (loc - matchpos - MAGIC0) & 0x7ff;
+ return (loc - matchpos - MAGIC0) & 0x7ff;
}
/* ------------------------------------------------------------------------ */
void
decode_start_lzs( /*void*/ )
{
- init_getbits();
+ init_getbits();
init_code_cache();
}
unsigned short
decode_c_lz5( /*void*/ )
{
- int c;
+ int c;
- if (flagcnt == 0) {
- flagcnt = 8;
- flag = getc(infile);
- }
- flagcnt--;
- c = getc(infile);
- if ((flag & 1) == 0) {
- matchpos = c;
- c = getc(infile);
- matchpos += (c & 0xf0) << 4;
- c &= 0x0f;
- c += 0x100;
- }
- flag >>= 1;
- return c;
+ if (flagcnt == 0) {
+ flagcnt = 8;
+ flag = getc(infile);
+ }
+ flagcnt--;
+ c = getc(infile);
+ if ((flag & 1) == 0) {
+ matchpos = c;
+ c = getc(infile);
+ matchpos += (c & 0xf0) << 4;
+ c &= 0x0f;
+ c += 0x100;
+ }
+ flag >>= 1;
+ return c;
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_p_lz5( /*void*/ )
{
- return (loc - matchpos - MAGIC5) & 0xfff;
+ return (loc - matchpos - MAGIC5) & 0xfff;
}
/* ------------------------------------------------------------------------ */
void
decode_start_lz5( /*void*/ )
{
- int i;
+ int i;
- flagcnt = 0;
- for (i = 0; i < 256; i++)
- memset(&text[i * 13 + 18], i, 13);
- for (i = 0; i < 256; i++)
- text[256 * 13 + 18 + i] = i;
- for (i = 0; i < 256; i++)
- text[256 * 13 + 256 + 18 + i] = 255 - i;
- memset(&text[256 * 13 + 512 + 18], 0, 128);
- memset(&text[256 * 13 + 512 + 128 + 18], ' ', 128 - 18);
+ flagcnt = 0;
+ for (i = 0; i < 256; i++)
+ memset(&text[i * 13 + 18], i, 13);
+ for (i = 0; i < 256; i++)
+ text[256 * 13 + 18 + i] = i;
+ for (i = 0; i < 256; i++)
+ text[256 * 13 + 256 + 18 + i] = 255 - i;
+ memset(&text[256 * 13 + 512 + 18], 0, 128);
+ memset(&text[256 * 13 + 512 + 128 + 18], ' ', 128 - 18);
}
-/* Local Variables: */
-/* tab-width : 4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX Archiver Driver */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14i Modified and bug fixed 2000.10.06 t.okamoto */
+/* LHa for UNIX Archiver Driver */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14i Modified and bug fixed 2000.10.06 t.okamoto */
/* ------------------------------------------------------------------------ */
/*
- Included...
- lharc.h interface.h slidehuf.h
+ Included...
+ lharc.h interface.h slidehuf.h
*/
#ifdef HAVE_CONFIG_H
#endif
#if HAVE_STRCASECMP
-#define strucmp(p,q) strcasecmp((p),(q))
+#define strucmp(p,q) strcasecmp((p),(q))
#endif
#if STDC_HEADERS
# if HAVE_NDIR_H
# include <ndir.h>
# endif
-# ifdef NONSYSTEM_DIR_LIBRARY /* no use ?? */
+# ifdef NONSYSTEM_DIR_LIBRARY /* no use ?? */
# include "lhdir.h"
# endif
#endif
#ifndef SEEK_SET
-#define SEEK_SET 0
-#define SEEK_CUR 1
-#define SEEK_END 2
-#endif /* SEEK_SET */
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif /* SEEK_SET */
#if HAVE_LIMITS_H
#include <limits.h>
struct encode_option {
#if defined(__STDC__) || defined(AIX)
- void (*output) ();
- void (*encode_start) ();
- void (*encode_end) ();
+ void (*output) ();
+ void (*encode_start) ();
+ void (*encode_end) ();
#else
- int (*output) ();
- int (*encode_start) ();
- int (*encode_end) ();
+ int (*output) ();
+ int (*encode_start) ();
+ int (*encode_end) ();
#endif
};
struct decode_option {
- unsigned short (*decode_c) ();
- unsigned short (*decode_p) ();
+ unsigned short (*decode_c) ();
+ unsigned short (*decode_p) ();
#if defined(__STDC__) || defined(AIX)
- void (*decode_start) ();
+ void (*decode_start) ();
#else
- int (*decode_start) ();
+ int (*decode_start) ();
#endif
};
/* ------------------------------------------------------------------------ */
-/* LHa File Type Definition */
+/* LHa File Type Definition */
/* ------------------------------------------------------------------------ */
typedef int boolean; /* TRUE or FALSE */
struct string_pool {
- int used;
- int size;
- int n;
- char *buffer;
+ int used;
+ int size;
+ int n;
+ char *buffer;
};
typedef struct LzHeader {
- long header_size;
+ long header_size;
int size_field_length;
- char method[METHOD_TYPE_STORAGE];
- long packed_size;
- long original_size;
- unsigned char attribute;
- unsigned char header_level;
- char name[FILENAME_LENGTH];
+ char method[METHOD_TYPE_STORAGE];
+ long packed_size;
+ long original_size;
+ unsigned char attribute;
+ unsigned char header_level;
+ char name[FILENAME_LENGTH];
char realname[FILENAME_LENGTH];/* real name for symbolic link */
- unsigned int crc; /* file CRC */
- boolean has_crc; /* file CRC */
+ unsigned int crc; /* file CRC */
+ boolean has_crc; /* file CRC */
unsigned int header_crc; /* header CRC */
- unsigned char extend_type;
- unsigned char minor_version;
-
- /* extend_type == EXTEND_UNIX and convert from other type. */
- time_t unix_last_modified_stamp;
- unsigned short unix_mode;
- unsigned short unix_uid;
- unsigned short unix_gid;
+ unsigned char extend_type;
+ unsigned char minor_version;
+
+ /* extend_type == EXTEND_UNIX and convert from other type. */
+ time_t unix_last_modified_stamp;
+ unsigned short unix_mode;
+ unsigned short unix_uid;
+ unsigned short unix_gid;
char user[256];
char group[256];
} LzHeader;
struct interfacing {
- FILE *infile;
- FILE *outfile;
- unsigned long original;
- unsigned long packed;
- int dicbit;
- int method;
+ FILE *infile;
+ FILE *outfile;
+ unsigned long original;
+ unsigned long packed;
+ int dicbit;
+ int method;
};
/* ------------------------------------------------------------------------ */
-/* Option switch variable */
+/* Option switch variable */
/* ------------------------------------------------------------------------ */
#ifdef LHA_MAIN_SRC
#define EXTERN
EXTERN boolean quiet;
EXTERN boolean text_mode;
EXTERN boolean verbose;
-EXTERN boolean noexec; /* debugging option */
+EXTERN boolean noexec; /* debugging option */
EXTERN boolean force;
EXTERN boolean prof;
EXTERN boolean delete_after_append;
-EXTERN int compress_method;
-EXTERN int header_level;
-/* EXTERN int quiet_mode; */ /* 1996.8.13 t.okamoto */
+EXTERN int compress_method;
+EXTERN int header_level;
+/* EXTERN int quiet_mode; */ /* 1996.8.13 t.okamoto */
#ifdef EUC
-EXTERN boolean euc_mode;
+EXTERN boolean euc_mode;
#endif
/* list command flags */
EXTERN boolean update_if_newer;
EXTERN boolean generic_format;
-EXTERN boolean remove_temporary_at_error;
-EXTERN boolean recover_archive_when_interrupt;
-EXTERN boolean remove_extracting_file_when_interrupt;
-EXTERN boolean get_filename_from_stdin;
-EXTERN boolean ignore_directory;
-EXTERN boolean verify_mode;
+EXTERN boolean remove_temporary_at_error;
+EXTERN boolean recover_archive_when_interrupt;
+EXTERN boolean remove_extracting_file_when_interrupt;
+EXTERN boolean get_filename_from_stdin;
+EXTERN boolean ignore_directory;
+EXTERN boolean verify_mode;
/* Indicator flag */
-EXTERN int quiet_mode;
+EXTERN int quiet_mode;
EXTERN boolean backup_old_archive;
/* ------------------------------------------------------------------------ */
-/* Globale Variable */
+/* Globale Variable */
/* ------------------------------------------------------------------------ */
-EXTERN char **cmd_filev;
+EXTERN char **cmd_filev;
EXTERN int cmd_filec;
-EXTERN char *archive_name;
+EXTERN char *archive_name;
EXTERN char temporary_name[FILENAME_LENGTH];
EXTERN char backup_archive_name[FILENAME_LENGTH];
-EXTERN char *extract_directory;
-EXTERN char *reading_filename, *writing_filename;
+EXTERN char *extract_directory;
+EXTERN char *reading_filename, *writing_filename;
EXTERN int archive_file_mode;
EXTERN int archive_file_gid;
-EXTERN struct interfacing interface;
+EXTERN struct interfacing interface;
EXTERN int noconvertcase; /* 2000.10.6 */
EXTERN unsigned short dicbit;
EXTERN unsigned short maxmatch;
EXTERN unsigned long count;
-EXTERN unsigned long loc; /* short -> long .. Changed N.Watazaki */
+EXTERN unsigned long loc; /* short -> long .. Changed N.Watazaki */
EXTERN unsigned char *text;
-EXTERN int prev_char;
+EXTERN int prev_char;
/* huf.c */
#ifndef LHA_MAIN_SRC /* t.okamoto 96/2/20 */
/* append.c */
#ifdef NEED_INCREMENTAL_INDICATOR
-EXTERN long indicator_count;
-EXTERN long indicator_threshold;
+EXTERN long indicator_count;
+EXTERN long indicator_threshold;
#endif
/* bitio.c */
-EXTERN FILE *infile, *outfile;
+EXTERN FILE *infile, *outfile;
EXTERN unsigned short bitbuf;
/* crcio.c */
EXTERN int temporary_fd;
/* ------------------------------------------------------------------------ */
-/* Functions */
+/* Functions */
/* ------------------------------------------------------------------------ */
#include "prototypes.h"
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX Archiver Driver macro define */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14g modified 2000.05.06 T.OKAMOTO */
+/* LHa for UNIX Archiver Driver macro define */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14g modified 2000.05.06 T.OKAMOTO */
/* ------------------------------------------------------------------------ */
-#define FALSE 0
-#define TRUE 1
+#define FALSE 0
+#define TRUE 1
-#define FILENAME_LENGTH 1024
+#define FILENAME_LENGTH 1024
#if defined __MINGW32__
# define getuid() 0
#endif
/* ------------------------------------------------------------------------ */
-/* YOUR CUSTOMIZIES */
+/* YOUR CUSTOMIZIES */
/* ------------------------------------------------------------------------ */
#ifndef ARCHIVENAME_EXTENTION
-#define ARCHIVENAME_EXTENTION ".lzh"
+#define ARCHIVENAME_EXTENTION ".lzh"
#endif
#ifndef BACKUPNAME_EXTENTION
-#define BACKUPNAME_EXTENTION ".bak"
+#define BACKUPNAME_EXTENTION ".bak"
#endif
-#define SJIS_FIRST_P(c) \
- (((unsigned char)(c) >= 0x80 && (unsigned char)(c) < 0xa0) || \
+#define SJIS_FIRST_P(c) \
+ (((unsigned char)(c) >= 0x80 && (unsigned char)(c) < 0xa0) || \
((unsigned char)(c) >= 0xe0 && (unsigned char)(c) < 0xfd))
-#define SJIS_SECOND_P(c) \
- (((unsigned char)(c) >= 0x40 && (unsigned char)(c) < 0xfd) && \
+#define SJIS_SECOND_P(c) \
+ (((unsigned char)(c) >= 0x40 && (unsigned char)(c) < 0xfd) && \
(unsigned char)(c) != 0x7f)
#define X0201_KANA_P(c)\
- (0xa0 < (unsigned char)(c) && (unsigned char)(c) < 0xe0)
+ (0xa0 < (unsigned char)(c) && (unsigned char)(c) < 0xe0)
/* for filename conversion */
#define NONE 0
#define TO_UPPER 2
/* ------------------------------------------------------------------------ */
-/* LHa File Definitions */
+/* LHa File Definitions */
/* ------------------------------------------------------------------------ */
#ifdef S_IFLNK
#define GETSTAT lstat
#define GETSTAT stat
#endif
-#define LZHUFF0_METHOD "-lh0-"
-#define LZHUFF1_METHOD "-lh1-"
-#define LZHUFF2_METHOD "-lh2-"
-#define LZHUFF3_METHOD "-lh3-"
-#define LZHUFF4_METHOD "-lh4-"
-#define LZHUFF5_METHOD "-lh5-"
-#define LZHUFF6_METHOD "-lh6-"
-#define LZHUFF7_METHOD "-lh7-"
-#define LARC_METHOD "-lzs-"
-#define LARC5_METHOD "-lz5-"
-#define LARC4_METHOD "-lz4-"
-#define LZHDIRS_METHOD "-lhd-"
-
-#define METHOD_TYPE_STORAGE 5
+#define LZHUFF0_METHOD "-lh0-"
+#define LZHUFF1_METHOD "-lh1-"
+#define LZHUFF2_METHOD "-lh2-"
+#define LZHUFF3_METHOD "-lh3-"
+#define LZHUFF4_METHOD "-lh4-"
+#define LZHUFF5_METHOD "-lh5-"
+#define LZHUFF6_METHOD "-lh6-"
+#define LZHUFF7_METHOD "-lh7-"
+#define LARC_METHOD "-lzs-"
+#define LARC5_METHOD "-lz5-"
+#define LARC4_METHOD "-lz4-"
+#define LZHDIRS_METHOD "-lhd-"
+
+#define METHOD_TYPE_STORAGE 5
/* Added N.Watazaki ..V */
-#define LZHUFF0_METHOD_NUM 0
-#define LZHUFF1_METHOD_NUM 1
-#define LZHUFF2_METHOD_NUM 2
-#define LZHUFF3_METHOD_NUM 3
-#define LZHUFF4_METHOD_NUM 4
-#define LZHUFF5_METHOD_NUM 5
-#define LZHUFF6_METHOD_NUM 6
-#define LZHUFF7_METHOD_NUM 7
-#define LARC_METHOD_NUM 8
-#define LARC5_METHOD_NUM 9
-#define LARC4_METHOD_NUM 10
-#define LZHDIRS_METHOD_NUM 11
+#define LZHUFF0_METHOD_NUM 0
+#define LZHUFF1_METHOD_NUM 1
+#define LZHUFF2_METHOD_NUM 2
+#define LZHUFF3_METHOD_NUM 3
+#define LZHUFF4_METHOD_NUM 4
+#define LZHUFF5_METHOD_NUM 5
+#define LZHUFF6_METHOD_NUM 6
+#define LZHUFF7_METHOD_NUM 7
+#define LARC_METHOD_NUM 8
+#define LARC5_METHOD_NUM 9
+#define LARC4_METHOD_NUM 10
+#define LZHDIRS_METHOD_NUM 11
/* Added N.Watazaki ..^ */
#define LZHUFF0_DICBIT 0 /* no compress */
#define LARC4_DICBIT 0 /* no compress */
#ifdef SUPPORT_LH7
-#define MAX_DICBIT LZHUFF7_DICBIT /* lh7 use 16bits */
+#define MAX_DICBIT LZHUFF7_DICBIT /* lh7 use 16bits */
#endif
#ifndef SUPPORT_LH7
-#define MAX_DICBIT LZHUFF6_DICBIT /* lh6 use 15bits */
+#define MAX_DICBIT LZHUFF6_DICBIT /* lh6 use 15bits */
#endif
-#define MAX_DICSIZ (1L << MAX_DICBIT)
-
-#define EXTEND_GENERIC 0
-#define EXTEND_UNIX 'U'
-#define EXTEND_MSDOS 'M'
-#define EXTEND_MACOS 'm'
-#define EXTEND_OS9 '9'
-#define EXTEND_OS2 '2'
-#define EXTEND_OS68K 'K'
-#define EXTEND_OS386 '3' /* OS-9000??? */
-#define EXTEND_HUMAN 'H'
-#define EXTEND_CPM 'C'
-#define EXTEND_FLEX 'F'
-#define EXTEND_RUNSER 'R'
+#define MAX_DICSIZ (1L << MAX_DICBIT)
+
+#define EXTEND_GENERIC 0
+#define EXTEND_UNIX 'U'
+#define EXTEND_MSDOS 'M'
+#define EXTEND_MACOS 'm'
+#define EXTEND_OS9 '9'
+#define EXTEND_OS2 '2'
+#define EXTEND_OS68K 'K'
+#define EXTEND_OS386 '3' /* OS-9000??? */
+#define EXTEND_HUMAN 'H'
+#define EXTEND_CPM 'C'
+#define EXTEND_FLEX 'F'
+#define EXTEND_RUNSER 'R'
/* this OS type is not official */
-#define EXTEND_TOWNSOS 'T'
-#define EXTEND_XOSK 'X' /* OS-9 for X68000 (?) */
-#define EXTEND_JAVA 'J'
+#define EXTEND_TOWNSOS 'T'
+#define EXTEND_XOSK 'X' /* OS-9 for X68000 (?) */
+#define EXTEND_JAVA 'J'
/*---------------------------------------------------------------------------*/
-#define GENERIC_ATTRIBUTE 0x20
-#define GENERIC_DIRECTORY_ATTRIBUTE 0x10
-#define HEADER_LEVEL0 0x00
-#define HEADER_LEVEL1 0x01
-#define HEADER_LEVEL2 0x02
+#define GENERIC_ATTRIBUTE 0x20
+#define GENERIC_DIRECTORY_ATTRIBUTE 0x10
+#define HEADER_LEVEL0 0x00
+#define HEADER_LEVEL1 0x01
+#define HEADER_LEVEL2 0x02
-#define CURRENT_UNIX_MINOR_VERSION 0x00
+#define CURRENT_UNIX_MINOR_VERSION 0x00
#define LHA_PATHSEP 0xff /* path separator of the
filename in lha header.
`unsigned char' or `int',
that is not '\xff', but 0xff. */
-#define OSK_RW_RW_RW 0000033
-#define OSK_FILE_REGULAR 0000000
-#define OSK_DIRECTORY_PERM 0000200
-#define OSK_SHARED_PERM 0000100
-#define OSK_OTHER_EXEC_PERM 0000040
-#define OSK_OTHER_WRITE_PERM 0000020
-#define OSK_OTHER_READ_PERM 0000010
-#define OSK_OWNER_EXEC_PERM 0000004
-#define OSK_OWNER_WRITE_PERM 0000002
-#define OSK_OWNER_READ_PERM 0000001
-
-#define UNIX_FILE_TYPEMASK 0170000
-#define UNIX_FILE_REGULAR 0100000
-#define UNIX_FILE_DIRECTORY 0040000
-#define UNIX_FILE_SYMLINK 0120000
-#define UNIX_SETUID 0004000
-#define UNIX_SETGID 0002000
-#define UNIX_STICKYBIT 0001000
-#define UNIX_OWNER_READ_PERM 0000400
-#define UNIX_OWNER_WRITE_PERM 0000200
-#define UNIX_OWNER_EXEC_PERM 0000100
-#define UNIX_GROUP_READ_PERM 0000040
-#define UNIX_GROUP_WRITE_PERM 0000020
-#define UNIX_GROUP_EXEC_PERM 0000010
-#define UNIX_OTHER_READ_PERM 0000004
-#define UNIX_OTHER_WRITE_PERM 0000002
-#define UNIX_OTHER_EXEC_PERM 0000001
-#define UNIX_RW_RW_RW 0000666
-
-#define LZHEADER_STORAGE 4096
-
-#define MAX_INDICATOR_COUNT 64
+#define OSK_RW_RW_RW 0000033
+#define OSK_FILE_REGULAR 0000000
+#define OSK_DIRECTORY_PERM 0000200
+#define OSK_SHARED_PERM 0000100
+#define OSK_OTHER_EXEC_PERM 0000040
+#define OSK_OTHER_WRITE_PERM 0000020
+#define OSK_OTHER_READ_PERM 0000010
+#define OSK_OWNER_EXEC_PERM 0000004
+#define OSK_OWNER_WRITE_PERM 0000002
+#define OSK_OWNER_READ_PERM 0000001
+
+#define UNIX_FILE_TYPEMASK 0170000
+#define UNIX_FILE_REGULAR 0100000
+#define UNIX_FILE_DIRECTORY 0040000
+#define UNIX_FILE_SYMLINK 0120000
+#define UNIX_SETUID 0004000
+#define UNIX_SETGID 0002000
+#define UNIX_STICKYBIT 0001000
+#define UNIX_OWNER_READ_PERM 0000400
+#define UNIX_OWNER_WRITE_PERM 0000200
+#define UNIX_OWNER_EXEC_PERM 0000100
+#define UNIX_GROUP_READ_PERM 0000040
+#define UNIX_GROUP_WRITE_PERM 0000020
+#define UNIX_GROUP_EXEC_PERM 0000010
+#define UNIX_OTHER_READ_PERM 0000004
+#define UNIX_OTHER_WRITE_PERM 0000002
+#define UNIX_OTHER_EXEC_PERM 0000001
+#define UNIX_RW_RW_RW 0000666
+
+#define LZHEADER_STORAGE 4096
+
+#define MAX_INDICATOR_COUNT 64
/* ------------------------------------------------------------------------ */
-/* FILE Attribute */
+/* FILE Attribute */
/* ------------------------------------------------------------------------ */
-#define is_directory(statp) (((statp)->st_mode & S_IFMT) == S_IFDIR)
-#define is_symlink(statp) (((statp)->st_mode & S_IFMT) == S_IFLNK)
-#define is_regularfile(statp) (((statp)->st_mode & S_IFMT) == S_IFREG)
+#define is_directory(statp) (((statp)->st_mode & S_IFMT) == S_IFDIR)
+#define is_symlink(statp) (((statp)->st_mode & S_IFMT) == S_IFLNK)
+#define is_regularfile(statp) (((statp)->st_mode & S_IFMT) == S_IFREG)
#if 1 /* assume that fopen() will accepts "b" as binary mode on all system. */
-#define WRITE_BINARY "wb"
-#define READ_BINARY "rb"
+#define WRITE_BINARY "wb"
+#define READ_BINARY "rb"
#else
-#define WRITE_BINARY "w"
-#define READ_BINARY "r"
+#define WRITE_BINARY "w"
+#define READ_BINARY "r"
#endif
/* ------------------------------------------------------------------------ */
-/* Individual macro define */
+/* Individual macro define */
/* ------------------------------------------------------------------------ */
/* from crcio.c */
-#define CRCPOLY 0xA001 /* CRC-16 (x^16+x^15+x^2+1) */
+#define CRCPOLY 0xA001 /* CRC-16 (x^16+x^15+x^2+1) */
#define INITIALIZE_CRC(crc) ((crc) = 0)
#define UPDATE_CRC(crc, c) \
(crctable[((crc) ^ (c)) & 0xFF] ^ ((crc) >> CHAR_BIT))
#define ROOT_P TREESIZE_C
/* huf.c */
-#define NP (MAX_DICBIT + 1)
-#define NT (USHRT_BIT + 3)
+#define NP (MAX_DICBIT + 1)
+#define NT (USHRT_BIT + 3)
#if 0
-#define PBIT 4 /* smallest integer such that (1 << PBIT) > * NP */
-#define TBIT 5 /* smallest integer such that (1 << TBIT) > * NT */
+#define PBIT 4 /* smallest integer such that (1 << PBIT) > * NP */
+#define TBIT 5 /* smallest integer such that (1 << TBIT) > * NT */
#endif
-#define PBIT 5 /* smallest integer such that (1 << PBIT) > * NP */
-#define TBIT 5 /* smallest integer such that (1 << TBIT) > * NT */
+#define PBIT 5 /* smallest integer such that (1 << PBIT) > * NP */
+#define TBIT 5 /* smallest integer such that (1 << TBIT) > * NT */
-#define NC (UCHAR_MAX + MAXMATCH + 2 - THRESHOLD)
+#define NC (UCHAR_MAX + MAXMATCH + 2 - THRESHOLD)
-/* #if NT > NP #define NPT NT #else #define NPT NP #endif */
-#define NPT 0x80
+/* #if NT > NP #define NPT NT #else #define NPT NP #endif */
+#define NPT 0x80
/* larc.c */
-#define MAGIC0 18
-#define MAGIC5 19
+#define MAGIC0 18
+#define MAGIC5 19
/* lharc.c */
-#define CMD_UNKNOWN 0
-#define CMD_EXTRACT 1
-#define CMD_ADD 2
-#define CMD_LIST 3
-#define CMD_DELETE 4
+#define CMD_UNKNOWN 0
+#define CMD_EXTRACT 1
+#define CMD_ADD 2
+#define CMD_LIST 3
+#define CMD_DELETE 4
-#define STREQU(a,b) (((a)[0] == (b)[0]) ? (strcmp ((a),(b)) == 0) : FALSE)
+#define STREQU(a,b) (((a)[0] == (b)[0]) ? (strcmp ((a),(b)) == 0) : FALSE)
/* shuf.c */
-#define N1 286 /* alphabet size */
-#define N2 (2 * N1 - 1) /* # of nodes in Huffman tree */
-#define EXTRABITS 8 /* >= log2(F-THRESHOLD+258-N1) */
-#define BUFBITS 16 /* >= log2(MAXBUF) */
-#define LENFIELD 4 /* bit size of length field for tree output */
+#define N1 286 /* alphabet size */
+#define N2 (2 * N1 - 1) /* # of nodes in Huffman tree */
+#define EXTRABITS 8 /* >= log2(F-THRESHOLD+258-N1) */
+#define BUFBITS 16 /* >= log2(MAXBUF) */
+#define LENFIELD 4 /* bit size of length field for tree output */
/* util.c */
-#define BUFFERSIZE 2048
+#define BUFFERSIZE 2048
/* slide.c */
/*
*/
/* slide.c */
-#define MATCHBIT 8 /* bits for MAXMATCH - THRESHOLD */
-#define MAXMATCH 256 /* formerly F (not more than UCHAR_MAX + 1) */
-#define THRESHOLD 3 /* choose optimal value */
+#define MATCHBIT 8 /* bits for MAXMATCH - THRESHOLD */
+#define MAXMATCH 256 /* formerly F (not more than UCHAR_MAX + 1) */
+#define THRESHOLD 3 /* choose optimal value */
/* from huf.c */
/* alphabet = {0, 1, 2, ..., NC - 1} */
-#define CBIT 9 /* $\lfloor \log_2 NC \rfloor + 1$ */
-#define USHRT_BIT 16 /* (CHAR_BIT * sizeof(ushort)) */
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
+#define CBIT 9 /* $\lfloor \log_2 NC \rfloor + 1$ */
+#define USHRT_BIT 16 /* (CHAR_BIT * sizeof(ushort)) */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* lhadd.c -- LHarc Add Command */
-/* */
-/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* lhadd.c -- LHarc Add Command */
+/* */
+/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */
static void
add_one(fp, nafp, hdr)
- FILE *fp, *nafp;
- LzHeader *hdr;
+ FILE *fp, *nafp;
+ LzHeader *hdr;
{
- long header_pos, next_pos, org_pos, data_pos;
- long v_original_size, v_packed_size;
+ long header_pos, next_pos, org_pos, data_pos;
+ long v_original_size, v_packed_size;
- reading_filename = hdr->name;
- writing_filename = temporary_name;
+ reading_filename = hdr->name;
+ writing_filename = temporary_name;
- if (!fp && generic_format) /* [generic] doesn't need directory info. */
- return;
- header_pos = ftell(nafp);
- write_header(nafp, hdr);/* DUMMY */
+ if (!fp && generic_format) /* [generic] doesn't need directory info. */
+ return;
+ header_pos = ftell(nafp);
+ write_header(nafp, hdr);/* DUMMY */
- if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
- if (!quiet)
- printf("%s -> %s\t- Symbolic Link\n", hdr->realname, hdr->name);
- }
+ if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
+ if (!quiet)
+ printf("%s -> %s\t- Symbolic Link\n", hdr->realname, hdr->name);
+ }
- if (hdr->original_size == 0) { /* empty file or directory */
+ if (hdr->original_size == 0) { /* empty file or directory */
finish_indicator2(hdr->name, "Frozen", 0);
- return; /* previous write_header is not DUMMY. (^_^) */
- }
- org_pos = ftell(fp);
- data_pos = ftell(nafp);
-
- hdr->crc = encode_lzhuf(fp, nafp, hdr->original_size,
- &v_original_size, &v_packed_size, hdr->name, hdr->method);
-
- if (v_packed_size < v_original_size) {
- next_pos = ftell(nafp);
- }
- else { /* retry by stored method */
- fseek(fp, org_pos, SEEK_SET);
- fseek(nafp, data_pos, SEEK_SET);
- hdr->crc = encode_stored_crc(fp, nafp, hdr->original_size,
- &v_original_size, &v_packed_size);
- fflush(nafp);
- next_pos = ftell(nafp);
+ return; /* previous write_header is not DUMMY. (^_^) */
+ }
+ org_pos = ftell(fp);
+ data_pos = ftell(nafp);
+
+ hdr->crc = encode_lzhuf(fp, nafp, hdr->original_size,
+ &v_original_size, &v_packed_size, hdr->name, hdr->method);
+
+ if (v_packed_size < v_original_size) {
+ next_pos = ftell(nafp);
+ }
+ else { /* retry by stored method */
+ fseek(fp, org_pos, SEEK_SET);
+ fseek(nafp, data_pos, SEEK_SET);
+ hdr->crc = encode_stored_crc(fp, nafp, hdr->original_size,
+ &v_original_size, &v_packed_size);
+ fflush(nafp);
+ next_pos = ftell(nafp);
#if HAVE_FTRUNCATE
- if (ftruncate(fileno(nafp), next_pos) == -1)
+ if (ftruncate(fileno(nafp), next_pos) == -1)
error("cannot truncate archive");
#elif HAVE_CHSIZE
if (chsize(fileno(nafp), next_pos) == -1)
#else
CAUSE COMPILE ERROR
#endif
- memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STORAGE);
- }
- hdr->original_size = v_original_size;
- hdr->packed_size = v_packed_size;
- fseek(nafp, header_pos, SEEK_SET);
- write_header(nafp, hdr);
- fseek(nafp, next_pos, SEEK_SET);
+ memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STORAGE);
+ }
+ hdr->original_size = v_original_size;
+ hdr->packed_size = v_packed_size;
+ fseek(nafp, header_pos, SEEK_SET);
+ write_header(nafp, hdr);
+ fseek(nafp, next_pos, SEEK_SET);
}
/* ------------------------------------------------------------------------ */
FILE *
append_it(name, oafp, nafp)
- char *name;
- FILE *oafp, *nafp;
+ char *name;
+ FILE *oafp, *nafp;
{
- LzHeader ahdr, hdr;
- FILE *fp;
- long old_header;
- int cmp;
- int filec;
- char **filev;
- int i;
- struct stat stbuf;
-
- boolean directory, symlink;
-
- if (GETSTAT(name, &stbuf) < 0) {
- error("Cannot access file \"%s\"", name); /* See cleaning_files, Why? */
- return oafp;
- }
-
- directory = is_directory(&stbuf);
+ LzHeader ahdr, hdr;
+ FILE *fp;
+ long old_header;
+ int cmp;
+ int filec;
+ char **filev;
+ int i;
+ struct stat stbuf;
+
+ boolean directory, symlink;
+
+ if (GETSTAT(name, &stbuf) < 0) {
+ error("Cannot access file \"%s\"", name); /* See cleaning_files, Why? */
+ return oafp;
+ }
+
+ directory = is_directory(&stbuf);
#ifdef S_IFLNK
- symlink = is_symlink(&stbuf);
+ symlink = is_symlink(&stbuf);
#else
- symlink = 0;
+ symlink = 0;
#endif
- init_header(name, &stbuf, &hdr);
+ init_header(name, &stbuf, &hdr);
fp = NULL;
if (!directory && !symlink && !noexec) {
}
cmp = 0; /* avoid compiler warnings `uninitialized' */
- while (oafp) {
- old_header = ftell(oafp);
- if (!get_header(oafp, &ahdr)) {
+ while (oafp) {
+ old_header = ftell(oafp);
+ if (!get_header(oafp, &ahdr)) {
/* end of archive or error occurred */
- fclose(oafp);
- oafp = NULL;
- break;
- }
+ fclose(oafp);
+ oafp = NULL;
+ break;
+ }
cmp = strcmp(ahdr.name, hdr.name);
if (cmp < 0) { /* SKIP */
else
add_one(fp, nafp, &hdr);
}
- else { /* cmp == 0 */
+ else { /* cmp == 0 */
if (!update_if_newer ||
ahdr.unix_last_modified_stamp < hdr.unix_last_modified_stamp) {
/* newer than archive's */
if (fp) fclose(fp);
- if (directory) { /* recursive call */
- if (find_files(name, &filec, &filev)) {
- for (i = 0; i < filec; i++)
- oafp = append_it(filev[i], oafp, nafp);
- free_files(filec, filev);
- }
- }
- return oafp;
+ if (directory) { /* recursive call */
+ if (find_files(name, &filec, &filev)) {
+ for (i = 0; i < filec; i++)
+ oafp = append_it(filev[i], oafp, nafp);
+ free_files(filec, filev);
+ }
+ }
+ return oafp;
}
/* ------------------------------------------------------------------------ */
static void
find_update_files(oafp)
- FILE *oafp; /* old archive */
+ FILE *oafp; /* old archive */
{
- char name[FILENAME_LENGTH];
- struct string_pool sp;
- LzHeader hdr;
- long pos;
- struct stat stbuf;
- int len;
-
- pos = ftell(oafp);
-
- init_sp(&sp);
- while (get_header(oafp, &hdr)) {
- if ((hdr.unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_REGULAR) {
- if (stat(hdr.name, &stbuf) >= 0) /* exist ? */
- add_sp(&sp, hdr.name, strlen(hdr.name) + 1);
- }
- else if ((hdr.unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_DIRECTORY) {
- strcpy(name, hdr.name);
- len = strlen(name);
- if (len > 0 && name[len - 1] == '/')
- name[--len] = '\0'; /* strip tail '/' */
- if (stat(name, &stbuf) >= 0) /* exist ? */
- add_sp(&sp, name, len + 1);
- }
- fseek(oafp, hdr.packed_size, SEEK_CUR);
- }
-
- fseek(oafp, pos, SEEK_SET);
-
- finish_sp(&sp, &cmd_filec, &cmd_filev);
+ char name[FILENAME_LENGTH];
+ struct string_pool sp;
+ LzHeader hdr;
+ long pos;
+ struct stat stbuf;
+ int len;
+
+ pos = ftell(oafp);
+
+ init_sp(&sp);
+ while (get_header(oafp, &hdr)) {
+ if ((hdr.unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_REGULAR) {
+ if (stat(hdr.name, &stbuf) >= 0) /* exist ? */
+ add_sp(&sp, hdr.name, strlen(hdr.name) + 1);
+ }
+ else if ((hdr.unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_DIRECTORY) {
+ strcpy(name, hdr.name);
+ len = strlen(name);
+ if (len > 0 && name[len - 1] == '/')
+ name[--len] = '\0'; /* strip tail '/' */
+ if (stat(name, &stbuf) >= 0) /* exist ? */
+ add_sp(&sp, name, len + 1);
+ }
+ fseek(oafp, hdr.packed_size, SEEK_CUR);
+ }
+
+ fseek(oafp, pos, SEEK_SET);
+
+ finish_sp(&sp, &cmd_filec, &cmd_filev);
}
/* ------------------------------------------------------------------------ */
static void
delete(oafp, nafp)
- FILE *oafp, *nafp;
+ FILE *oafp, *nafp;
{
- LzHeader ahdr;
- long old_header_pos;
-
- old_header_pos = ftell(oafp);
- while (get_header(oafp, &ahdr)) {
- if (need_file(ahdr.name)) { /* skip */
- fseek(oafp, ahdr.packed_size, SEEK_CUR);
- if (noexec || !quiet) {
+ LzHeader ahdr;
+ long old_header_pos;
+
+ old_header_pos = ftell(oafp);
+ while (get_header(oafp, &ahdr)) {
+ if (need_file(ahdr.name)) { /* skip */
+ fseek(oafp, ahdr.packed_size, SEEK_CUR);
+ if (noexec || !quiet) {
if ((ahdr.unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK)
message("delete %s -> %s", ahdr.realname, ahdr.name);
- else
- message("delete %s", ahdr.name);
+ else
+ message("delete %s", ahdr.name);
+ }
+ }
+ else { /* copy */
+ if (noexec) {
+ fseek(oafp, ahdr.packed_size, SEEK_CUR);
}
- }
- else { /* copy */
- if (noexec) {
- fseek(oafp, ahdr.packed_size, SEEK_CUR);
- }
- else {
- fseek(oafp, old_header_pos, SEEK_SET);
- copy_old_one(oafp, nafp, &ahdr);
- }
- }
- old_header_pos = ftell(oafp);
- }
- return;
+ else {
+ fseek(oafp, old_header_pos, SEEK_SET);
+ copy_old_one(oafp, nafp, &ahdr);
+ }
+ }
+ old_header_pos = ftell(oafp);
+ }
+ return;
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
static FILE *
build_temporary_file()
build_backup_file()
{
- build_backup_name(backup_archive_name, archive_name);
- if (!noexec) {
- signal(SIGINT, SIG_IGN);
+ build_backup_name(backup_archive_name, archive_name);
+ if (!noexec) {
+ signal(SIGINT, SIG_IGN);
#ifdef SIGHUP
- signal(SIGHUP, SIG_IGN);
+ signal(SIGHUP, SIG_IGN);
#endif
- if (rename(archive_name, backup_archive_name) < 0) {
+ if (rename(archive_name, backup_archive_name) < 0) {
#if __MINGW32__
/* On MinGW, cannot rename when
newfile (backup_archive_name) already exists */
#endif
fatal_error("Cannot make backup file \"%s\"", archive_name);
}
- recover_archive_when_interrupt = TRUE;
- signal(SIGINT, interrupt);
+ recover_archive_when_interrupt = TRUE;
+ signal(SIGINT, interrupt);
#ifdef SIGHUP
- signal(SIGHUP, interrupt);
+ signal(SIGHUP, interrupt);
#endif
- }
+ }
}
/* ------------------------------------------------------------------------ */
static void
report_archive_name_if_different()
{
- if (!quiet && new_archive_name == new_archive_name_buffer) {
- /* warning at old archive is SFX */
- message("New archive file is \"%s\"", new_archive_name);
- }
+ if (!quiet && new_archive_name == new_archive_name_buffer) {
+ /* warning at old archive is SFX */
+ message("New archive file is \"%s\"", new_archive_name);
+ }
}
/* ------------------------------------------------------------------------ */
void
temporary_to_new_archive_file(new_archive_size)
- long new_archive_size;
+ long new_archive_size;
{
- FILE *oafp, *nafp;
+ FILE *oafp, *nafp;
- if (!strcmp(new_archive_name, "-")) {
- nafp = stdout;
- writing_filename = "starndard output";
+ if (!strcmp(new_archive_name, "-")) {
+ nafp = stdout;
+ writing_filename = "starndard output";
#if __MINGW32__
setmode(fileno(stdout), O_BINARY);
#endif
- }
- else {
+ }
+ else {
unlink(new_archive_name);
if (rename(temporary_name, new_archive_name) == 0)
return;
- nafp = xfopen(new_archive_name, WRITE_BINARY);
- writing_filename = archive_name;
- }
+ nafp = xfopen(new_archive_name, WRITE_BINARY);
+ writing_filename = archive_name;
+ }
- oafp = xfopen(temporary_name, READ_BINARY);
- reading_filename = temporary_name;
- copyfile(oafp, nafp, new_archive_size, 0, 0);
- if (nafp != stdout)
- fclose(nafp);
- fclose(oafp);
+ oafp = xfopen(temporary_name, READ_BINARY);
+ reading_filename = temporary_name;
+ copyfile(oafp, nafp, new_archive_size, 0, 0);
+ if (nafp != stdout)
+ fclose(nafp);
+ fclose(oafp);
- recover_archive_when_interrupt = FALSE;
- unlink(temporary_name);
+ recover_archive_when_interrupt = FALSE;
+ unlink(temporary_name);
- remove_temporary_at_error = FALSE;
+ remove_temporary_at_error = FALSE;
}
/* ------------------------------------------------------------------------ */
static void
set_archive_file_mode()
{
- int umask_value;
- struct stat stbuf;
-
- if (archive_file_gid < 0) {
- umask(umask_value = umask(0));
- archive_file_mode = (~umask_value) & 0666; /* rw-rw-rw- */
- if (stat(".", &stbuf) >= 0)
- archive_file_gid = stbuf.st_gid;
- }
- if (archive_file_gid >= 0)
- chown(new_archive_name, getuid(), archive_file_gid);
-
- chmod(new_archive_name, archive_file_mode);
+ int umask_value;
+ struct stat stbuf;
+
+ if (archive_file_gid < 0) {
+ umask(umask_value = umask(0));
+ archive_file_mode = (~umask_value) & 0666; /* rw-rw-rw- */
+ if (stat(".", &stbuf) >= 0)
+ archive_file_gid = stbuf.st_gid;
+ }
+ if (archive_file_gid >= 0)
+ chown(new_archive_name, getuid(), archive_file_gid);
+
+ chmod(new_archive_name, archive_file_mode);
}
/* ------------------------------------------------------------------------ */
-/* REMOVE FILE/DIRECTORY */
+/* REMOVE FILE/DIRECTORY */
/* ------------------------------------------------------------------------ */
static void
remove_one(name)
- char *name;
+ char *name;
{
- struct stat stbuf;
- int filec;
- char **filev;
-
- if (GETSTAT(name, &stbuf) < 0) {
- warning("Cannot access \"%s\": %s", name, strerror(errno));
- }
- else if (is_directory(&stbuf)) {
- if (find_files(name, &filec, &filev)) {
- remove_files(filec, filev);
- free_files(filec, filev);
- }
- else
- warning("Cannot open directory \"%s\"", name);
-
- if (noexec)
- message("REMOVE DIRECTORY %s", name);
- else if (rmdir(name) < 0)
- warning("Cannot remove directory \"%s\"", name);
- else if (verbose)
- message("Removed %s.", name);
- }
- else if (is_regularfile(&stbuf)) {
- if (noexec)
- message("REMOVE FILE %s.", name);
- else if (unlink(name) < 0)
- warning("Cannot remove \"%s\"", name);
- else if (verbose)
- message("Removed %s.", name);
- }
+ struct stat stbuf;
+ int filec;
+ char **filev;
+
+ if (GETSTAT(name, &stbuf) < 0) {
+ warning("Cannot access \"%s\": %s", name, strerror(errno));
+ }
+ else if (is_directory(&stbuf)) {
+ if (find_files(name, &filec, &filev)) {
+ remove_files(filec, filev);
+ free_files(filec, filev);
+ }
+ else
+ warning("Cannot open directory \"%s\"", name);
+
+ if (noexec)
+ message("REMOVE DIRECTORY %s", name);
+ else if (rmdir(name) < 0)
+ warning("Cannot remove directory \"%s\"", name);
+ else if (verbose)
+ message("Removed %s.", name);
+ }
+ else if (is_regularfile(&stbuf)) {
+ if (noexec)
+ message("REMOVE FILE %s.", name);
+ else if (unlink(name) < 0)
+ warning("Cannot remove \"%s\"", name);
+ else if (verbose)
+ message("Removed %s.", name);
+ }
#ifdef S_IFLNK
- else if (is_symlink(&stbuf)) {
- if (noexec)
- printf("REMOVE SYMBOLIC LINK %s.\n", name);
- else if (unlink(name) < 0)
- warning("Cannot remove", name);
- else if (verbose)
- message("Removed %s.", name);
- }
+ else if (is_symlink(&stbuf)) {
+ if (noexec)
+ printf("REMOVE SYMBOLIC LINK %s.\n", name);
+ else if (unlink(name) < 0)
+ warning("Cannot remove", name);
+ else if (verbose)
+ message("Removed %s.", name);
+ }
#endif
- else {
- error("Cannot remove file \"%s\" (not a file or directory)", name);
- }
+ else {
+ error("Cannot remove file \"%s\" (not a file or directory)", name);
+ }
}
static void
remove_files(filec, filev)
- int filec;
- char **filev;
+ int filec;
+ char **filev;
{
- int i;
+ int i;
- for (i = 0; i < filec; i++)
- remove_one(filev[i]);
+ for (i = 0; i < filec; i++)
+ remove_one(filev[i]);
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
void
cmd_add()
{
- LzHeader ahdr;
- FILE *oafp, *nafp;
- int i;
- long old_header;
- boolean old_archive_exist;
- long new_archive_size;
-
- /* exit if no operation */
- if (!update_if_newer && cmd_filec == 0) {
- error("No files given in argument, do nothing.");
+ LzHeader ahdr;
+ FILE *oafp, *nafp;
+ int i;
+ long old_header;
+ boolean old_archive_exist;
+ long new_archive_size;
+
+ /* exit if no operation */
+ if (!update_if_newer && cmd_filec == 0) {
+ error("No files given in argument, do nothing.");
exit(1);
- }
+ }
- /* open old archive if exist */
- if ((oafp = open_old_archive()) == NULL)
- old_archive_exist = FALSE;
- else
- old_archive_exist = TRUE;
+ /* open old archive if exist */
+ if ((oafp = open_old_archive()) == NULL)
+ old_archive_exist = FALSE;
+ else
+ old_archive_exist = TRUE;
- if (update_if_newer && cmd_filec == 0) {
+ if (update_if_newer && cmd_filec == 0) {
warning("No files given in argument");
if (!oafp) {
error("archive file \"%s\" does not exists.",
}
}
- if (new_archive && old_archive_exist) {
- fclose(oafp);
- oafp = NULL;
- }
+ if (new_archive && old_archive_exist) {
+ fclose(oafp);
+ oafp = NULL;
+ }
- if (oafp && archive_is_msdos_sfx1(archive_name)) {
- skip_msdos_sfx1_code(oafp);
- build_standard_archive_name(new_archive_name_buffer, archive_name);
- new_archive_name = new_archive_name_buffer;
- }
- else {
- new_archive_name = archive_name;
- }
+ if (oafp && archive_is_msdos_sfx1(archive_name)) {
+ skip_msdos_sfx1_code(oafp);
+ build_standard_archive_name(new_archive_name_buffer, archive_name);
+ new_archive_name = new_archive_name_buffer;
+ }
+ else {
+ new_archive_name = archive_name;
+ }
- /* build temporary file */
+ /* build temporary file */
nafp = NULL; /* avoid compiler warnings `uninitialized' */
- if (!noexec)
- nafp = build_temporary_file();
-
- /* find needed files when automatic update */
- if (update_if_newer && cmd_filec == 0)
- find_update_files(oafp);
-
- /* build new archive file */
- /* cleaning arguments */
- cleaning_files(&cmd_filec, &cmd_filev);
- if (cmd_filec == 0) {
- if (oafp)
- fclose(oafp);
- if (!noexec)
- fclose(nafp);
- return;
- }
-
- for (i = 0; i < cmd_filec; i++) {
+ if (!noexec)
+ nafp = build_temporary_file();
+
+ /* find needed files when automatic update */
+ if (update_if_newer && cmd_filec == 0)
+ find_update_files(oafp);
+
+ /* build new archive file */
+ /* cleaning arguments */
+ cleaning_files(&cmd_filec, &cmd_filev);
+ if (cmd_filec == 0) {
+ if (oafp)
+ fclose(oafp);
+ if (!noexec)
+ fclose(nafp);
+ return;
+ }
+
+ for (i = 0; i < cmd_filec; i++) {
if (strcmp(cmd_filev[i], archive_name) == 0) {
int j;
/* exclude target archive */
oafp = append_it(cmd_filev[i], oafp, nafp);
}
- if (oafp) {
- old_header = ftell(oafp);
- while (get_header(oafp, &ahdr)) {
- if (noexec)
- fseek(oafp, ahdr.packed_size, SEEK_CUR);
- else {
- fseek(oafp, old_header, SEEK_SET);
- copy_old_one(oafp, nafp, &ahdr);
- }
- old_header = ftell(oafp);
- }
- fclose(oafp);
- }
+ if (oafp) {
+ old_header = ftell(oafp);
+ while (get_header(oafp, &ahdr)) {
+ if (noexec)
+ fseek(oafp, ahdr.packed_size, SEEK_CUR);
+ else {
+ fseek(oafp, old_header, SEEK_SET);
+ copy_old_one(oafp, nafp, &ahdr);
+ }
+ old_header = ftell(oafp);
+ }
+ fclose(oafp);
+ }
new_archive_size = 0; /* avoid compiler warnings `uninitialized' */
- if (!noexec) {
- write_archive_tail(nafp);
- new_archive_size = ftell(nafp);
- fclose(nafp);
- }
+ if (!noexec) {
+ write_archive_tail(nafp);
+ new_archive_size = ftell(nafp);
+ fclose(nafp);
+ }
- /* build backup archive file */
- if (old_archive_exist && backup_old_archive)
- build_backup_file();
+ /* build backup archive file */
+ if (old_archive_exist && backup_old_archive)
+ build_backup_file();
- report_archive_name_if_different();
+ report_archive_name_if_different();
- /* copy temporary file to new archive file */
- if (!noexec && (!strcmp(new_archive_name, "-") ||
- rename(temporary_name, new_archive_name) < 0))
- temporary_to_new_archive_file(new_archive_size);
+ /* copy temporary file to new archive file */
+ if (!noexec && (!strcmp(new_archive_name, "-") ||
+ rename(temporary_name, new_archive_name) < 0))
+ temporary_to_new_archive_file(new_archive_size);
- /* set new archive file mode/group */
- set_archive_file_mode();
+ /* set new archive file mode/group */
+ set_archive_file_mode();
- /* remove archived files */
- if (delete_after_append)
- remove_files(cmd_filec, cmd_filev);
+ /* remove archived files */
+ if (delete_after_append)
+ remove_files(cmd_filec, cmd_filev);
- return;
+ return;
}
/* ------------------------------------------------------------------------ */
void
cmd_delete()
{
- FILE *oafp, *nafp;
- long new_archive_size;
-
- /* open old archive if exist */
- if ((oafp = open_old_archive()) == NULL)
- fatal_error("Cannot open archive file \"%s\"", archive_name);
-
- /* exit if no operation */
- if (cmd_filec == 0) {
- fclose(oafp);
- warning("No files given in argument, do nothing.");
- return;
- }
-
- if (archive_is_msdos_sfx1(archive_name)) {
- skip_msdos_sfx1_code(oafp);
- build_standard_archive_name(new_archive_name_buffer, archive_name);
- new_archive_name = new_archive_name_buffer;
- }
- else {
- new_archive_name = archive_name;
- }
-
- /* build temporary file */
+ FILE *oafp, *nafp;
+ long new_archive_size;
+
+ /* open old archive if exist */
+ if ((oafp = open_old_archive()) == NULL)
+ fatal_error("Cannot open archive file \"%s\"", archive_name);
+
+ /* exit if no operation */
+ if (cmd_filec == 0) {
+ fclose(oafp);
+ warning("No files given in argument, do nothing.");
+ return;
+ }
+
+ if (archive_is_msdos_sfx1(archive_name)) {
+ skip_msdos_sfx1_code(oafp);
+ build_standard_archive_name(new_archive_name_buffer, archive_name);
+ new_archive_name = new_archive_name_buffer;
+ }
+ else {
+ new_archive_name = archive_name;
+ }
+
+ /* build temporary file */
nafp = NULL; /* avoid compiler warnings `uninitialized' */
- if (!noexec)
- nafp = build_temporary_file();
+ if (!noexec)
+ nafp = build_temporary_file();
- /* build new archive file */
- delete(oafp, nafp);
- fclose(oafp);
+ /* build new archive file */
+ delete(oafp, nafp);
+ fclose(oafp);
new_archive_size = 0; /* avoid compiler warnings `uninitialized' */
- if (!noexec) {
- write_archive_tail(nafp);
- new_archive_size = ftell(nafp);
- fclose(nafp);
- }
+ if (!noexec) {
+ write_archive_tail(nafp);
+ new_archive_size = ftell(nafp);
+ fclose(nafp);
+ }
- /* build backup archive file */
+ /* build backup archive file */
if (backup_old_archive)
build_backup_file();
- /* 1999.5.24 t.oka */
- if(!noexec && new_archive_size <= 1){
- unlink(temporary_name);
+ /* 1999.5.24 t.oka */
+ if(!noexec && new_archive_size <= 1){
+ unlink(temporary_name);
if (!backup_old_archive)
unlink(archive_name);
- warning("The archive file \"%s\" was removed because it would be empty.", new_archive_name);
- return;
- }
+ warning("The archive file \"%s\" was removed because it would be empty.", new_archive_name);
+ return;
+ }
- report_archive_name_if_different();
+ report_archive_name_if_different();
- /* copy temporary file to new archive file */
- if (!noexec && rename(temporary_name, new_archive_name) < 0)
- temporary_to_new_archive_file(new_archive_size);
+ /* copy temporary file to new archive file */
+ if (!noexec && rename(temporary_name, new_archive_name) < 0)
+ temporary_to_new_archive_file(new_archive_size);
- /* set new archive file mode/group */
- set_archive_file_mode();
+ /* set new archive file mode/group */
+ set_archive_file_mode();
- return;
+ return;
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* compile-command:"gcc -c lhadd.c" */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* lharc.c -- append to archive */
-/* */
-/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
-/* Modified Nobutaka Watazaki */
-/* Thanks to H.Yoshizaki. (MS-DOS LHarc) */
-/* */
-/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
-/* Ver. 0.01 Alpha Version (for 4.2BSD) 1989.05.28 Y.Tagawa */
-/* Ver. 0.02 Alpha Version Rel.2 1989.05.29 Y.Tagawa */
-/* Ver. 0.03 Release #3 Beta Version 1989.07.02 Y.Tagawa */
-/* Ver. 0.03a Debug 1989.07.03 Y.Tagawa */
-/* Ver. 0.03b Modified 1989.07.13 Y.Tagawa */
-/* Ver. 0.03c Debug (Thanks to void@rena.dit.junet) */
-/* 1989.08.09 Y.Tagawa */
-/* Ver. 0.03d Modified (quiet and verbose) 1989.09.14 Y.Tagawa */
-/* V1.00 Fixed 1989.09.22 Y.Tagawa */
-/* V1.01 Bug Fixed 1989.12.25 Y.Tagawa */
-/* */
-/* DOS-Version Original LHx V C2.01 (C) H.Yohizaki */
-/* */
-/* V2.00 UNIX Lharc + DOS LHx -> OSK LHx 1990.11.01 Momozou */
-/* V2.01 Minor Modified 1990.11.24 Momozou */
-/* */
-/* Ver. 0.02 LHx for UNIX 1991.11.18 M.Oki */
-/* Ver. 0.03 LHa for UNIX 1991.12.17 M.Oki */
-/* Ver. 0.04 LHa for UNIX beta version 1992.01.20 M.Oki */
-/* Ver. 1.00 LHa for UNIX Fixed 1992.03.19 M.Oki */
-/* */
-/* Ver. 1.10 for Symbolic Link 1993.06.25 N.Watazaki */
-/* Ver. 1.11 for Symbolic Link Bug Fixed 1993.08.18 N.Watazaki */
-/* Ver. 1.12 for File Date Check 1993.10.28 N.Watazaki */
-/* Ver. 1.13 Bug Fixed (Idicator calcurate) 1994.02.21 N.Watazaki */
-/* Ver. 1.13a Bug Fixed (Sym. Link delete) 1994.03.11 N.Watazaki */
-/* Ver. 1.13b Bug Fixed (Sym. Link delete) 1994.07.29 N.Watazaki */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14b,c Bug Fixed 1996.03.07 t.okamoto */
+/* LHa for UNIX */
+/* lharc.c -- append to archive */
+/* */
+/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
+/* Modified Nobutaka Watazaki */
+/* Thanks to H.Yoshizaki. (MS-DOS LHarc) */
+/* */
+/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
+/* Ver. 0.01 Alpha Version (for 4.2BSD) 1989.05.28 Y.Tagawa */
+/* Ver. 0.02 Alpha Version Rel.2 1989.05.29 Y.Tagawa */
+/* Ver. 0.03 Release #3 Beta Version 1989.07.02 Y.Tagawa */
+/* Ver. 0.03a Debug 1989.07.03 Y.Tagawa */
+/* Ver. 0.03b Modified 1989.07.13 Y.Tagawa */
+/* Ver. 0.03c Debug (Thanks to void@rena.dit.junet) */
+/* 1989.08.09 Y.Tagawa */
+/* Ver. 0.03d Modified (quiet and verbose) 1989.09.14 Y.Tagawa */
+/* V1.00 Fixed 1989.09.22 Y.Tagawa */
+/* V1.01 Bug Fixed 1989.12.25 Y.Tagawa */
+/* */
+/* DOS-Version Original LHx V C2.01 (C) H.Yohizaki */
+/* */
+/* V2.00 UNIX Lharc + DOS LHx -> OSK LHx 1990.11.01 Momozou */
+/* V2.01 Minor Modified 1990.11.24 Momozou */
+/* */
+/* Ver. 0.02 LHx for UNIX 1991.11.18 M.Oki */
+/* Ver. 0.03 LHa for UNIX 1991.12.17 M.Oki */
+/* Ver. 0.04 LHa for UNIX beta version 1992.01.20 M.Oki */
+/* Ver. 1.00 LHa for UNIX Fixed 1992.03.19 M.Oki */
+/* */
+/* Ver. 1.10 for Symbolic Link 1993.06.25 N.Watazaki */
+/* Ver. 1.11 for Symbolic Link Bug Fixed 1993.08.18 N.Watazaki */
+/* Ver. 1.12 for File Date Check 1993.10.28 N.Watazaki */
+/* Ver. 1.13 Bug Fixed (Idicator calcurate) 1994.02.21 N.Watazaki */
+/* Ver. 1.13a Bug Fixed (Sym. Link delete) 1994.03.11 N.Watazaki */
+/* Ver. 1.13b Bug Fixed (Sym. Link delete) 1994.07.29 N.Watazaki */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14b,c Bug Fixed 1996.03.07 t.okamoto */
/* Ver. 1.14d Version up 1997.01.12 t.okamoto */
/* Ver. 1.14g Bug Fixed 2000.05.06 t.okamoto */
/* Ver. 1.14i Modified 2000.10.06 t.okamoto */
/* static functions */
static void sort_files();
-static void print_version();
+static void print_version();
/* ------------------------------------------------------------------------ */
static void
-init_variable() /* Added N.Watazaki */
+init_variable() /* Added N.Watazaki */
{
/* options */
- quiet = FALSE;
- text_mode = FALSE;
- verbose = 0;
- noexec = FALSE; /* debugging option */
- force = FALSE;
- prof = FALSE;
+ quiet = FALSE;
+ text_mode = FALSE;
+ verbose = 0;
+ noexec = FALSE; /* debugging option */
+ force = FALSE;
+ prof = FALSE;
- compress_method = DEFAULT_LZHUFF_METHOD; /* defined in config.h */
+ compress_method = DEFAULT_LZHUFF_METHOD; /* defined in config.h */
- header_level = HEADER_LEVEL2;
- quiet_mode = 0;
+ header_level = HEADER_LEVEL2;
+ quiet_mode = 0;
#ifdef EUC
- euc_mode = FALSE;
+ euc_mode = FALSE;
#endif
/* view command flags */
- verbose_listing = FALSE;
+ verbose_listing = FALSE;
/* extract command flags */
- output_to_stdout = FALSE;
+ output_to_stdout = FALSE;
/* append command flags */
- new_archive = FALSE;
- update_if_newer = FALSE;
- delete_after_append = FALSE;
- generic_format = FALSE;
+ new_archive = FALSE;
+ update_if_newer = FALSE;
+ delete_after_append = FALSE;
+ generic_format = FALSE;
- remove_temporary_at_error = FALSE;
- recover_archive_when_interrupt = FALSE;
- remove_extracting_file_when_interrupt = FALSE;
- get_filename_from_stdin = FALSE;
- ignore_directory = FALSE;
- verify_mode = FALSE;
+ remove_temporary_at_error = FALSE;
+ recover_archive_when_interrupt = FALSE;
+ remove_extracting_file_when_interrupt = FALSE;
+ get_filename_from_stdin = FALSE;
+ ignore_directory = FALSE;
+ verify_mode = FALSE;
- noconvertcase = FALSE;
+ noconvertcase = FALSE;
- extract_directory = NULL;
+ extract_directory = NULL;
temporary_fd = -1;
#if BACKUP_OLD_ARCHIVE
}
/* ------------------------------------------------------------------------ */
-/* NOTES : Text File Format */
-/* GENERATOR NewLine */
-/* [generic] 0D 0A */
-/* [MS-DOS] 0D 0A */
-/* [OS9][MacOS] 0D */
-/* [UNIX] 0A */
+/* NOTES : Text File Format */
+/* GENERATOR NewLine */
+/* [generic] 0D 0A */
+/* [MS-DOS] 0D 0A */
+/* [OS9][MacOS] 0D */
+/* [UNIX] 0A */
/* ------------------------------------------------------------------------ */
static void
print_tiny_usage()
{
- fprintf(stderr, "\
+ fprintf(stderr, "\
LHarc for UNIX V 1.02 Copyright(C) 1989 Y.Tagawa\n\
LHx for MSDOS V C2.01 Copyright(C) 1990 H.Yoshizaki\n\
LHx(arc) for OSK V 2.01 Modified 1990 Momozou\n\
Modified 2002 Hiroto Sakai\n\
Autoconfiscated 2001,2002 Koji Arai\n\
");
- fprintf(stderr, "\
+ fprintf(stderr, "\
usage: lha [-]{axelvudmcp[q[num]][vnfodizg012]}[w=<dir>] archive_file [file...]\n\
commands: options:\n\
a Add(or replace) to archive q{num} quiet (num:quiet mode)\n\
u Update newer files to archive f force (over write at extract)\n\
d Delete from archive t FILES are TEXT file\n");
#ifdef SUPPORT_LH7
- fprintf(stderr, "\
+ fprintf(stderr, "\
m Move to archive (means 'ad') o[567] compression method (a/u)\n\
");
#endif
#ifndef SUPPORT_LH7
- fprintf(stderr, "\
+ fprintf(stderr, "\
m Move to archive (means 'ad') o use LHarc compatible method (a/u)\n\
");
#endif
- fprintf(stderr, "\
+ fprintf(stderr, "\
c re-Construct new archive w=<dir> specify extract directory (a/u/m/x/e)\n\
p Print to STDOUT from archive d delete FILES after (a/u/c)\n\
t Test file CRC in archive i ignore directory path (x/e)\n\
0/1/2 header level (a/u)\n\
");
#ifdef EUC
- fprintf(stderr, "\
+ fprintf(stderr, "\
e TEXT code convert from/to EUC\n\
");
#endif
/* ------------------------------------------------------------------------ */
int
main(argc, argv)
- int argc;
- char *argv[];
+ int argc;
+ char *argv[];
{
- char *p;
+ char *p;
- int i;
- int ac;
- char **av, *m;
+ int i;
+ int ac;
+ char **av, *m;
- init_variable(); /* Added N.Watazaki */
+ init_variable(); /* Added N.Watazaki */
- ac = argc;
- av = (char **)xmalloc( sizeof(char*)*argc );
-
for (i=0; i<argc; i++) {
+ ac = argc;
+ av = (char **)xmalloc( sizeof(char*)*argc );
+ for (i=0; i<argc; i++) {
av[i] = xstrdup( argv[i] );
- }
+ }
- if (ac < 2 || strcmp(av[1], "--help") == 0) {
+ if (ac < 2 || strcmp(av[1], "--help") == 0) {
print_tiny_usage();
exit(0);
}
- if (strcmp(av[1], "--version") == 0) {
- print_version();
- exit(0);
- }
-
- if (ac < 3) {
- cmd = CMD_LIST;
- av--; /* argv--; */ /* 1999.7.18 */
- ac++; /* argc++; */
- goto work;
- }
-
- m = av[1];
-
- if (m[0] == '-')
- m++;
- /* commands */
- switch (*m) {
- case 'x':
- case 'e':
- cmd = CMD_EXTRACT;
- break;
-
- case 'p':
- output_to_stdout = TRUE;
- cmd = CMD_EXTRACT;
- break;
-
- case 'c':
- new_archive = TRUE;
- cmd = CMD_ADD;
- break;
-
- case 'a':
- cmd = CMD_ADD;
- break;
-
- case 'd':
- cmd = CMD_DELETE;
- break;
-
- case 'u':
- update_if_newer = TRUE;
- cmd = CMD_ADD;
- break;
-
- case 'm':
- delete_after_append = TRUE;
- cmd = CMD_ADD;
- break;
-
- case 'v':
- verbose_listing = TRUE;
- cmd = CMD_LIST;
- break;
-
- case 'l':
- cmd = CMD_LIST;
- break;
-
- case 't':
- cmd = CMD_EXTRACT;
- verify_mode = TRUE;
- break;
-
- default:
+ if (strcmp(av[1], "--version") == 0) {
+ print_version();
+ exit(0);
+ }
+
+ if (ac < 3) {
+ cmd = CMD_LIST;
+ av--; /* argv--; */ /* 1999.7.18 */
+ ac++; /* argc++; */
+ goto work;
+ }
+
+ m = av[1];
+
+ if (m[0] == '-')
+ m++;
+ /* commands */
+ switch (*m) {
+ case 'x':
+ case 'e':
+ cmd = CMD_EXTRACT;
+ break;
+
+ case 'p':
+ output_to_stdout = TRUE;
+ cmd = CMD_EXTRACT;
+ break;
+
+ case 'c':
+ new_archive = TRUE;
+ cmd = CMD_ADD;
+ break;
+
+ case 'a':
+ cmd = CMD_ADD;
+ break;
+
+ case 'd':
+ cmd = CMD_DELETE;
+ break;
+
+ case 'u':
+ update_if_newer = TRUE;
+ cmd = CMD_ADD;
+ break;
+
+ case 'm':
+ delete_after_append = TRUE;
+ cmd = CMD_ADD;
+ break;
+
+ case 'v':
+ verbose_listing = TRUE;
+ cmd = CMD_LIST;
+ break;
+
+ case 'l':
+ cmd = CMD_LIST;
+ break;
+
+ case 't':
+ cmd = CMD_EXTRACT;
+ verify_mode = TRUE;
+ break;
+
+ default:
print_tiny_usage();
exit(2);
- }
-
- /* options */
- /* p = &argv[1][1]; */
- p = m+1;
- while ( *p != 0 ) {
- switch ((*p++)) {
- case 'q':
- switch (*p) {
- case '0': /* no quiet */
- case '1': /* no use the incremental indicator */
- quiet_mode = *p - '0';
- ++p;
- break;
- case '2': /* no output */
- ++p;
+ }
+
+ /* options */
+ /* p = &argv[1][1]; */
+ p = m+1;
+ while ( *p != 0 ) {
+ switch ((*p++)) {
+ case 'q':
+ switch (*p) {
+ case '0': /* no quiet */
+ case '1': /* no use the incremental indicator */
+ quiet_mode = *p - '0';
+ ++p;
+ break;
+ case '2': /* no output */
+ ++p;
/* fall through */
- default:
+ default:
/* In quiet mode, no confirm to overwrite */
force = TRUE;
- quiet = TRUE;
- break;
- }
+ quiet = TRUE;
+ break;
+ }
+ break;
+ case 'f':
+ force = TRUE;
+ break;
+ case 'p':
+ prof = TRUE;
+ break;
+ case 'v':
+ verbose++;
+ break;
+ case 't':
+ text_mode = TRUE;
break;
- case 'f':
- force = TRUE;
- break;
- case 'p':
- prof = TRUE;
- break;
- case 'v':
- verbose++;
- break;
- case 't':
- text_mode = TRUE;
- break;
#ifdef EUC
- case 'e':
- text_mode = TRUE;
- euc_mode = TRUE;
- break;
+ case 'e':
+ text_mode = TRUE;
+ euc_mode = TRUE;
+ break;
#endif
- case 'n':
- noexec = TRUE;
- break;
- case 'g':
- generic_format = TRUE;
- noconvertcase = TRUE;
- header_level = 0;
- break;
- case 'd':
- delete_after_append = TRUE;
- break;
- case 'o':
- switch (*p) {
- case 0:
- compress_method = LZHUFF1_METHOD_NUM;
- header_level = 0;
- break;
- case '5':
- compress_method = LZHUFF5_METHOD_NUM;
- p++;
- break;
+ case 'n':
+ noexec = TRUE;
+ break;
+ case 'g':
+ generic_format = TRUE;
+ noconvertcase = TRUE;
+ header_level = 0;
+ break;
+ case 'd':
+ delete_after_append = TRUE;
+ break;
+ case 'o':
+ switch (*p) {
+ case 0:
+ compress_method = LZHUFF1_METHOD_NUM;
+ header_level = 0;
+ break;
+ case '5':
+ compress_method = LZHUFF5_METHOD_NUM;
+ p++;
+ break;
#ifdef SUPPORT_LH7
- case '6':
- compress_method = LZHUFF6_METHOD_NUM;
- p++;
- break;
- case '7':
- compress_method = LZHUFF7_METHOD_NUM;
- p++;
- break;
+ case '6':
+ compress_method = LZHUFF6_METHOD_NUM;
+ p++;
+ break;
+ case '7':
+ compress_method = LZHUFF7_METHOD_NUM;
+ p++;
+ break;
#endif
- default:
- error("invalid compression method 'o%c'", *p);
- exit(1);
- }
- break;
- case 'z':
- compress_method = LZHUFF0_METHOD_NUM; /* Changed N.Watazaki */
- break;
- case 'i':
- ignore_directory = TRUE;
- break;
- case 'w':
- if (*p == '=')
- p++;
- extract_directory = p;
- while (*p)
- p++;
- break;
- case '0':
- header_level = HEADER_LEVEL0;
- break;
- case '1':
- header_level = HEADER_LEVEL1;
- break;
- case '2':
- header_level = HEADER_LEVEL2;
- break;
- default:
- error("Unknown option '%c'.", p[-1]);
- exit(1);
- }
- }
+ default:
+ error("invalid compression method 'o%c'", *p);
+ exit(1);
+ }
+ break;
+ case 'z':
+ compress_method = LZHUFF0_METHOD_NUM; /* Changed N.Watazaki */
+ break;
+ case 'i':
+ ignore_directory = TRUE;
+ break;
+ case 'w':
+ if (*p == '=')
+ p++;
+ extract_directory = p;
+ while (*p)
+ p++;
+ break;
+ case '0':
+ header_level = HEADER_LEVEL0;
+ break;
+ case '1':
+ header_level = HEADER_LEVEL1;
+ break;
+ case '2':
+ header_level = HEADER_LEVEL2;
+ break;
+ default:
+ error("Unknown option '%c'.", p[-1]);
+ exit(1);
+ }
+ }
work:
- /* archive file name */
- archive_name = av[2];
+ /* archive file name */
+ archive_name = av[2];
- if (!strcmp(archive_name, "-")) {
- if (!isatty(1) && cmd == CMD_ADD)
- quiet = TRUE;
- }
+ if (!strcmp(archive_name, "-")) {
+ if (!isatty(1) && cmd == CMD_ADD)
+ quiet = TRUE;
+ }
#if 0 /* Comment out; IMHO, this feature is useless. by Koji Arai */
- else {
- if (ac == 3 && !isatty(0)) { /* 1999.7.18 */
+ else {
+ if (ac == 3 && !isatty(0)) { /* 1999.7.18 */
/* Bug(?) on MinGW, isatty() return 0 on Cygwin console.
mingw-runtime-1.3-2 and Cygwin 1.3.10(0.51/3/2) on
Win2000 */
get_filename_from_stdin = TRUE;
- }
- }
+ }
+ }
#endif
- /* target file name */
- if (get_filename_from_stdin) {
+ /* target file name */
+ if (get_filename_from_stdin) {
char inpbuf[4096];
char **xfilev;
int xfilec = 257;
- cmd_filec = 0;
- xfilev = (char **)xmalloc(sizeof(char *) * xfilec);
- while (fgets(inpbuf, sizeof(inpbuf), stdin)) {
- /* delete \n if it exist */
- i=0; p=inpbuf;
- while (i < sizeof(inpbuf) && p != 0) {
- if (*p == '\n') {
- *p = 0;
- break;
- }
- p++; i++;
- }
-
- if (cmd_filec >= xfilec) {
- xfilec += 256;
- xfilev = (char **) xrealloc(xfilev,
- sizeof(char *) * xfilec);
- }
- if (strlen(inpbuf) < 1)
- continue;
- xfilev[cmd_filec++] = xstrdup(inpbuf);
- }
- xfilev[cmd_filec] = NULL;
- cmd_filev = xfilev;
- } else {
- cmd_filec = ac - 3;
- cmd_filev = av + 3;
- }
- sort_files();
-
- /* make crc table */
- make_crctable();
-
- switch (cmd) {
- case CMD_EXTRACT:
- cmd_extract();
- break;
- case CMD_ADD:
- cmd_add();
- break;
- case CMD_LIST:
- cmd_list();
- break;
- case CMD_DELETE:
- cmd_delete();
- break;
- }
+ cmd_filec = 0;
+ xfilev = (char **)xmalloc(sizeof(char *) * xfilec);
+ while (fgets(inpbuf, sizeof(inpbuf), stdin)) {
+ /* delete \n if it exist */
+ i=0; p=inpbuf;
+ while (i < sizeof(inpbuf) && p != 0) {
+ if (*p == '\n') {
+ *p = 0;
+ break;
+ }
+ p++; i++;
+ }
+
+ if (cmd_filec >= xfilec) {
+ xfilec += 256;
+ xfilev = (char **) xrealloc(xfilev,
+ sizeof(char *) * xfilec);
+ }
+ if (strlen(inpbuf) < 1)
+ continue;
+ xfilev[cmd_filec++] = xstrdup(inpbuf);
+ }
+ xfilev[cmd_filec] = NULL;
+ cmd_filev = xfilev;
+ } else {
+ cmd_filec = ac - 3;
+ cmd_filev = av + 3;
+ }
+ sort_files();
+
+ /* make crc table */
+ make_crctable();
+
+ switch (cmd) {
+ case CMD_EXTRACT:
+ cmd_extract();
+ break;
+ case CMD_ADD:
+ cmd_add();
+ break;
+ case CMD_LIST:
+ cmd_list();
+ break;
+ case CMD_DELETE:
+ cmd_delete();
+ break;
+ }
#ifdef USE_PROF
- if (!prof)
- exit(0);
+ if (!prof)
+ exit(0);
#endif
if (error_occurred)
return 1;
- return 0;
+ return 0;
}
{
/* macro PACKAGE_NAME, PACKAGE_VERSION and PLATFORM are
defined in config.h by configure script */
- fprintf(stderr, "%s version %s (%s)\n",
+ fprintf(stderr, "%s version %s (%s)\n",
PACKAGE_NAME, PACKAGE_VERSION, PLATFORM);
}
int errno_sv = errno;
va_list v;
- fprintf(stderr, "LHa: ");
+ fprintf(stderr, "LHa: ");
va_init(v, fmt);
vfprintf(stderr, fmt, v);
int errno_sv = errno;
va_list v;
- fprintf(stderr, "LHa: Warning: ");
+ fprintf(stderr, "LHa: Warning: ");
va_init(v, fmt);
vfprintf(stderr, fmt, v);
int errno_sv = errno;
va_list v;
- fprintf(stderr, "LHa: Error: ");
+ fprintf(stderr, "LHa: Error: ");
va_init(v, fmt);
vfprintf(stderr, fmt, v);
int errno_sv = errno;
va_list v;
- fprintf(stderr, "LHa: Fatal error: ");
+ fprintf(stderr, "LHa: Fatal error: ");
va_init(v, fmt);
vfprintf(stderr, fmt, v);
va_end(v);
- if (errno)
+ if (errno)
fprintf(stderr, ": %s\n", strerror(errno_sv));
else
fputs("\n", stderr);
/* ------------------------------------------------------------------------ */
RETSIGTYPE
interrupt(signo)
- int signo;
+ int signo;
{
- message("Interrupted");
-
- if (temporary_fd != -1)
- close(temporary_fd);
- unlink(temporary_name);
- if (recover_archive_when_interrupt)
- rename(backup_archive_name, archive_name);
- if (remove_extracting_file_when_interrupt) {
- message("Removing: %s", writing_filename);
- unlink(writing_filename);
- }
- signal(SIGINT, SIG_DFL);
+ message("Interrupted");
+
+ if (temporary_fd != -1)
+ close(temporary_fd);
+ unlink(temporary_name);
+ if (recover_archive_when_interrupt)
+ rename(backup_archive_name, archive_name);
+ if (remove_extracting_file_when_interrupt) {
+ message("Removing: %s", writing_filename);
+ unlink(writing_filename);
+ }
+ signal(SIGINT, SIG_DFL);
#ifdef SIGHUP
- signal(SIGHUP, SIG_DFL);
+ signal(SIGHUP, SIG_DFL);
#endif
- kill(getpid(), signo);
+ kill(getpid(), signo);
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
static int
sort_by_ascii(a, b)
- char **a, **b;
+ char **a, **b;
{
- register char *p, *q;
- register int c1, c2;
-
- p = *a, q = *b;
- if (generic_format) {
- do {
- c1 = *(unsigned char *) p++;
- c2 = *(unsigned char *) q++;
- if (!c1 || !c2)
- break;
- if (islower(c1))
- c1 = toupper(c1);
- if (islower(c2))
- c2 = toupper(c2);
- }
- while (c1 == c2);
- return c1 - c2;
- }
- else {
- while (*p == *q && *p != '\0')
- p++, q++;
- return *(unsigned char *) p - *(unsigned char *) q;
- }
+ register char *p, *q;
+ register int c1, c2;
+
+ p = *a, q = *b;
+ if (generic_format) {
+ do {
+ c1 = *(unsigned char *) p++;
+ c2 = *(unsigned char *) q++;
+ if (!c1 || !c2)
+ break;
+ if (islower(c1))
+ c1 = toupper(c1);
+ if (islower(c2))
+ c2 = toupper(c2);
+ }
+ while (c1 == c2);
+ return c1 - c2;
+ }
+ else {
+ while (*p == *q && *p != '\0')
+ p++, q++;
+ return *(unsigned char *) p - *(unsigned char *) q;
+ }
}
/* ------------------------------------------------------------------------ */
static void
sort_files()
{
- if (cmd_filec > 1)
- qsort(cmd_filev, cmd_filec, sizeof(char *), sort_by_ascii);
+ if (cmd_filec > 1)
+ qsort(cmd_filev, cmd_filec, sizeof(char *), sort_by_ascii);
}
/* ------------------------------------------------------------------------ */
size_t size;
{
void *p = malloc(size);
- if (!p)
- fatal_error("Not enough memory");
- return p;
+ if (!p)
+ fatal_error("Not enough memory");
+ return p;
}
/* ------------------------------------------------------------------------ */
void *old;
size_t size;
{
- void *p = (char *) realloc(old, size);
- if (!p)
- fatal_error("Not enough memory");
- return p;
+ void *p = (char *) realloc(old, size);
+ if (!p)
+ fatal_error("Not enough memory");
+ return p;
}
char *
xstrdup(str)
- char *str;
+ char *str;
{
int len = strlen(str);
- char *p = (char *)xmalloc(len + 1);
+ char *p = (char *)xmalloc(len + 1);
strcpy(p, str);
- return p;
+ return p;
}
/* ------------------------------------------------------------------------ */
-/* STRING POOL */
+/* STRING POOL */
/* ------------------------------------------------------------------------ */
/*
string pool :
- +-------------+-------------+------+-------------+----------+
- | N A M E 1 \0| N A M E 2 \0| .... | N A M E n \0| |
- +-------------+-------------+------+-------------+----------+
- ^ ^ ^ buffer+0 buffer+used buffer+size
+ +-------------+-------------+------+-------------+----------+
+ | N A M E 1 \0| N A M E 2 \0| .... | N A M E n \0| |
+ +-------------+-------------+------+-------------+----------+
+ ^ ^ ^ buffer+0 buffer+used buffer+size
vector :
- +---------------+---------------+------------- -----------------+
- | pointer to | pointer to | pointer to ... pointer to |
- | stringpool | N A M E 1 | N A M E 2 ... N A M E n |
- +---------------+---------------+------------- -------------+
- ^ malloc base returned
+ +---------------+---------------+------------- -----------------+
+ | pointer to | pointer to | pointer to ... pointer to |
+ | stringpool | N A M E 1 | N A M E 2 ... N A M E n |
+ +---------------+---------------+------------- -------------+
+ ^ malloc base returned
*/
/* ------------------------------------------------------------------------ */
void
init_sp(sp)
- struct string_pool *sp;
+ struct string_pool *sp;
{
- sp->size = 1024 - 8; /* any ( >=0 ) */
- sp->used = 0;
- sp->n = 0;
- sp->buffer = (char *) xmalloc(sp->size * sizeof(char));
+ sp->size = 1024 - 8; /* any ( >=0 ) */
+ sp->used = 0;
+ sp->n = 0;
+ sp->buffer = (char *) xmalloc(sp->size * sizeof(char));
}
/* ------------------------------------------------------------------------ */
void
add_sp(sp, name, len)
- struct string_pool *sp;
- char *name; /* stored '\0' at tail */
- int len; /* include '\0' */
+ struct string_pool *sp;
+ char *name; /* stored '\0' at tail */
+ int len; /* include '\0' */
{
- while (sp->used + len > sp->size) {
- sp->size *= 2;
- sp->buffer = (char *) xrealloc(sp->buffer, sp->size * sizeof(char));
- }
- memmove(sp->buffer + sp->used, name, len);
- sp->used += len;
- sp->n++;
+ while (sp->used + len > sp->size) {
+ sp->size *= 2;
+ sp->buffer = (char *) xrealloc(sp->buffer, sp->size * sizeof(char));
+ }
+ memmove(sp->buffer + sp->used, name, len);
+ sp->used += len;
+ sp->n++;
}
/* ------------------------------------------------------------------------ */
void
finish_sp(sp, v_count, v_vector)
- register struct string_pool *sp;
- int *v_count;
- char ***v_vector;
+ register struct string_pool *sp;
+ int *v_count;
+ char ***v_vector;
{
- int i;
- register char *p;
- char **v;
-
- v = (char **) xmalloc((sp->n + 1) * sizeof(char *));
- *v++ = sp->buffer;
- *v_vector = v;
- *v_count = sp->n;
- p = sp->buffer;
- for (i = sp->n; i; i--) {
- *v++ = p;
- if (i - 1)
- p += strlen(p) + 1;
- }
+ int i;
+ register char *p;
+ char **v;
+
+ v = (char **) xmalloc((sp->n + 1) * sizeof(char *));
+ *v++ = sp->buffer;
+ *v_vector = v;
+ *v_count = sp->n;
+ p = sp->buffer;
+ for (i = sp->n; i; i--) {
+ *v++ = p;
+ if (i - 1)
+ p += strlen(p) + 1;
+ }
}
/* ------------------------------------------------------------------------ */
void
free_sp(vector)
- char **vector;
+ char **vector;
{
- vector--;
- free(*vector); /* free string pool */
- free(vector);
+ vector--;
+ free(*vector); /* free string pool */
+ free(vector);
}
/* ------------------------------------------------------------------------ */
-/* READ DIRECTORY FILES */
+/* READ DIRECTORY FILES */
/* ------------------------------------------------------------------------ */
static boolean
include_path_p(path, name)
- char *path, *name;
+ char *path, *name;
{
- char *n = name;
- while (*path)
- if (*path++ != *n++)
- return (path[-1] == '/' && *n == '\0');
- return (*n == '/' || (n != name && path[-1] == '/' && n[-1] == '/'));
+ char *n = name;
+ while (*path)
+ if (*path++ != *n++)
+ return (path[-1] == '/' && *n == '\0');
+ return (*n == '/' || (n != name && path[-1] == '/' && n[-1] == '/'));
}
/* ------------------------------------------------------------------------ */
void
cleaning_files(v_filec, v_filev)
- int *v_filec;
- char ***v_filev;
+ int *v_filec;
+ char ***v_filev;
{
- char *flags;
- struct stat stbuf;
-
- register char **filev = *v_filev;
- register int filec = *v_filec;
- register char *p;
- register int i, j;
-
- if (filec == 0)
- return;
-
- flags = xmalloc(filec * sizeof(char));
-
- /* flags & 0x01 : 1: ignore */
- /* flags & 0x02 : 1: directory, 0 : regular file */
- /* flags & 0x04 : 1: need delete */
-
-
- for (i = 0; i < filec; i++)
- if (GETSTAT(filev[i], &stbuf) < 0) {
- flags[i] = 0x04;
- warning("Cannot access \"%s\", ignored.", filev[i]);
- }
- else {
- if (is_regularfile(&stbuf))
- flags[i] = 0x00;
- else if (is_directory(&stbuf))
- flags[i] = 0x02;
+ char *flags;
+ struct stat stbuf;
+
+ register char **filev = *v_filev;
+ register int filec = *v_filec;
+ register char *p;
+ register int i, j;
+
+ if (filec == 0)
+ return;
+
+ flags = xmalloc(filec * sizeof(char));
+
+ /* flags & 0x01 : 1: ignore */
+ /* flags & 0x02 : 1: directory, 0 : regular file */
+ /* flags & 0x04 : 1: need delete */
+
+
+ for (i = 0; i < filec; i++)
+ if (GETSTAT(filev[i], &stbuf) < 0) {
+ flags[i] = 0x04;
+ warning("Cannot access \"%s\", ignored.", filev[i]);
+ }
+ else {
+ if (is_regularfile(&stbuf))
+ flags[i] = 0x00;
+ else if (is_directory(&stbuf))
+ flags[i] = 0x02;
#ifdef S_IFLNK
- else if (is_symlink(&stbuf)) /* t.okamoto */
- flags[i] = 0x00;
-#endif
- else {
- flags[i] = 0x04;
- warning("Cannot archive \"%s\", ignored.", filev[i]);
- }
- }
-
- for (i = 0; i < filec; i++) {
- p = filev[i];
- if ((flags[i] & 0x07) == 0x00) { /* regular file, not
- * deleted/ignored */
- for (j = i + 1; j < filec; j++) {
- if ((flags[j] & 0x07) == 0x00) { /* regular file, not
- * deleted/ignored */
- if (STREQU(p, filev[j]))
- flags[j] = 0x04; /* delete */
- }
- }
- }
- else if ((flags[i] & 0x07) == 0x02) { /* directory, not
- * deleted/ignored */
- for (j = i + 1; j < filec; j++) {
- if ((flags[j] & 0x07) == 0x00) { /* regular file, not
- * deleted/ignored */
- if (include_path_p(p, filev[j]))
- flags[j] = 0x04; /* delete */
- }
- else if ((flags[j] & 0x07) == 0x02) { /* directory, not
- * deleted/ignored */
- if (include_path_p(p, filev[j]))
- flags[j] = 0x04; /* delete */
- }
- }
- }
- }
-
- for (i = j = 0; i < filec; i++) {
- if ((flags[i] & 0x04) == 0) {
- if (i != j)
- filev[j] = filev[i];
- j++;
- }
- }
- *v_filec = j;
-
- free(flags);
+ else if (is_symlink(&stbuf)) /* t.okamoto */
+ flags[i] = 0x00;
+#endif
+ else {
+ flags[i] = 0x04;
+ warning("Cannot archive \"%s\", ignored.", filev[i]);
+ }
+ }
+
+ for (i = 0; i < filec; i++) {
+ p = filev[i];
+ if ((flags[i] & 0x07) == 0x00) { /* regular file, not
+ * deleted/ignored */
+ for (j = i + 1; j < filec; j++) {
+ if ((flags[j] & 0x07) == 0x00) { /* regular file, not
+ * deleted/ignored */
+ if (STREQU(p, filev[j]))
+ flags[j] = 0x04; /* delete */
+ }
+ }
+ }
+ else if ((flags[i] & 0x07) == 0x02) { /* directory, not
+ * deleted/ignored */
+ for (j = i + 1; j < filec; j++) {
+ if ((flags[j] & 0x07) == 0x00) { /* regular file, not
+ * deleted/ignored */
+ if (include_path_p(p, filev[j]))
+ flags[j] = 0x04; /* delete */
+ }
+ else if ((flags[j] & 0x07) == 0x02) { /* directory, not
+ * deleted/ignored */
+ if (include_path_p(p, filev[j]))
+ flags[j] = 0x04; /* delete */
+ }
+ }
+ }
+ }
+
+ for (i = j = 0; i < filec; i++) {
+ if ((flags[i] & 0x04) == 0) {
+ if (i != j)
+ filev[j] = filev[i];
+ j++;
+ }
+ }
+ *v_filec = j;
+
+ free(flags);
}
/* ------------------------------------------------------------------------ */
boolean
find_files(name, v_filec, v_filev)
- char *name;
- int *v_filec;
- char ***v_filev;
+ char *name;
+ int *v_filec;
+ char ***v_filev;
{
- struct string_pool sp;
- char newname[FILENAME_LENGTH];
- int len, n;
- DIR *dirp;
+ struct string_pool sp;
+ char newname[FILENAME_LENGTH];
+ int len, n;
+ DIR *dirp;
struct dirent *dp;
- struct stat tmp_stbuf, arc_stbuf, fil_stbuf;
+ struct stat tmp_stbuf, arc_stbuf, fil_stbuf;
- strcpy(newname, name);
- len = strlen(name);
- if (len > 0 && newname[len - 1] != '/')
- newname[len++] = '/';
+ strcpy(newname, name);
+ len = strlen(name);
+ if (len > 0 && newname[len - 1] != '/')
+ newname[len++] = '/';
- dirp = opendir(name);
- if (!dirp)
- return FALSE;
+ dirp = opendir(name);
+ if (!dirp)
+ return FALSE;
- init_sp(&sp);
+ init_sp(&sp);
- GETSTAT(temporary_name, &tmp_stbuf);
- GETSTAT(archive_name, &arc_stbuf);
+ GETSTAT(temporary_name, &tmp_stbuf);
+ GETSTAT(archive_name, &arc_stbuf);
- for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
- n = NAMLEN(dp);
- strncpy(newname + len, dp->d_name, n);
- newname[len + n] = '\0';
- if (GETSTAT(newname, &fil_stbuf) < 0)
- continue;
+ for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
+ n = NAMLEN(dp);
+ strncpy(newname + len, dp->d_name, n);
+ newname[len + n] = '\0';
+ if (GETSTAT(newname, &fil_stbuf) < 0)
+ continue;
#if !defined(HAVE_STRUCT_STAT_ST_INO) || __MINGW32__
- if ( dp->d_name[0] != '.' ||
- (n != 1 &&
- (dp->d_name[1] != '.' ||
- n != 2)) ) {
- add_sp(&sp, newname, len+n+1);
- }
-#else
- if ((dp->d_ino != 0) &&
- /* exclude '.' and '..' */
- ((dp->d_name[0] != '.') ||
- ((n != 1) &&
- ((dp->d_name[1] != '.') ||
- (n != 2)))) &&
- ((tmp_stbuf.st_dev != fil_stbuf.st_dev ||
- tmp_stbuf.st_ino != fil_stbuf.st_ino) &&
- (arc_stbuf.st_dev != fil_stbuf.st_dev ||
- arc_stbuf.st_ino != fil_stbuf.st_ino))) {
- add_sp(&sp, newname, len + n + 1);
- }
+ if ( dp->d_name[0] != '.' ||
+ (n != 1 &&
+ (dp->d_name[1] != '.' ||
+ n != 2)) ) {
+ add_sp(&sp, newname, len+n+1);
+ }
+#else
+ if ((dp->d_ino != 0) &&
+ /* exclude '.' and '..' */
+ ((dp->d_name[0] != '.') ||
+ ((n != 1) &&
+ ((dp->d_name[1] != '.') ||
+ (n != 2)))) &&
+ ((tmp_stbuf.st_dev != fil_stbuf.st_dev ||
+ tmp_stbuf.st_ino != fil_stbuf.st_ino) &&
+ (arc_stbuf.st_dev != fil_stbuf.st_dev ||
+ arc_stbuf.st_ino != fil_stbuf.st_ino))) {
+ add_sp(&sp, newname, len + n + 1);
+ }
#endif
- }
- closedir(dirp);
- finish_sp(&sp, v_filec, v_filev);
- if (*v_filec > 1)
- qsort(*v_filev, *v_filec, sizeof(char *), sort_by_ascii);
- cleaning_files(v_filec, v_filev);
-
- return TRUE;
+ }
+ closedir(dirp);
+ finish_sp(&sp, v_filec, v_filev);
+ if (*v_filec > 1)
+ qsort(*v_filev, *v_filec, sizeof(char *), sort_by_ascii);
+ cleaning_files(v_filec, v_filev);
+
+ return TRUE;
}
/* ------------------------------------------------------------------------ */
void
free_files(filec, filev)
- int filec;
- char **filev;
+ int filec;
+ char **filev;
{
- free_sp(filev);
+ free_sp(filev);
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
/* Build temporary file name and store to TEMPORARY_NAME */
int
build_temporary_name()
{
#ifdef TMP_FILENAME_TEMPLATE
- /* "/tmp/lhXXXXXX" etc. */
- if (extract_directory == NULL) {
- strcpy(temporary_name, TMP_FILENAME_TEMPLATE);
- }
- else {
- xsnprintf(temporary_name, sizeof(temporary_name),
+ /* "/tmp/lhXXXXXX" etc. */
+ if (extract_directory == NULL) {
+ strcpy(temporary_name, TMP_FILENAME_TEMPLATE);
+ }
+ else {
+ xsnprintf(temporary_name, sizeof(temporary_name),
"%s/lhXXXXXX", extract_directory);
- }
+ }
#else
- char *p, *s;
+ char *p, *s;
- strcpy(temporary_name, archive_name);
- for (p = temporary_name, s = (char *) 0; *p; p++)
- if (*p == '/')
- s = p;
- strcpy((s ? s + 1 : temporary_name), "lhXXXXXX");
+ strcpy(temporary_name, archive_name);
+ for (p = temporary_name, s = (char *) 0; *p; p++)
+ if (*p == '/')
+ s = p;
+ strcpy((s ? s + 1 : temporary_name), "lhXXXXXX");
#endif
#ifdef HAVE_MKSTEMP
{
/* ------------------------------------------------------------------------ */
static void
modify_filename_extention(buffer, ext)
- char *buffer;
- char *ext;
+ char *buffer;
+ char *ext;
{
- register char *p, *dot;
+ register char *p, *dot;
- for (p = buffer, dot = (char *) 0; *p; p++) {
- if (*p == '.')
- dot = p;
- else if (*p == '/')
- dot = (char *) 0;
- }
+ for (p = buffer, dot = (char *) 0; *p; p++) {
+ if (*p == '.')
+ dot = p;
+ else if (*p == '/')
+ dot = (char *) 0;
+ }
- if (dot)
- p = dot;
+ if (dot)
+ p = dot;
- strcpy(p, ext);
+ strcpy(p, ext);
}
/* ------------------------------------------------------------------------ */
/* build backup file name */
void
build_backup_name(buffer, original)
- char *buffer;
- char *original;
+ char *buffer;
+ char *original;
{
- strcpy(buffer, original);
- modify_filename_extention(buffer, BACKUPNAME_EXTENTION); /* ".bak" */
+ strcpy(buffer, original);
+ modify_filename_extention(buffer, BACKUPNAME_EXTENTION); /* ".bak" */
}
/* ------------------------------------------------------------------------ */
void
build_standard_archive_name(buffer, orginal)
- char *buffer;
- char *orginal;
+ char *buffer;
+ char *orginal;
{
- strcpy(buffer, orginal);
- modify_filename_extention(buffer, ARCHIVENAME_EXTENTION); /* ".lzh" */
+ strcpy(buffer, orginal);
+ modify_filename_extention(buffer, ARCHIVENAME_EXTENTION); /* ".lzh" */
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
boolean
need_file(name)
- char *name;
+ char *name;
{
- int i;
+ int i;
- if (cmd_filec == 0)
- return TRUE;
+ if (cmd_filec == 0)
+ return TRUE;
- for (i = 0; i < cmd_filec; i++) {
- if (patmatch(cmd_filev[i], name, 0))
- return TRUE;
- }
+ for (i = 0; i < cmd_filec; i++) {
+ if (patmatch(cmd_filev[i], name, 0))
+ return TRUE;
+ }
- return FALSE;
+ return FALSE;
}
FILE *
xfopen(name, mode)
- char *name, *mode;
+ char *name, *mode;
{
- FILE *fp;
+ FILE *fp;
- if ((fp = fopen(name, mode)) == NULL)
- fatal_error("Cannot open file \"%s\"", name);
+ if ((fp = fopen(name, mode)) == NULL)
+ fatal_error("Cannot open file \"%s\"", name);
- return fp;
+ return fp;
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
static boolean
open_old_archive_1(name, v_fp)
- char *name;
- FILE **v_fp;
+ char *name;
+ FILE **v_fp;
{
- FILE *fp;
- struct stat stbuf;
-
- if (stat(name, &stbuf) >= 0 &&
- is_regularfile(&stbuf) &&
- (fp = fopen(name, READ_BINARY)) != NULL) {
- *v_fp = fp;
- archive_file_gid = stbuf.st_gid;
- archive_file_mode = stbuf.st_mode;
- return TRUE;
- }
-
- *v_fp = NULL;
- archive_file_gid = -1;
- return FALSE;
+ FILE *fp;
+ struct stat stbuf;
+
+ if (stat(name, &stbuf) >= 0 &&
+ is_regularfile(&stbuf) &&
+ (fp = fopen(name, READ_BINARY)) != NULL) {
+ *v_fp = fp;
+ archive_file_gid = stbuf.st_gid;
+ archive_file_mode = stbuf.st_mode;
+ return TRUE;
+ }
+
+ *v_fp = NULL;
+ archive_file_gid = -1;
+ return FALSE;
}
/* ------------------------------------------------------------------------ */
FILE *
open_old_archive()
{
- FILE *fp;
- char *p;
+ FILE *fp;
+ char *p;
static char expanded_archive_name[FILENAME_LENGTH];
- if (!strcmp(archive_name, "-")) {
- if (cmd == CMD_EXTRACT || cmd == CMD_LIST) {
+ if (!strcmp(archive_name, "-")) {
+ if (cmd == CMD_EXTRACT || cmd == CMD_LIST) {
#if __MINGW32__
setmode(fileno(stdin), O_BINARY);
#endif
- return stdin;
+ return stdin;
}
- else
- return NULL;
- }
+ else
+ return NULL;
+ }
p = strrchr(archive_name, '.');
- if (p) {
- if (strucmp(".LZH", p) == 0
- || strucmp(".LZS", p) == 0
- || strucmp(".COM", p) == 0 /* DOS SFX */
- || strucmp(".EXE", p) == 0
- || strucmp(".X", p) == 0 /* HUMAN SFX */
- || strucmp(".BAK", p) == 0) { /* for BackUp */
- open_old_archive_1(archive_name, &fp);
- return fp;
- }
- }
-
- if (open_old_archive_1(archive_name, &fp))
- return fp;
- xsnprintf(expanded_archive_name, sizeof(expanded_archive_name),
+ if (p) {
+ if (strucmp(".LZH", p) == 0
+ || strucmp(".LZS", p) == 0
+ || strucmp(".COM", p) == 0 /* DOS SFX */
+ || strucmp(".EXE", p) == 0
+ || strucmp(".X", p) == 0 /* HUMAN SFX */
+ || strucmp(".BAK", p) == 0) { /* for BackUp */
+ open_old_archive_1(archive_name, &fp);
+ return fp;
+ }
+ }
+
+ if (open_old_archive_1(archive_name, &fp))
+ return fp;
+ xsnprintf(expanded_archive_name, sizeof(expanded_archive_name),
"%s.lzh", archive_name);
- if (open_old_archive_1(expanded_archive_name, &fp)) {
- archive_name = expanded_archive_name;
- return fp;
- }
- /*
- * if ( (errno&0xffff)!=E_PNNF ) { archive_name =
- * expanded_archive_name; return NULL; }
- */
- xsnprintf(expanded_archive_name, sizeof(expanded_archive_name),
+ if (open_old_archive_1(expanded_archive_name, &fp)) {
+ archive_name = expanded_archive_name;
+ return fp;
+ }
+ /*
+ * if ( (errno&0xffff)!=E_PNNF ) { archive_name =
+ * expanded_archive_name; return NULL; }
+ */
+ xsnprintf(expanded_archive_name, sizeof(expanded_archive_name),
"%s.lzs", archive_name);
- if (open_old_archive_1(expanded_archive_name, &fp)) {
- archive_name = expanded_archive_name;
- return fp;
- }
- /*
- * if ( (errno&0xffff)!=E_PNNF ) { archive_name =
- * expanded_archive_name; return NULL; }
- */
- /*
- * sprintf( expanded_archive_name , "%s.lzh",archive_name);
- * archive_name = expanded_archive_name;
- */
- return NULL;
+ if (open_old_archive_1(expanded_archive_name, &fp)) {
+ archive_name = expanded_archive_name;
+ return fp;
+ }
+ /*
+ * if ( (errno&0xffff)!=E_PNNF ) { archive_name =
+ * expanded_archive_name; return NULL; }
+ */
+ /*
+ * sprintf( expanded_archive_name , "%s.lzh",archive_name);
+ * archive_name = expanded_archive_name;
+ */
+ return NULL;
}
/* ------------------------------------------------------------------------ */
int
inquire(msg, name, selective)
- char *msg, *name, *selective;
+ char *msg, *name, *selective;
{
- char buffer[1024];
- char *p;
+ char buffer[1024];
+ char *p;
- for (;;) {
- fprintf(stderr, "%s %s ", name, msg);
- fflush(stderr);
+ for (;;) {
+ fprintf(stderr, "%s %s ", name, msg);
+ fflush(stderr);
- fgets(buffer, 1024, stdin);
+ fgets(buffer, 1024, stdin);
- for (p = selective; *p; p++)
- if (buffer[0] == *p)
- return p - selective;
- }
- /* NOTREACHED */
+ for (p = selective; *p; p++)
+ if (buffer[0] == *p)
+ return p - selective;
+ }
+ /* NOTREACHED */
}
/* ------------------------------------------------------------------------ */
void
write_archive_tail(nafp)
- FILE *nafp;
+ FILE *nafp;
{
- putc(0x00, nafp);
+ putc(0x00, nafp);
}
/* ------------------------------------------------------------------------ */
void
copy_old_one(oafp, nafp, hdr)
- FILE *oafp, *nafp;
- LzHeader *hdr;
+ FILE *oafp, *nafp;
+ LzHeader *hdr;
{
- if (noexec) {
- fseek(oafp, hdr->header_size + hdr->packed_size, SEEK_CUR);
- }
- else {
- reading_filename = archive_name;
- writing_filename = temporary_name;
+ if (noexec) {
+ fseek(oafp, hdr->header_size + hdr->packed_size, SEEK_CUR);
+ }
+ else {
+ reading_filename = archive_name;
+ writing_filename = temporary_name;
copyfile(oafp, nafp, hdr->header_size + hdr->packed_size, 0, 0);
- }
+ }
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* compile-command:"gcc -c lharc.c" */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* lhdir.c -- Directory access routine */
-/* */
-/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Emulate opendir(),readdir(),closedir() function for LHarc */
-/* */
-/* Ver. 0.00 Original 1988.05.31 Y.Tagawa */
-/* Ver. 0.03 Release #3 for LHarc UNIX 1988.07.02 Y.Tagawa */
-/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* lhdir.c -- Directory access routine */
+/* */
+/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Emulate opendir(),readdir(),closedir() function for LHarc */
+/* */
+/* Ver. 0.00 Original 1988.05.31 Y.Tagawa */
+/* Ver. 0.03 Release #3 for LHarc UNIX 1988.07.02 Y.Tagawa */
+/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
#ifndef DIRSIZ
/* Warning : Are you sure? (normally defined in <sys/dir.h> */
-#define DIRSIZ 14
+#define DIRSIZ 14
#endif
#include "lhdir.h"
/* ------------------------------------------------------------------------ */
DIR *
opendir(name)
- char *name;
+ char *name;
{
- register DIR *dirp;
- register int fd;
+ register DIR *dirp;
+ register int fd;
- if ((fd = open(name, O_RDONLY)) >= 0) {
- if ((dirp = (DIR *) malloc(sizeof(DIR))) != (DIR *) 0) {
- dirp->dd_fd = fd;
- dirp->dd_loc = 0;
- dirp->dd_size = 0;
- return dirp;
- }
+ if ((fd = open(name, O_RDONLY)) >= 0) {
+ if ((dirp = (DIR *) malloc(sizeof(DIR))) != (DIR *) 0) {
+ dirp->dd_fd = fd;
+ dirp->dd_loc = 0;
+ dirp->dd_size = 0;
+ return dirp;
+ }
- close(fd);
- }
+ close(fd);
+ }
- return (DIR *) 0;
+ return (DIR *) 0;
}
/* ------------------------------------------------------------------------ */
struct direct *
readdir(dirp)
- register DIR *dirp;
+ register DIR *dirp;
{
- static struct direct lhdir;
- register struct old_direct *dp;
+ static struct direct lhdir;
+ register struct old_direct *dp;
- do {
- if (dirp->dd_loc >= dirp->dd_size) {
- dirp->dd_loc = 0;
- if ((dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
- return (struct direct *) 0;
- }
+ do {
+ if (dirp->dd_loc >= dirp->dd_size) {
+ dirp->dd_loc = 0;
+ if ((dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
+ return (struct direct *) 0;
+ }
- dp = (struct old_direct *) (dirp->dd_buf + dirp->dd_loc);
+ dp = (struct old_direct *) (dirp->dd_buf + dirp->dd_loc);
- if (dirp->dd_loc + sizeof(struct old_direct) > dirp->dd_size)
- return (struct direct *) 0;
+ if (dirp->dd_loc + sizeof(struct old_direct) > dirp->dd_size)
+ return (struct direct *) 0;
- dirp->dd_loc += sizeof(struct old_direct);
+ dirp->dd_loc += sizeof(struct old_direct);
- } while (dp->d_ino == 0);
+ } while (dp->d_ino == 0);
- /* construct new format */
- lhdir.d_ino = dp->d_ino;
- strncpy(lhdir.d_name, dp->d_name, DIRSIZ);
- lhdir.d_name[DIRSIZ] = '\0';
- lhdir.d_namlen = strlen(lhdir.d_name);
+ /* construct new format */
+ lhdir.d_ino = dp->d_ino;
+ strncpy(lhdir.d_name, dp->d_name, DIRSIZ);
+ lhdir.d_name[DIRSIZ] = '\0';
+ lhdir.d_namlen = strlen(lhdir.d_name);
- return &lhdir;
+ return &lhdir;
}
/* ------------------------------------------------------------------------ */
closedir(dirp)
- DIR *dirp;
+ DIR *dirp;
{
- close(dirp->dd_fd);
- free(dirp);
+ close(dirp->dd_fd);
+ free(dirp);
}
-/* Local Variables: */
-/* tab-width : 4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX Directory access routine */
-/* */
-/* Modified Nobutaka Watazaki */
-/* Emulate opendir(), readdir(), closedir() function for LHa */
-/* */
-/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX Directory access routine */
+/* */
+/* Modified Nobutaka Watazaki */
+/* Emulate opendir(), readdir(), closedir() function for LHa */
+/* */
+/* Ver. 1.14 Soruce All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#ifndef DIRBLKSIZ
-#define DIRBLKSIZ 512
+#define DIRBLKSIZ 512
#endif
/* ------------------------------------------------------------------------ */
-/* Type Definition */
+/* Type Definition */
/* ------------------------------------------------------------------------ */
struct direct {
- int d_ino;
- int d_namlen;
- char d_name[256];
+ int d_ino;
+ int d_namlen;
+ char d_name[256];
};
typedef struct {
- int dd_fd;
- int dd_loc;
- int dd_size;
- char dd_buf[DIRBLKSIZ];
+ int dd_fd;
+ int dd_loc;
+ int dd_size;
+ char dd_buf[DIRBLKSIZ];
} DIR;
/* ------------------------------------------------------------------------ */
-/* Functions */
+/* Functions */
/* ------------------------------------------------------------------------ */
-extern DIR *opendir();
+extern DIR *opendir();
extern struct direct *readdir();
-extern int closedir();
-
-/* Local Variables: */
-/* tab-width : 4 */
-/* End: */
-/* vi: set tabstop=4: */
+extern int closedir();
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* lhext.c -- LHarc extract */
-/* */
-/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
-/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
-/* Ver. 0.03 LHa for UNIX 1991.12.17 M.Oki */
-/* Ver. 1.12 LHa for UNIX 1993.10.01 N.Watazaki */
-/* Ver. 1.13b Symbolic Link Update Bug Fix 1994.06.21 N.Watazaki */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* lhext.c -- LHarc extract */
+/* */
+/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
+/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
+/* Ver. 0.03 LHa for UNIX 1991.12.17 M.Oki */
+/* Ver. 1.12 LHa for UNIX 1993.10.01 N.Watazaki */
+/* Ver. 1.13b Symbolic Link Update Bug Fix 1994.06.21 N.Watazaki */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* Ver. 1.14e bugfix 1999.04.30 T.Okamoto */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
-static int skip_flg = FALSE; /* FALSE..No Skip , TRUE..Skip */
-static char *methods[] =
+static int skip_flg = FALSE; /* FALSE..No Skip , TRUE..Skip */
+static char *methods[] =
{
- LZHUFF0_METHOD, LZHUFF1_METHOD, LZHUFF2_METHOD, LZHUFF3_METHOD,
- LZHUFF4_METHOD, LZHUFF5_METHOD, LZHUFF6_METHOD, LZHUFF7_METHOD,
- LARC_METHOD, LARC5_METHOD, LARC4_METHOD,
- LZHDIRS_METHOD,
- NULL
+ LZHUFF0_METHOD, LZHUFF1_METHOD, LZHUFF2_METHOD, LZHUFF3_METHOD,
+ LZHUFF4_METHOD, LZHUFF5_METHOD, LZHUFF6_METHOD, LZHUFF7_METHOD,
+ LARC_METHOD, LARC5_METHOD, LARC4_METHOD,
+ LZHDIRS_METHOD,
+ NULL
};
/* ------------------------------------------------------------------------ */
static boolean
inquire_extract(name)
- char *name;
+ char *name;
{
- struct stat stbuf;
-
- skip_flg = FALSE;
- if (stat(name, &stbuf) >= 0) {
- if (!is_regularfile(&stbuf)) {
- error("\"%s\" already exists (not a file)", name);
- return FALSE;
- }
-
- if (noexec) {
- printf("EXTRACT %s but file is exist.\n", name);
- return FALSE;
- }
- else if (!force) {
- if (!isatty(0))
- return FALSE;
-
- switch (inquire("OverWrite ?(Yes/[No]/All/Skip)", name, "YyNnAaSs\n")) {
- case 0:
- case 1:/* Y/y */
- break;
- case 2:
- case 3:/* N/n */
- case 8:/* Return */
- return FALSE;
- case 4:
- case 5:/* A/a */
- force = TRUE;
- break;
- case 6:
- case 7:/* S/s */
- skip_flg = TRUE;
- break;
- }
- }
- }
- if (noexec)
- printf("EXTRACT %s\n", name);
-
- return TRUE;
+ struct stat stbuf;
+
+ skip_flg = FALSE;
+ if (stat(name, &stbuf) >= 0) {
+ if (!is_regularfile(&stbuf)) {
+ error("\"%s\" already exists (not a file)", name);
+ return FALSE;
+ }
+
+ if (noexec) {
+ printf("EXTRACT %s but file is exist.\n", name);
+ return FALSE;
+ }
+ else if (!force) {
+ if (!isatty(0))
+ return FALSE;
+
+ switch (inquire("OverWrite ?(Yes/[No]/All/Skip)", name, "YyNnAaSs\n")) {
+ case 0:
+ case 1:/* Y/y */
+ break;
+ case 2:
+ case 3:/* N/n */
+ case 8:/* Return */
+ return FALSE;
+ case 4:
+ case 5:/* A/a */
+ force = TRUE;
+ break;
+ case 6:
+ case 7:/* S/s */
+ skip_flg = TRUE;
+ break;
+ }
+ }
+ }
+ if (noexec)
+ printf("EXTRACT %s\n", name);
+
+ return TRUE;
}
/* ------------------------------------------------------------------------ */
static boolean
make_parent_path(name)
- char *name;
+ char *name;
{
- char path[FILENAME_LENGTH];
- struct stat stbuf;
- register char *p;
-
- /* make parent directory name into PATH for recursive call */
- strcpy(path, name);
- for (p = path + strlen(path); p > path; p--)
- if (p[-1] == '/') {
- *--p = '\0';
- break;
- }
-
- if (p == path) {
- message("invalid path name \"%s\"", name);
- return FALSE; /* no more parent. */
- }
-
- if (GETSTAT(path, &stbuf) >= 0) {
- if (is_directory(&stbuf))
- return TRUE;
- }
-
- if (verbose)
- message("Making directory \"%s\".", path);
+ char path[FILENAME_LENGTH];
+ struct stat stbuf;
+ register char *p;
+
+ /* make parent directory name into PATH for recursive call */
+ strcpy(path, name);
+ for (p = path + strlen(path); p > path; p--)
+ if (p[-1] == '/') {
+ *--p = '\0';
+ break;
+ }
+
+ if (p == path) {
+ message("invalid path name \"%s\"", name);
+ return FALSE; /* no more parent. */
+ }
+
+ if (GETSTAT(path, &stbuf) >= 0) {
+ if (is_directory(&stbuf))
+ return TRUE;
+ }
+
+ if (verbose)
+ message("Making directory \"%s\".", path);
#if defined __MINGW32__
if (mkdir(path) >= 0)
return TRUE;
#else
- if (mkdir(path, 0777) >= 0) /* try */
- return TRUE; /* successful done. */
+ if (mkdir(path, 0777) >= 0) /* try */
+ return TRUE; /* successful done. */
#endif
- if (!make_parent_path(path))
- return FALSE;
+ if (!make_parent_path(path))
+ return FALSE;
#if defined __MINGW32__
if (mkdir(path) < 0) { /* try again */
return FALSE;
}
#else
- if (mkdir(path, 0777) < 0) { /* try again */
+ if (mkdir(path, 0777) < 0) { /* try again */
error("Cannot make directory \"%s\"", path);
return FALSE;
- }
+ }
#endif
- return TRUE;
+ return TRUE;
}
/* ------------------------------------------------------------------------ */
static FILE *
open_with_make_path(name)
- char *name;
+ char *name;
{
- FILE *fp;
-
- if ((fp = fopen(name, WRITE_BINARY)) == NULL) {
- if (!make_parent_path(name) ||
- (fp = fopen(name, WRITE_BINARY)) == NULL)
- error("Cannot extract a file \"%s\"", name);
- }
- return fp;
+ FILE *fp;
+
+ if ((fp = fopen(name, WRITE_BINARY)) == NULL) {
+ if (!make_parent_path(name) ||
+ (fp = fopen(name, WRITE_BINARY)) == NULL)
+ error("Cannot extract a file \"%s\"", name);
+ }
+ return fp;
}
/* ------------------------------------------------------------------------ */
static void
adjust_info(name, hdr)
- char *name;
- LzHeader *hdr;
+ char *name;
+ LzHeader *hdr;
{
struct utimbuf utimebuf;
- /* adjust file stamp */
- utimebuf.actime = utimebuf.modtime = hdr->unix_last_modified_stamp;
+ /* adjust file stamp */
+ utimebuf.actime = utimebuf.modtime = hdr->unix_last_modified_stamp;
- if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK)
- utime(name, &utimebuf);
+ if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK)
+ utime(name, &utimebuf);
- if (hdr->extend_type == EXTEND_UNIX
- || hdr->extend_type == EXTEND_OS68K
- || hdr->extend_type == EXTEND_XOSK) {
+ if (hdr->extend_type == EXTEND_UNIX
+ || hdr->extend_type == EXTEND_OS68K
+ || hdr->extend_type == EXTEND_XOSK) {
#ifdef NOT_COMPATIBLE_MODE
- Please need your modification in this space.
+ Please need your modification in this space.
#else
- if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK)
- chmod(name, hdr->unix_mode);
+ if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) != UNIX_FILE_SYMLINK)
+ chmod(name, hdr->unix_mode);
#endif
- if (!getuid()){
+ if (!getuid()){
uid_t uid = hdr->unix_uid;
gid_t gid = hdr->unix_gid;
#endif
#if HAVE_LCHOWN
- if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK)
- lchown(name, uid, gid);
- else
+ if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK)
+ lchown(name, uid, gid);
+ else
#endif /* HAVE_LCHWON */
- chown(name, uid, gid);
- }
- }
+ chown(name, uid, gid);
+ }
+ }
}
/* ------------------------------------------------------------------------ */
static void
extract_one(afp, hdr)
- FILE *afp; /* archive file */
- LzHeader *hdr;
+ FILE *afp; /* archive file */
+ LzHeader *hdr;
{
- FILE *fp; /* output file */
- struct stat stbuf;
- char name[FILENAME_LENGTH];
- unsigned int crc;
- int method;
- boolean save_quiet, save_verbose, up_flag;
- char *q = hdr->name, c;
-
- if (ignore_directory && strrchr(hdr->name, '/')) {
- q = (char *) strrchr(hdr->name, '/') + 1;
- }
- else {
- if (*q == '/') {
- q++;
- /*
- * if OSK then strip device name
- */
- if (hdr->extend_type == EXTEND_OS68K
- || hdr->extend_type == EXTEND_XOSK) {
- do
- c = (*q++);
- while (c && c != '/');
- if (!c || !*q)
- q = "."; /* if device name only */
- }
- }
- }
-
- if (extract_directory)
- xsnprintf(name, sizeof(name), "%s/%s", extract_directory, q);
- else
- strcpy(name, q);
-
-
- /* LZHDIRS_METHOD¤ò»ý¤Ä¥Ø¥Ã¥À¤ò¥Á¥§¥Ã¥¯¤¹¤ë */
- /* 1999.4.30 t.okamoto */
- for (method = 0;; method++) {
- if (methods[method] == NULL) {
- error("Unknown method \"%.*s\"; \"%s\" will be skiped ...",
+ FILE *fp; /* output file */
+ struct stat stbuf;
+ char name[FILENAME_LENGTH];
+ unsigned int crc;
+ int method;
+ boolean save_quiet, save_verbose, up_flag;
+ char *q = hdr->name, c;
+
+ if (ignore_directory && strrchr(hdr->name, '/')) {
+ q = (char *) strrchr(hdr->name, '/') + 1;
+ }
+ else {
+ if (*q == '/') {
+ q++;
+ /*
+ * if OSK then strip device name
+ */
+ if (hdr->extend_type == EXTEND_OS68K
+ || hdr->extend_type == EXTEND_XOSK) {
+ do
+ c = (*q++);
+ while (c && c != '/');
+ if (!c || !*q)
+ q = "."; /* if device name only */
+ }
+ }
+ }
+
+ if (extract_directory)
+ xsnprintf(name, sizeof(name), "%s/%s", extract_directory, q);
+ else
+ strcpy(name, q);
+
+
+ /* LZHDIRS_METHOD¤ò»ý¤Ä¥Ø¥Ã¥À¤ò¥Á¥§¥Ã¥¯¤¹¤ë */
+ /* 1999.4.30 t.okamoto */
+ for (method = 0;; method++) {
+ if (methods[method] == NULL) {
+ error("Unknown method \"%.*s\"; \"%s\" will be skiped ...",
5, hdr->method, name);
- return;
- }
- if (memcmp(hdr->method, methods[method], 5) == 0)
- break;
- }
-
- if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_REGULAR
- && method != LZHDIRS_METHOD_NUM) {
+ return;
+ }
+ if (memcmp(hdr->method, methods[method], 5) == 0)
+ break;
+ }
+
+ if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_REGULAR
+ && method != LZHDIRS_METHOD_NUM) {
extract_regular:
#if 0
- for (method = 0;; method++) {
- if (methods[method] == NULL) {
+ for (method = 0;; method++) {
+ if (methods[method] == NULL) {
error("Unknown method \"%.*s\"; \"%s\" will be skiped ...",
5, hdr->method, name);
- return;
- }
- if (memcmp(hdr->method, methods[method], 5) == 0)
- break;
- }
+ return;
+ }
+ if (memcmp(hdr->method, methods[method], 5) == 0)
+ break;
+ }
#endif
- reading_filename = archive_name;
- writing_filename = name;
- if (output_to_stdout || verify_mode) {
- if (noexec) {
- printf("%s %s\n", verify_mode ? "VERIFY" : "EXTRACT", name);
- if (afp == stdin) {
- int i = hdr->packed_size;
- while (i--)
- fgetc(afp);
- }
- return;
- }
-
- save_quiet = quiet;
- save_verbose = verbose;
- if (!quiet && output_to_stdout) {
- printf("::::::::\n%s\n::::::::\n", name);
- quiet = TRUE;
- verbose = FALSE;
- }
- else if (verify_mode) {
- quiet = FALSE;
- verbose = TRUE;
- }
+ reading_filename = archive_name;
+ writing_filename = name;
+ if (output_to_stdout || verify_mode) {
+ if (noexec) {
+ printf("%s %s\n", verify_mode ? "VERIFY" : "EXTRACT", name);
+ if (afp == stdin) {
+ int i = hdr->packed_size;
+ while (i--)
+ fgetc(afp);
+ }
+ return;
+ }
+
+ save_quiet = quiet;
+ save_verbose = verbose;
+ if (!quiet && output_to_stdout) {
+ printf("::::::::\n%s\n::::::::\n", name);
+ quiet = TRUE;
+ verbose = FALSE;
+ }
+ else if (verify_mode) {
+ quiet = FALSE;
+ verbose = TRUE;
+ }
#if __MINGW32__
{
old_mode = setmode(fileno(stdout), O_BINARY);
#endif
- crc = decode_lzhuf
- (afp, stdout, hdr->original_size, hdr->packed_size, name, method);
+ crc = decode_lzhuf
+ (afp, stdout, hdr->original_size, hdr->packed_size, name, method);
#if __MINGW32__
fflush(stdout);
setmode(fileno(stdout), old_mode);
}
#endif
- quiet = save_quiet;
- verbose = save_verbose;
- }
- else {
- if (skip_flg == FALSE) {
- up_flag = inquire_extract(name);
- if (up_flag == FALSE && force == FALSE) {
- return;
- }
- }
-
- if (skip_flg == TRUE) { /* if skip_flg */
- if (stat(name, &stbuf) == 0 && force != TRUE) {
- if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) {
- if (quiet != TRUE)
- printf("%s : Skipped...\n", name);
- return;
- }
- }
- }
- if (noexec) {
- if (afp == stdin) {
- int i = hdr->packed_size;
- while (i--)
- fgetc(afp);
- }
- return;
- }
-
- signal(SIGINT, interrupt);
+ quiet = save_quiet;
+ verbose = save_verbose;
+ }
+ else {
+ if (skip_flg == FALSE) {
+ up_flag = inquire_extract(name);
+ if (up_flag == FALSE && force == FALSE) {
+ return;
+ }
+ }
+
+ if (skip_flg == TRUE) { /* if skip_flg */
+ if (stat(name, &stbuf) == 0 && force != TRUE) {
+ if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) {
+ if (quiet != TRUE)
+ printf("%s : Skipped...\n", name);
+ return;
+ }
+ }
+ }
+ if (noexec) {
+ if (afp == stdin) {
+ int i = hdr->packed_size;
+ while (i--)
+ fgetc(afp);
+ }
+ return;
+ }
+
+ signal(SIGINT, interrupt);
#ifdef SIGHUP
- signal(SIGHUP, interrupt);
+ signal(SIGHUP, interrupt);
#endif
- unlink(name);
- remove_extracting_file_when_interrupt = TRUE;
+ unlink(name);
+ remove_extracting_file_when_interrupt = TRUE;
- if ((fp = open_with_make_path(name)) != NULL) {
- crc = decode_lzhuf
- (afp, fp, hdr->original_size, hdr->packed_size, name, method);
- fclose(fp);
- }
- remove_extracting_file_when_interrupt = FALSE;
- signal(SIGINT, SIG_DFL);
+ if ((fp = open_with_make_path(name)) != NULL) {
+ crc = decode_lzhuf
+ (afp, fp, hdr->original_size, hdr->packed_size, name, method);
+ fclose(fp);
+ }
+ remove_extracting_file_when_interrupt = FALSE;
+ signal(SIGINT, SIG_DFL);
#ifdef SIGHUP
- signal(SIGHUP, SIG_DFL);
+ signal(SIGHUP, SIG_DFL);
#endif
- if (!fp)
- return;
- }
-
- if (hdr->has_crc && crc != hdr->crc)
- error("CRC error: \"%s\"", name);
- }
- else if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_DIRECTORY
- || (hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK
- || method == LZHDIRS_METHOD_NUM) {
- /* ¢¬¤³¤ì¤Ç¡¢Symbolic Link ¤Ï¡¢Âç¾æÉפ«¡© */
- if (!ignore_directory && !verify_mode) {
- if (noexec) {
- if (quiet != TRUE)
- printf("EXTRACT %s (directory)\n", name);
- return;
- }
- /* NAME has trailing SLASH '/', (^_^) */
- if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK) {
- int l_code;
+ if (!fp)
+ return;
+ }
+
+ if (hdr->has_crc && crc != hdr->crc)
+ error("CRC error: \"%s\"", name);
+ }
+ else if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_DIRECTORY
+ || (hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK
+ || method == LZHDIRS_METHOD_NUM) {
+ /* ¢¬¤³¤ì¤Ç¡¢Symbolic Link ¤Ï¡¢Âç¾æÉפ«¡© */
+ if (!ignore_directory && !verify_mode) {
+ if (noexec) {
+ if (quiet != TRUE)
+ printf("EXTRACT %s (directory)\n", name);
+ return;
+ }
+ /* NAME has trailing SLASH '/', (^_^) */
+ if ((hdr->unix_mode & UNIX_FILE_TYPEMASK) == UNIX_FILE_SYMLINK) {
+ int l_code;
#ifdef S_IFLNK
- if (skip_flg == FALSE) {
- up_flag = inquire_extract(name);
- if (up_flag == FALSE && force == FALSE) {
- return;
- }
- } else {
- if (GETSTAT(name, &stbuf) == 0 && force != TRUE) {
- if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) {
- if (quiet != TRUE)
- printf("%s : Skipped...\n", name);
- return;
- }
- }
- }
-
- unlink(name);
+ if (skip_flg == FALSE) {
+ up_flag = inquire_extract(name);
+ if (up_flag == FALSE && force == FALSE) {
+ return;
+ }
+ } else {
+ if (GETSTAT(name, &stbuf) == 0 && force != TRUE) {
+ if (stbuf.st_mtime >= hdr->unix_last_modified_stamp) {
+ if (quiet != TRUE)
+ printf("%s : Skipped...\n", name);
+ return;
+ }
+ }
+ }
+
+ unlink(name);
make_parent_path(name);
- l_code = symlink(hdr->realname, name);
- if (l_code < 0) {
- if (quiet != TRUE)
- warning("Can't make Symbolic Link \"%s\" -> \"%s\"",
+ l_code = symlink(hdr->realname, name);
+ if (l_code < 0) {
+ if (quiet != TRUE)
+ warning("Can't make Symbolic Link \"%s\" -> \"%s\"",
hdr->realname, name);
- }
- if (quiet != TRUE) {
- message("Symbolic Link %s -> %s",
+ }
+ if (quiet != TRUE) {
+ message("Symbolic Link %s -> %s",
hdr->realname, name);
- }
+ }
#else
- warning("Can't make Symbolic Link %s -> %s",
+ warning("Can't make Symbolic Link %s -> %s",
hdr->realname, name);
- return;
+ return;
#endif
- } else { /* make directory */
- if (!output_to_stdout && !make_parent_path(name))
- return;
- }
- }
- }
- else {
+ } else { /* make directory */
+ if (!output_to_stdout && !make_parent_path(name))
+ return;
+ }
+ }
+ }
+ else {
if (force) /* force extract */
goto extract_regular;
else
error("Unknown file type: \"%s\". use `f' option to force extract.", name);
- }
+ }
- if (!output_to_stdout)
- adjust_info(name, hdr);
+ if (!output_to_stdout)
+ adjust_info(name, hdr);
}
/* ------------------------------------------------------------------------ */
-/* EXTRACT COMMAND MAIN */
+/* EXTRACT COMMAND MAIN */
/* ------------------------------------------------------------------------ */
void
cmd_extract()
{
- LzHeader hdr;
- long pos;
- FILE *afp;
-
- /* open archive file */
- if ((afp = open_old_archive()) == NULL)
- fatal_error("Cannot open archive file \"%s\"", archive_name);
-
- if (archive_is_msdos_sfx1(archive_name))
- skip_msdos_sfx1_code(afp);
-
- /* extract each files */
- while (get_header(afp, &hdr)) {
- if (need_file(hdr.name)) {
- pos = ftell(afp);
- extract_one(afp, &hdr);
+ LzHeader hdr;
+ long pos;
+ FILE *afp;
+
+ /* open archive file */
+ if ((afp = open_old_archive()) == NULL)
+ fatal_error("Cannot open archive file \"%s\"", archive_name);
+
+ if (archive_is_msdos_sfx1(archive_name))
+ skip_msdos_sfx1_code(afp);
+
+ /* extract each files */
+ while (get_header(afp, &hdr)) {
+ if (need_file(hdr.name)) {
+ pos = ftell(afp);
+ extract_one(afp, &hdr);
/* when error occurred in extract_one(), should adjust
point of file stream */
- if (afp != stdin)
+ if (afp != stdin)
fseek(afp, pos + hdr.packed_size, SEEK_SET);
else {
/* FIXME: assume that the extract_one() has read
packed_size bytes from stdin. */
long i = 0;
- while (i--) fgetc(afp);
+ while (i--) fgetc(afp);
}
- } else {
- if (afp != stdin)
- fseek(afp, hdr.packed_size, SEEK_CUR);
- else {
- int i = hdr.packed_size;
- while (i--)
- fgetc(afp);
- }
- }
- }
-
- /* close archive file */
- fclose(afp);
-
- return;
-}
+ } else {
+ if (afp != stdin)
+ fseek(afp, hdr.packed_size, SEEK_CUR);
+ else {
+ int i = hdr.packed_size;
+ while (i--)
+ fgetc(afp);
+ }
+ }
+ }
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
+ /* close archive file */
+ fclose(afp);
+
+ return;
+}
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* lhlist.c -- LHarc list */
-/* */
-/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
-/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
-/* Ver. 1.01 Bug Fix for month name 1989.12.25 Y.Tagawa */
-/* Ver. 1.10 Changed list format 1993.10.01 N.Watazaki */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14e Bug Fix for many problems 1999.05.25 T.Okamoto */
+/* LHa for UNIX */
+/* lhlist.c -- LHarc list */
+/* */
+/* Copyright (C) MCMLXXXIX Yooichi.Tagawa */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 0.00 Original 1988.05.23 Y.Tagawa */
+/* Ver. 1.00 Fixed 1989.09.22 Y.Tagawa */
+/* Ver. 1.01 Bug Fix for month name 1989.12.25 Y.Tagawa */
+/* Ver. 1.10 Changed list format 1993.10.01 N.Watazaki */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14e Bug Fix for many problems 1999.05.25 T.Okamoto */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
-/* Print Stuff */
+/* Print Stuff */
/* ------------------------------------------------------------------------ */
/* need 14 or 22 (when verbose_listing is TRUE) column spaces */
static void
print_size(packed_size, original_size)
- long packed_size, original_size;
+ long packed_size, original_size;
{
- if (verbose_listing)
- printf("%7ld ", packed_size);
+ if (verbose_listing)
+ printf("%7ld ", packed_size);
- printf("%7ld ", original_size);
+ printf("%7ld ", original_size);
- if (original_size == 0L)
- printf("******");
- else /* Changed N.Watazaki */
- printf("%5.1f%%", packed_size * 100.0 / original_size);
+ if (original_size == 0L)
+ printf("******");
+ else /* Changed N.Watazaki */
+ printf("%5.1f%%", packed_size * 100.0 / original_size);
}
/* ------------------------------------------------------------------------ */
/* need 12 or 17 (when verbose_listing is TRUE) column spaces */
static void
print_stamp(t)
- time_t t;
+ time_t t;
{
- static unsigned int threshold;
- static char t_month[12 * 3 + 1] = "JanFebMarAprMayJunJulAugSepOctNovDec";
- struct tm *p;
+ static unsigned int threshold;
+ static char t_month[12 * 3 + 1] = "JanFebMarAprMayJunJulAugSepOctNovDec";
+ struct tm *p;
- if (t == 0) {
+ if (t == 0) {
if (verbose_listing && verbose)
printf(" "); /* 19 spaces */
else
- printf(" "); /* 12 spaces */
- return;
- }
+ printf(" "); /* 12 spaces */
+ return;
+ }
- if (!threshold) {
- time_t now = time(0);
- p = localtime(&now);
- threshold = p->tm_year * 12 + p->tm_mon - 6;
- }
+ if (!threshold) {
+ time_t now = time(0);
+ p = localtime(&now);
+ threshold = p->tm_year * 12 + p->tm_mon - 6;
+ }
- p = localtime(&t);
+ p = localtime(&t);
if (verbose_listing && verbose)
printf("%04d-%02d-%02d %02d:%02d:%02d",
p->tm_year+1900, p->tm_mon+1, p->tm_mday,
p->tm_hour, p->tm_min, p->tm_sec);
- else if (p->tm_year * 12 + p->tm_mon > threshold)
- printf("%.3s %2d %02d:%02d",
- &t_month[p->tm_mon * 3], p->tm_mday, p->tm_hour, p->tm_min);
- else
- printf("%.3s %2d %04d",
- &t_month[p->tm_mon * 3], p->tm_mday, p->tm_year + 1900);
+ else if (p->tm_year * 12 + p->tm_mon > threshold)
+ printf("%.3s %2d %02d:%02d",
+ &t_month[p->tm_mon * 3], p->tm_mday, p->tm_hour, p->tm_min);
+ else
+ printf("%.3s %2d %04d",
+ &t_month[p->tm_mon * 3], p->tm_mday, p->tm_year + 1900);
}
/* ------------------------------------------------------------------------ */
}
/* ------------------------------------------------------------------------ */
-/* */
+/* */
/* ------------------------------------------------------------------------ */
static void
list_header()
else
printf("PERMISSION UID GID SIZE RATIO STAMP NAME\n");
}
- print_bar();
+ print_bar();
}
/* ------------------------------------------------------------------------ */
static void
list_one(hdr)
- register LzHeader *hdr;
+ register LzHeader *hdr;
{
- register int mode = 0;
- register char *p;
- char method[6];
- char modebits[11];
+ register int mode = 0;
+ register char *p;
+ char method[6];
+ char modebits[11];
if (verbose) {
if ((hdr->unix_mode & UNIX_FILE_SYMLINK) != UNIX_FILE_SYMLINK)
printf("%s -> %s\n", hdr->realname, hdr->name);
}
- strncpy(method, hdr->method, 5);
- method[5] = '\0';
-
- switch (hdr->extend_type) {
- case EXTEND_UNIX:
- mode = hdr->unix_mode;
-
- if (mode & UNIX_FILE_DIRECTORY)
- modebits[0] = 'd';
- else if ((mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK)
- modebits[0] = 'l';
- else
- modebits[0] = '-';
- modebits[1] = ((mode & UNIX_OWNER_READ_PERM) ? 'r' : '-');
- modebits[2] = ((mode & UNIX_OWNER_WRITE_PERM) ? 'w' : '-');
- modebits[3] = (mode & UNIX_SETUID) ? 's' :
- ((mode & UNIX_OWNER_EXEC_PERM) ? 'x' : '-');
- modebits[4] = ((mode & UNIX_GROUP_READ_PERM) ? 'r' : '-');
- modebits[5] = ((mode & UNIX_GROUP_WRITE_PERM) ? 'w' : '-');
- modebits[6] = (mode & UNIX_SETGID) ? 's' :
- ((mode & UNIX_GROUP_EXEC_PERM) ? 'x' : '-');
- modebits[7] = ((mode & UNIX_OTHER_READ_PERM) ? 'r' : '-');
- modebits[8] = ((mode & UNIX_OTHER_WRITE_PERM) ? 'w' : '-');
- modebits[9] = (mode & UNIX_STICKYBIT) ? 't' :
- ((mode & UNIX_OTHER_EXEC_PERM) ? 'x' : '-');
- modebits[10] = 0;
+ strncpy(method, hdr->method, 5);
+ method[5] = '\0';
+
+ switch (hdr->extend_type) {
+ case EXTEND_UNIX:
+ mode = hdr->unix_mode;
+
+ if (mode & UNIX_FILE_DIRECTORY)
+ modebits[0] = 'd';
+ else if ((mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK)
+ modebits[0] = 'l';
+ else
+ modebits[0] = '-';
+ modebits[1] = ((mode & UNIX_OWNER_READ_PERM) ? 'r' : '-');
+ modebits[2] = ((mode & UNIX_OWNER_WRITE_PERM) ? 'w' : '-');
+ modebits[3] = (mode & UNIX_SETUID) ? 's' :
+ ((mode & UNIX_OWNER_EXEC_PERM) ? 'x' : '-');
+ modebits[4] = ((mode & UNIX_GROUP_READ_PERM) ? 'r' : '-');
+ modebits[5] = ((mode & UNIX_GROUP_WRITE_PERM) ? 'w' : '-');
+ modebits[6] = (mode & UNIX_SETGID) ? 's' :
+ ((mode & UNIX_GROUP_EXEC_PERM) ? 'x' : '-');
+ modebits[7] = ((mode & UNIX_OTHER_READ_PERM) ? 'r' : '-');
+ modebits[8] = ((mode & UNIX_OTHER_WRITE_PERM) ? 'w' : '-');
+ modebits[9] = (mode & UNIX_STICKYBIT) ? 't' :
+ ((mode & UNIX_OTHER_EXEC_PERM) ? 'x' : '-');
+ modebits[10] = 0;
printf("%s ", modebits);
- break;
- case EXTEND_OS68K:
- /**/ case EXTEND_XOSK:/**/
- mode = hdr->unix_mode;
- printf("%c%c%c%c%c%c%c%c ",
- ((mode & OSK_DIRECTORY_PERM) ? 'd' : '-'),
- ((mode & OSK_SHARED_PERM) ? 's' : '-'),
- ((mode & OSK_OTHER_EXEC_PERM) ? 'e' : '-'),
- ((mode & OSK_OTHER_WRITE_PERM) ? 'w' : '-'),
- ((mode & OSK_OTHER_READ_PERM) ? 'r' : '-'),
- ((mode & OSK_OWNER_EXEC_PERM) ? 'e' : '-'),
- ((mode & OSK_OWNER_WRITE_PERM) ? 'w' : '-'),
- ((mode & OSK_OWNER_READ_PERM) ? 'r' : '-'));
-
- break;
- default:
- switch (hdr->extend_type) { /* max 18 characters */
- case EXTEND_GENERIC:
- p = "[generic]";
- break;
- case EXTEND_CPM:
- p = "[CP/M]";
- break;
- case EXTEND_FLEX:
- p = "[FLEX]";
- break;
- case EXTEND_OS9:
- p = "[OS-9]";
- break;
- case EXTEND_OS68K:
- p = "[OS-9/68K]";
- break;
- case EXTEND_MSDOS:
- p = "[MS-DOS]";
- break;
- case EXTEND_MACOS:
- p = "[Mac OS]";
- break;
- case EXTEND_OS2:
- p = "[OS/2]";
- break;
- case EXTEND_HUMAN:
- p = "[Human68K]";
- break;
- case EXTEND_OS386:
- p = "[OS-386]";
- break;
- case EXTEND_RUNSER:
- p = "[Runser]";
- break;
+ break;
+ case EXTEND_OS68K:
+ /**/ case EXTEND_XOSK:/**/
+ mode = hdr->unix_mode;
+ printf("%c%c%c%c%c%c%c%c ",
+ ((mode & OSK_DIRECTORY_PERM) ? 'd' : '-'),
+ ((mode & OSK_SHARED_PERM) ? 's' : '-'),
+ ((mode & OSK_OTHER_EXEC_PERM) ? 'e' : '-'),
+ ((mode & OSK_OTHER_WRITE_PERM) ? 'w' : '-'),
+ ((mode & OSK_OTHER_READ_PERM) ? 'r' : '-'),
+ ((mode & OSK_OWNER_EXEC_PERM) ? 'e' : '-'),
+ ((mode & OSK_OWNER_WRITE_PERM) ? 'w' : '-'),
+ ((mode & OSK_OWNER_READ_PERM) ? 'r' : '-'));
+
+ break;
+ default:
+ switch (hdr->extend_type) { /* max 18 characters */
+ case EXTEND_GENERIC:
+ p = "[generic]";
+ break;
+ case EXTEND_CPM:
+ p = "[CP/M]";
+ break;
+ case EXTEND_FLEX:
+ p = "[FLEX]";
+ break;
+ case EXTEND_OS9:
+ p = "[OS-9]";
+ break;
+ case EXTEND_OS68K:
+ p = "[OS-9/68K]";
+ break;
+ case EXTEND_MSDOS:
+ p = "[MS-DOS]";
+ break;
+ case EXTEND_MACOS:
+ p = "[Mac OS]";
+ break;
+ case EXTEND_OS2:
+ p = "[OS/2]";
+ break;
+ case EXTEND_HUMAN:
+ p = "[Human68K]";
+ break;
+ case EXTEND_OS386:
+ p = "[OS-386]";
+ break;
+ case EXTEND_RUNSER:
+ p = "[Runser]";
+ break;
#ifdef EXTEND_TOWNSOS
- /* This ID isn't fixed */
- case EXTEND_TOWNSOS:
- p = "[TownsOS]";
- break;
+ /* This ID isn't fixed */
+ case EXTEND_TOWNSOS:
+ p = "[TownsOS]";
+ break;
#endif
- case EXTEND_JAVA:
+ case EXTEND_JAVA:
p = "[JAVA]";
break;
- /* Ouch! Please customize it's ID. */
- default:
- p = "[unknown]";
- break;
- }
- printf("%-11.11s", p);
- break;
- }
+ /* Ouch! Please customize it's ID. */
+ default:
+ p = "[unknown]";
+ break;
+ }
+ printf("%-11.11s", p);
+ break;
+ }
switch (hdr->extend_type) {
case EXTEND_UNIX:
break;
}
- print_size(hdr->packed_size, hdr->original_size);
+ print_size(hdr->packed_size, hdr->original_size);
- if (verbose_listing) {
- if (hdr->has_crc)
- printf(" %s %04x", method, hdr->crc);
- else
- printf(" %s ****", method);
+ if (verbose_listing) {
+ if (hdr->has_crc)
+ printf(" %s %04x", method, hdr->crc);
+ else
+ printf(" %s ****", method);
}
- printf(" ");
- print_stamp(hdr->unix_last_modified_stamp);
+ printf(" ");
+ print_stamp(hdr->unix_last_modified_stamp);
- if (!verbose) {
- if ((hdr->unix_mode & UNIX_FILE_SYMLINK) != UNIX_FILE_SYMLINK)
- printf(" %s", hdr->name);
- else {
- printf(" %s -> %s", hdr->realname, hdr->name);
- }
+ if (!verbose) {
+ if ((hdr->unix_mode & UNIX_FILE_SYMLINK) != UNIX_FILE_SYMLINK)
+ printf(" %s", hdr->name);
+ else {
+ printf(" %s -> %s", hdr->realname, hdr->name);
+ }
}
- if (verbose)
- printf(" [%d]", hdr->header_level);
- printf("\n");
+ if (verbose)
+ printf(" [%d]", hdr->header_level);
+ printf("\n");
}
int list_files;
unsigned long packed_size_total, original_size_total;
{
- struct stat stbuf;
+ struct stat stbuf;
- print_bar();
+ print_bar();
- printf(" Total %9d file%c ",
- list_files, (list_files == 1) ? ' ' : 's');
- print_size(packed_size_total, original_size_total);
- printf(" ");
+ printf(" Total %9d file%c ",
+ list_files, (list_files == 1) ? ' ' : 's');
+ print_size(packed_size_total, original_size_total);
+ printf(" ");
- if (verbose_listing)
- printf(" ");
+ if (verbose_listing)
+ printf(" ");
- if (stat(archive_name, &stbuf) < 0)
- print_stamp((time_t) 0);
- else
- print_stamp(stbuf.st_mtime);
+ if (stat(archive_name, &stbuf) < 0)
+ print_stamp((time_t) 0);
+ else
+ print_stamp(stbuf.st_mtime);
- printf("\n");
+ printf("\n");
}
/* ------------------------------------------------------------------------ */
-/* LIST COMMAND MAIN */
+/* LIST COMMAND MAIN */
/* ------------------------------------------------------------------------ */
void
cmd_list()
{
- FILE *afp;
- LzHeader hdr;
- int i;
+ FILE *afp;
+ LzHeader hdr;
+ int i;
unsigned long packed_size_total;
unsigned long original_size_total;
int list_files;
- /* initialize total count */
- packed_size_total = 0L;
- original_size_total = 0L;
- list_files = 0;
-
- /* open archive file */
- if ((afp = open_old_archive()) == NULL) {
- error("Cannot open archive \"%s\"", archive_name);
- exit(1);
- }
- if (archive_is_msdos_sfx1(archive_name))
- skip_msdos_sfx1_code(afp);
-
- /* print header message */
- if (!quiet)
- list_header();
-
- /* print each file information */
- while (get_header(afp, &hdr)) {
- if (need_file(hdr.name)) {
- list_one(&hdr);
- list_files++;
- packed_size_total += hdr.packed_size;
- original_size_total += hdr.original_size;
- }
-
- if (afp != stdin)
- fseek(afp, hdr.packed_size, SEEK_CUR);
- else {
- i = hdr.packed_size;
- while (i--)
- fgetc(afp);
- }
- }
-
- /* close archive file */
- fclose(afp);
-
- /* print tailer message */
- if (!quiet)
- list_tailer(list_files, packed_size_total, original_size_total);
-
- return;
-}
+ /* initialize total count */
+ packed_size_total = 0L;
+ original_size_total = 0L;
+ list_files = 0;
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* compile-command:"gcc -c lhlist.c" */
-/* End: */
-/* vi: set tabstop=4: */
+ /* open archive file */
+ if ((afp = open_old_archive()) == NULL) {
+ error("Cannot open archive \"%s\"", archive_name);
+ exit(1);
+ }
+ if (archive_is_msdos_sfx1(archive_name))
+ skip_msdos_sfx1_code(afp);
+
+ /* print header message */
+ if (!quiet)
+ list_header();
+
+ /* print each file information */
+ while (get_header(afp, &hdr)) {
+ if (need_file(hdr.name)) {
+ list_one(&hdr);
+ list_files++;
+ packed_size_total += hdr.packed_size;
+ original_size_total += hdr.original_size;
+ }
+
+ if (afp != stdin)
+ fseek(afp, hdr.packed_size, SEEK_CUR);
+ else {
+ i = hdr.packed_size;
+ while (i--)
+ fgetc(afp);
+ }
+ }
+
+ /* close archive file */
+ fclose(afp);
+
+ /* print tailer message */
+ if (!quiet)
+ list_tailer(list_files, packed_size_total, original_size_total);
+
+ return;
+}
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* maketbl.c -- makes decoding table */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* maketbl.c -- makes decoding table */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
void
make_table(nchar, bitlen, tablebits, table)
- short nchar;
- unsigned char bitlen[];
- short tablebits;
- unsigned short table[];
+ short nchar;
+ unsigned char bitlen[];
+ short tablebits;
+ unsigned short table[];
{
- unsigned short count[17]; /* count of bitlen */
- unsigned short weight[17]; /* 0x10000ul >> bitlen */
- unsigned short start[17]; /* first code of bitlen */
- unsigned short total;
- unsigned int i, l;
- int j, k, m, n, avail;
- unsigned short *p;
+ unsigned short count[17]; /* count of bitlen */
+ unsigned short weight[17]; /* 0x10000ul >> bitlen */
+ unsigned short start[17]; /* first code of bitlen */
+ unsigned short total;
+ unsigned int i, l;
+ int j, k, m, n, avail;
+ unsigned short *p;
- avail = nchar;
+ avail = nchar;
- /* initialize */
- for (i = 1; i <= 16; i++) {
- count[i] = 0;
- weight[i] = 1 << (16 - i);
- }
+ /* initialize */
+ for (i = 1; i <= 16; i++) {
+ count[i] = 0;
+ weight[i] = 1 << (16 - i);
+ }
- /* count */
- for (i = 0; i < nchar; i++)
- count[bitlen[i]]++;
+ /* count */
+ for (i = 0; i < nchar; i++)
+ count[bitlen[i]]++;
- /* calculate first code */
- total = 0;
- for (i = 1; i <= 16; i++) {
- start[i] = total;
- total += weight[i] * count[i];
- }
- if ((total & 0xffff) != 0)
- error("make_table(): Bad table (5)");
+ /* calculate first code */
+ total = 0;
+ for (i = 1; i <= 16; i++) {
+ start[i] = total;
+ total += weight[i] * count[i];
+ }
+ if ((total & 0xffff) != 0)
+ error("make_table(): Bad table (5)");
- /* shift data for make table. */
- m = 16 - tablebits;
- for (i = 1; i <= tablebits; i++) {
- start[i] >>= m;
- weight[i] >>= m;
- }
+ /* shift data for make table. */
+ m = 16 - tablebits;
+ for (i = 1; i <= tablebits; i++) {
+ start[i] >>= m;
+ weight[i] >>= m;
+ }
- /* initialize */
- j = start[tablebits + 1] >> m;
- k = 1 << tablebits;
- if (j != 0)
- for (i = j; i < k; i++)
- table[i] = 0;
+ /* initialize */
+ j = start[tablebits + 1] >> m;
+ k = 1 << tablebits;
+ if (j != 0)
+ for (i = j; i < k; i++)
+ table[i] = 0;
- /* create table and tree */
- for (j = 0; j < nchar; j++) {
- k = bitlen[j];
- if (k == 0)
- continue;
- l = start[k] + weight[k];
- if (k <= tablebits) {
- /* code in table */
- for (i = start[k]; i < l; i++)
- table[i] = j;
- }
- else {
- /* code not in table */
- p = &table[(i = start[k]) >> m];
- i <<= tablebits;
- n = k - tablebits;
- /* make tree (n length) */
- while (--n >= 0) {
- if (*p == 0) {
- right[avail] = left[avail] = 0;
- *p = avail++;
- }
- if (i & 0x8000)
- p = &right[*p];
- else
- p = &left[*p];
- i <<= 1;
- }
- *p = j;
- }
- start[k] = l;
- }
+ /* create table and tree */
+ for (j = 0; j < nchar; j++) {
+ k = bitlen[j];
+ if (k == 0)
+ continue;
+ l = start[k] + weight[k];
+ if (k <= tablebits) {
+ /* code in table */
+ for (i = start[k]; i < l; i++)
+ table[i] = j;
+ }
+ else {
+ /* code not in table */
+ p = &table[(i = start[k]) >> m];
+ i <<= tablebits;
+ n = k - tablebits;
+ /* make tree (n length) */
+ while (--n >= 0) {
+ if (*p == 0) {
+ right[avail] = left[avail] = 0;
+ *p = avail++;
+ }
+ if (i & 0x8000)
+ p = &right[*p];
+ else
+ p = &left[*p];
+ i <<= 1;
+ }
+ *p = j;
+ }
+ start[k] = l;
+ }
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* maketree.c -- make Huffman tree */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* maketree.c -- make Huffman tree */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/* ------------------------------------------------------------------------ */
void
make_code(n, len, code)
- int n;
- unsigned char len[];
- unsigned short code[];
+ int n;
+ unsigned char len[];
+ unsigned short code[];
{
- unsigned short weight[17]; /* 0x10000ul >> bitlen */
- unsigned short start[17]; /* start code */
- unsigned short j, k;
- int i;
+ unsigned short weight[17]; /* 0x10000ul >> bitlen */
+ unsigned short start[17]; /* start code */
+ unsigned short j, k;
+ int i;
- j = 0;
- k = 1 << (16 - 1);
- for (i = 1; i <= 16; i++) {
- start[i] = j;
- j += (weight[i] = k) * len_cnt[i];
- k >>= 1;
- }
- for (i = 0; i < n; i++) {
- j = len[i];
- code[i] = start[j];
- start[j] += weight[j];
- }
+ j = 0;
+ k = 1 << (16 - 1);
+ for (i = 1; i <= 16; i++) {
+ start[i] = j;
+ j += (weight[i] = k) * len_cnt[i];
+ k >>= 1;
+ }
+ for (i = 0; i < n; i++) {
+ j = len[i];
+ code[i] = start[j];
+ start[j] += weight[j];
+ }
}
/* ------------------------------------------------------------------------ */
static void
-count_len(i) /* call with i = root */
- int i;
+count_len(i) /* call with i = root */
+ int i;
{
- static unsigned char depth = 0;
+ static unsigned char depth = 0;
- if (i < n)
- len_cnt[depth < 16 ? depth : 16]++;
- else {
- depth++;
- count_len(left[i]);
- count_len(right[i]);
- depth--;
- }
+ if (i < n)
+ len_cnt[depth < 16 ? depth : 16]++;
+ else {
+ depth++;
+ count_len(left[i]);
+ count_len(right[i]);
+ depth--;
+ }
}
/* ------------------------------------------------------------------------ */
static void
make_len(root)
- int root;
+ int root;
{
- int i, k;
- unsigned int cum;
+ int i, k;
+ unsigned int cum;
- for (i = 0; i <= 16; i++)
- len_cnt[i] = 0;
- count_len(root);
- cum = 0;
- for (i = 16; i > 0; i--) {
- cum += len_cnt[i] << (16 - i);
- }
+ for (i = 0; i <= 16; i++)
+ len_cnt[i] = 0;
+ count_len(root);
+ cum = 0;
+ for (i = 16; i > 0; i--) {
+ cum += len_cnt[i] << (16 - i);
+ }
#if (UINT_MAX != 0xffff)
- cum &= 0xffff;
+ cum &= 0xffff;
#endif
- /* adjust len */
- if (cum) {
- fprintf(stderr, "17");
- len_cnt[16] -= cum; /* always len_cnt[16] > cum */
- do {
- for (i = 15; i > 0; i--) {
- if (len_cnt[i]) {
- len_cnt[i]--;
- len_cnt[i + 1] += 2;
- break;
- }
- }
- } while (--cum);
- }
- /* make len */
- for (i = 16; i > 0; i--) {
- k = len_cnt[i];
- while (k > 0) {
- len[*sort++] = i;
- k--;
- }
- }
+ /* adjust len */
+ if (cum) {
+ fprintf(stderr, "17");
+ len_cnt[16] -= cum; /* always len_cnt[16] > cum */
+ do {
+ for (i = 15; i > 0; i--) {
+ if (len_cnt[i]) {
+ len_cnt[i]--;
+ len_cnt[i + 1] += 2;
+ break;
+ }
+ }
+ } while (--cum);
+ }
+ /* make len */
+ for (i = 16; i > 0; i--) {
+ k = len_cnt[i];
+ while (k > 0) {
+ len[*sort++] = i;
+ k--;
+ }
+ }
}
/* ------------------------------------------------------------------------ */
static void
downheap(i)
/* priority queue; send i-th entry down heap */
- int i;
+ int i;
{
- short j, k;
+ short j, k;
- k = heap[i];
- while ((j = 2 * i) <= heapsize) {
- if (j < heapsize && freq[heap[j]] > freq[heap[j + 1]])
- j++;
- if (freq[k] <= freq[heap[j]])
- break;
- heap[i] = heap[j];
- i = j;
- }
- heap[i] = k;
+ k = heap[i];
+ while ((j = 2 * i) <= heapsize) {
+ if (j < heapsize && freq[heap[j]] > freq[heap[j + 1]])
+ j++;
+ if (freq[k] <= freq[heap[j]])
+ break;
+ heap[i] = heap[j];
+ i = j;
+ }
+ heap[i] = k;
}
/* ------------------------------------------------------------------------ */
short
make_tree(nparm, freqparm, lenparm, codeparm)
/* make tree, calculate len[], return root */
- int nparm;
- unsigned short freqparm[];
- unsigned char lenparm[];
- unsigned short codeparm[];
+ int nparm;
+ unsigned short freqparm[];
+ unsigned char lenparm[];
+ unsigned short codeparm[];
{
- short i, j, k, avail;
+ short i, j, k, avail;
- n = nparm;
- freq = freqparm;
- len = lenparm;
- avail = n;
- heapsize = 0;
- heap[1] = 0;
- for (i = 0; i < n; i++) {
- len[i] = 0;
- if (freq[i])
- heap[++heapsize] = i;
- }
- if (heapsize < 2) {
- codeparm[heap[1]] = 0;
- return heap[1];
- }
- for (i = heapsize / 2; i >= 1; i--)
- downheap(i); /* make priority queue */
- sort = codeparm;
- do { /* while queue has at least two entries */
- i = heap[1]; /* take out least-freq entry */
- if (i < n)
- *sort++ = i;
- heap[1] = heap[heapsize--];
- downheap(1);
- j = heap[1]; /* next least-freq entry */
- if (j < n)
- *sort++ = j;
- k = avail++; /* generate new node */
- freq[k] = freq[i] + freq[j];
- heap[1] = k;
- downheap(1); /* put into queue */
- left[k] = i;
- right[k] = j;
- } while (heapsize > 1);
- sort = codeparm;
- make_len(k);
- make_code(nparm, lenparm, codeparm);
- return k; /* return root */
+ n = nparm;
+ freq = freqparm;
+ len = lenparm;
+ avail = n;
+ heapsize = 0;
+ heap[1] = 0;
+ for (i = 0; i < n; i++) {
+ len[i] = 0;
+ if (freq[i])
+ heap[++heapsize] = i;
+ }
+ if (heapsize < 2) {
+ codeparm[heap[1]] = 0;
+ return heap[1];
+ }
+ for (i = heapsize / 2; i >= 1; i--)
+ downheap(i); /* make priority queue */
+ sort = codeparm;
+ do { /* while queue has at least two entries */
+ i = heap[1]; /* take out least-freq entry */
+ if (i < n)
+ *sort++ = i;
+ heap[1] = heap[heapsize--];
+ downheap(1);
+ j = heap[1]; /* next least-freq entry */
+ if (j < n)
+ *sort++ = j;
+ k = avail++; /* generate new node */
+ freq[k] = freq[i] + freq[j];
+ heap[1] = k;
+ downheap(1); /* put into queue */
+ left[k] = i;
+ right[k] = j;
+ } while (heapsize > 1);
+ sort = codeparm;
+ make_len(k);
+ make_code(nparm, lenparm, codeparm);
+ return k; /* return root */
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* patmatch.c -- path check */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* patmatch.c -- path check */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include <stdio.h>
*/
int
patmatch(p, s, f)
- register char *p; /* pattern */
- register char *s; /* string to match */
- int f; /* flag for case force */
+ register char *p; /* pattern */
+ register char *s; /* string to match */
+ int f; /* flag for case force */
{
- char pc; /* a single character from pattern */
+ char pc; /* a single character from pattern */
- while (pc = ((f && islower(*p)) ? toupper(*p++) : *p++)) {
- if (pc == '*') {
- do { /* look for match till s exhausted */
- if (patmatch(p, s, f))
- return (1);
- } while (*s++);
- return (0);
- }
- else if (*s == 0)
- return (0); /* s exhausted, p not */
- else if (pc == '?')
- s++; /* matches all, just bump */
- else if (pc != ((f && islower(*s)) ? toupper(*s++) : *s++))
- return (0);
- }
- return (!*s); /* p exhausted, ret true if s exhausted */
+ while (pc = ((f && islower(*p)) ? toupper(*p++) : *p++)) {
+ if (pc == '*') {
+ do { /* look for match till s exhausted */
+ if (patmatch(p, s, f))
+ return (1);
+ } while (*s++);
+ return (0);
+ }
+ else if (*s == 0)
+ return (0); /* s exhausted, p not */
+ else if (pc == '?')
+ s++; /* matches all, just bump */
+ else if (pc != ((f && islower(*s)) ? toupper(*s++) : *s++))
+ return (0);
+ }
+ return (!*s); /* p exhausted, ret true if s exhausted */
}
-
-/* Local Variables: */
-/* tab-width : 4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* shuf.c -- extract static Huffman coding */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* LHa for UNIX */
+/* shuf.c -- extract static Huffman coding */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
/* ------------------------------------------------------------------------ */
#include "lha.h"
#undef NP
#undef NP2
-#define NP (8 * 1024 / 64)
-#define NP2 (NP * 2 - 1)
+#define NP (8 * 1024 / 64)
+#define NP2 (NP * 2 - 1)
/* ------------------------------------------------------------------------ */
static unsigned int np;
int fixed[2][16] = {
- {3, 0x01, 0x04, 0x0c, 0x18, 0x30, 0}, /* old compatible */
- {2, 0x01, 0x01, 0x03, 0x06, 0x0D, 0x1F, 0x4E, 0} /* 8K buf */
+ {3, 0x01, 0x04, 0x0c, 0x18, 0x30, 0}, /* old compatible */
+ {2, 0x01, 0x01, 0x03, 0x06, 0x0D, 0x1F, 0x4E, 0} /* 8K buf */
};
/* ------------------------------------------------------------------------ */
/* lh3 */
void
decode_start_st0( /*void*/ )
{
- n_max = 286;
- maxmatch = MAXMATCH;
- init_getbits();
+ n_max = 286;
+ maxmatch = MAXMATCH;
+ init_getbits();
init_code_cache();
#ifdef SUPPORT_LH7
- np = 1 << (MAX_DICBIT - 7);
+ np = 1 << (MAX_DICBIT - 7);
#endif
#ifndef SUPPORT_LH7
- np = 1 << (MAX_DICBIT - 6);
+ np = 1 << (MAX_DICBIT - 6);
#endif
}
/* ------------------------------------------------------------------------ */
void
encode_p_st0(j)
- unsigned short j;
+ unsigned short j;
{
- unsigned short i;
+ unsigned short i;
- i = j >> 6;
- putcode(pt_len[i], pt_code[i]);
- putbits(6, j & 0x3f);
+ i = j >> 6;
+ putcode(pt_len[i], pt_code[i]);
+ putbits(6, j & 0x3f);
}
/* ------------------------------------------------------------------------ */
static void
ready_made(method)
- int method;
+ int method;
{
- int i, j;
- unsigned int code, weight;
- int *tbl;
-
- tbl = fixed[method];
- j = *tbl++;
- weight = 1 << (16 - j);
- code = 0;
- for (i = 0; i < np; i++) {
- while (*tbl == i) {
- j++;
- tbl++;
- weight >>= 1;
- }
- pt_len[i] = j;
- pt_code[i] = code;
- code += weight;
- }
+ int i, j;
+ unsigned int code, weight;
+ int *tbl;
+
+ tbl = fixed[method];
+ j = *tbl++;
+ weight = 1 << (16 - j);
+ code = 0;
+ for (i = 0; i < np; i++) {
+ while (*tbl == i) {
+ j++;
+ tbl++;
+ weight >>= 1;
+ }
+ pt_len[i] = j;
+ pt_code[i] = code;
+ code += weight;
+ }
}
/* ------------------------------------------------------------------------ */
void
encode_start_fix( /*void*/ )
{
- n_max = 314;
- maxmatch = 60;
- np = 1 << (12 - 6);
- init_putbits();
+ n_max = 314;
+ maxmatch = 60;
+ np = 1 << (12 - 6);
+ init_putbits();
init_code_cache();
- start_c_dyn();
- ready_made(0);
+ start_c_dyn();
+ ready_made(0);
}
/* ------------------------------------------------------------------------ */
static void
read_tree_c( /*void*/ )
-{ /* read tree from file */
- int i, c;
-
- i = 0;
- while (i < N1) {
- if (getbits(1))
- c_len[i] = getbits(LENFIELD) + 1;
- else
- c_len[i] = 0;
- if (++i == 3 && c_len[0] == 1 && c_len[1] == 1 && c_len[2] == 1) {
- c = getbits(CBIT);
- for (i = 0; i < N1; i++)
- c_len[i] = 0;
- for (i = 0; i < 4096; i++)
- c_table[i] = c;
- return;
- }
- }
- make_table(N1, c_len, 12, c_table);
+{ /* read tree from file */
+ int i, c;
+
+ i = 0;
+ while (i < N1) {
+ if (getbits(1))
+ c_len[i] = getbits(LENFIELD) + 1;
+ else
+ c_len[i] = 0;
+ if (++i == 3 && c_len[0] == 1 && c_len[1] == 1 && c_len[2] == 1) {
+ c = getbits(CBIT);
+ for (i = 0; i < N1; i++)
+ c_len[i] = 0;
+ for (i = 0; i < 4096; i++)
+ c_table[i] = c;
+ return;
+ }
+ }
+ make_table(N1, c_len, 12, c_table);
}
/* ------------------------------------------------------------------------ */
static void
read_tree_p(/*void*/)
-{ /* read tree from file */
- int i, c;
-
- i = 0;
- while (i < NP) {
- pt_len[i] = getbits(LENFIELD);
- if (++i == 3 && pt_len[0] == 1 && pt_len[1] == 1 && pt_len[2] == 1) {
- c = getbits(LZHUFF3_DICBIT - 6);
- for (i = 0; i < NP; i++)
- pt_len[i] = 0;
- for (i = 0; i < 256; i++)
- pt_table[i] = c;
- return;
- }
- }
+{ /* read tree from file */
+ int i, c;
+
+ i = 0;
+ while (i < NP) {
+ pt_len[i] = getbits(LENFIELD);
+ if (++i == 3 && pt_len[0] == 1 && pt_len[1] == 1 && pt_len[2] == 1) {
+ c = getbits(LZHUFF3_DICBIT - 6);
+ for (i = 0; i < NP; i++)
+ pt_len[i] = 0;
+ for (i = 0; i < 256; i++)
+ pt_table[i] = c;
+ return;
+ }
+ }
}
/* ------------------------------------------------------------------------ */
void
decode_start_fix(/*void*/)
{
- n_max = 314;
- maxmatch = 60;
- init_getbits();
+ n_max = 314;
+ maxmatch = 60;
+ init_getbits();
init_code_cache();
- np = 1 << (LZHUFF1_DICBIT - 6);
- start_c_dyn();
- ready_made(0);
- make_table(np, pt_len, 8, pt_table);
+ np = 1 << (LZHUFF1_DICBIT - 6);
+ start_c_dyn();
+ ready_made(0);
+ make_table(np, pt_len, 8, pt_table);
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_c_st0(/*void*/)
{
- int i, j;
- static unsigned short blocksize = 0;
-
- if (blocksize == 0) { /* read block head */
- blocksize = getbits(BUFBITS); /* read block blocksize */
- read_tree_c();
- if (getbits(1)) {
- read_tree_p();
- }
- else {
- ready_made(1);
- }
- make_table(NP, pt_len, 8, pt_table);
- }
- blocksize--;
- j = c_table[bitbuf >> 4];
- if (j < N1)
- fillbuf(c_len[j]);
- else {
- fillbuf(12);
- i = bitbuf;
- do {
- if ((short) i < 0)
- j = right[j];
- else
- j = left[j];
- i <<= 1;
- } while (j >= N1);
- fillbuf(c_len[j] - 12);
- }
- if (j == N1 - 1)
- j += getbits(EXTRABITS);
- return j;
+ int i, j;
+ static unsigned short blocksize = 0;
+
+ if (blocksize == 0) { /* read block head */
+ blocksize = getbits(BUFBITS); /* read block blocksize */
+ read_tree_c();
+ if (getbits(1)) {
+ read_tree_p();
+ }
+ else {
+ ready_made(1);
+ }
+ make_table(NP, pt_len, 8, pt_table);
+ }
+ blocksize--;
+ j = c_table[bitbuf >> 4];
+ if (j < N1)
+ fillbuf(c_len[j]);
+ else {
+ fillbuf(12);
+ i = bitbuf;
+ do {
+ if ((short) i < 0)
+ j = right[j];
+ else
+ j = left[j];
+ i <<= 1;
+ } while (j >= N1);
+ fillbuf(c_len[j] - 12);
+ }
+ if (j == N1 - 1)
+ j += getbits(EXTRABITS);
+ return j;
}
/* ------------------------------------------------------------------------ */
unsigned short
decode_p_st0(/*void*/)
{
- int i, j;
-
- j = pt_table[bitbuf >> 8];
- if (j < np) {
- fillbuf(pt_len[j]);
- }
- else {
- fillbuf(8);
- i = bitbuf;
- do {
- if ((short) i < 0)
- j = right[j];
- else
- j = left[j];
- i <<= 1;
- } while (j >= np);
- fillbuf(pt_len[j] - 8);
- }
- return (j << 6) + getbits(6);
+ int i, j;
+
+ j = pt_table[bitbuf >> 8];
+ if (j < np) {
+ fillbuf(pt_len[j]);
+ }
+ else {
+ fillbuf(8);
+ i = bitbuf;
+ do {
+ if ((short) i < 0)
+ j = right[j];
+ else
+ j = left[j];
+ i <<= 1;
+ } while (j >= np);
+ fillbuf(pt_len[j] - 8);
+ }
+ return (j << 6) + getbits(6);
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* slice.c -- sliding dictionary with percolating update */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14d Exchanging a search algorithm 1997.01.11 T.Okamoto */
+/* LHa for UNIX */
+/* slice.c -- sliding dictionary with percolating update */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14d Exchanging a search algorithm 1997.01.11 T.Okamoto */
/* ------------------------------------------------------------------------ */
#if 0
static struct encode_option encode_define[2] = {
#if defined(__STDC__) || defined(AIX)
- /* lh1 */
- {(void (*) ()) output_dyn,
- (void (*) ()) encode_start_fix,
- (void (*) ()) encode_end_dyn},
- /* lh4, 5,6 */
- {(void (*) ()) output_st1,
- (void (*) ()) encode_start_st1,
- (void (*) ()) encode_end_st1}
+ /* lh1 */
+ {(void (*) ()) output_dyn,
+ (void (*) ()) encode_start_fix,
+ (void (*) ()) encode_end_dyn},
+ /* lh4, 5,6 */
+ {(void (*) ()) output_st1,
+ (void (*) ()) encode_start_st1,
+ (void (*) ()) encode_end_st1}
#else
- /* lh1 */
- {(int (*) ()) output_dyn,
- (int (*) ()) encode_start_fix,
- (int (*) ()) encode_end_dyn},
- /* lh4, 5,6 */
- {(int (*) ()) output_st1,
- (int (*) ()) encode_start_st1,
- (int (*) ()) encode_end_st1}
+ /* lh1 */
+ {(int (*) ()) output_dyn,
+ (int (*) ()) encode_start_fix,
+ (int (*) ()) encode_end_dyn},
+ /* lh4, 5,6 */
+ {(int (*) ()) output_st1,
+ (int (*) ()) encode_start_st1,
+ (int (*) ()) encode_end_st1}
#endif
};
static struct decode_option decode_define[] = {
- /* lh1 */
- {decode_c_dyn, decode_p_st0, decode_start_fix},
- /* lh2 */
- {decode_c_dyn, decode_p_dyn, decode_start_dyn},
- /* lh3 */
- {decode_c_st0, decode_p_st0, decode_start_st0},
- /* lh4 */
- {decode_c_st1, decode_p_st1, decode_start_st1},
- /* lh5 */
- {decode_c_st1, decode_p_st1, decode_start_st1},
- /* lh6 */
- {decode_c_st1, decode_p_st1, decode_start_st1},
- /* lh7 */
- {decode_c_st1, decode_p_st1, decode_start_st1},
- /* lzs */
- {decode_c_lzs, decode_p_lzs, decode_start_lzs},
- /* lz5 */
- {decode_c_lz5, decode_p_lz5, decode_start_lz5}
+ /* lh1 */
+ {decode_c_dyn, decode_p_st0, decode_start_fix},
+ /* lh2 */
+ {decode_c_dyn, decode_p_dyn, decode_start_dyn},
+ /* lh3 */
+ {decode_c_st0, decode_p_st0, decode_start_st0},
+ /* lh4 */
+ {decode_c_st1, decode_p_st1, decode_start_st1},
+ /* lh5 */
+ {decode_c_st1, decode_p_st1, decode_start_st1},
+ /* lh6 */
+ {decode_c_st1, decode_p_st1, decode_start_st1},
+ /* lh7 */
+ {decode_c_st1, decode_p_st1, decode_start_st1},
+ /* lzs */
+ {decode_c_lzs, decode_p_lzs, decode_start_lzs},
+ /* lz5 */
+ {decode_c_lz5, decode_p_lz5, decode_start_lz5}
};
static struct encode_option encode_set;
#define TXTSIZ (MAX_DICSIZ * 2L + MAXMATCH)
#define HSHSIZ (((unsigned long)1) <<15)
#define NIL 0
-#define LIMIT 0x100 /* chain ŤΠlimit */
+#define LIMIT 0x100 /* chain ŤΠlimit */
static unsigned int txtsiz;
/* ------------------------------------------------------------------------ */
int
encode_alloc(method)
- int method;
+ int method;
{
switch (method) {
case LZHUFF1_METHOD_NUM:
assert(0);
}
- dicsiz = (((unsigned long)1) << dicbit);
- txtsiz = dicsiz*2+maxmatch;
+ dicsiz = (((unsigned long)1) << dicbit);
+ txtsiz = dicsiz*2+maxmatch;
- if (hash) return method;
+ if (hash) return method;
- alloc_buf();
+ alloc_buf();
- hash = (unsigned int*)xmalloc(HSHSIZ * sizeof(unsigned int));
- prev = (unsigned int*)xmalloc(MAX_DICSIZ * sizeof(unsigned int));
- text = (unsigned char*)xmalloc(TXTSIZ);
- too_flag = (unsigned char*)xmalloc(HSHSIZ);
+ hash = (unsigned int*)xmalloc(HSHSIZ * sizeof(unsigned int));
+ prev = (unsigned int*)xmalloc(MAX_DICSIZ * sizeof(unsigned int));
+ text = (unsigned char*)xmalloc(TXTSIZ);
+ too_flag = (unsigned char*)xmalloc(HSHSIZ);
- return method;
+ return method;
}
/* ------------------------------------------------------------------------ */
static void init_slide()
{
- unsigned int i;
-
- for (i = 0; i < HSHSIZ; i++) {
- hash[i] = NIL;
- too_flag[i] = 0;
- }
- /*
- for (i = 0; i < DICSIZ; i++) {
- prev[i] = NIL;
- }
- */
+ unsigned int i;
+
+ for (i = 0; i < HSHSIZ; i++) {
+ hash[i] = NIL;
+ too_flag[i] = 0;
+ }
+ /*
+ for (i = 0; i < DICSIZ; i++) {
+ prev[i] = NIL;
+ }
+ */
}
/* ¼½ñ¤ò DICSIZ ʬ Á°¤Ë¤º¤é¤¹ */
update(crc)
unsigned int crc;
{
- unsigned int i, j;
- long n;
+ unsigned int i, j;
+ long n;
assert(dicsiz > 0);
assert(txtsiz - dicsiz > 0);
n = fread_crc(&crc, &text[txtsiz - dicsiz], dicsiz, infile);
- remainder += n;
- encoded_origsize += n; /* total size of read bytes */
+ remainder += n;
+ encoded_origsize += n; /* total size of read bytes */
- pos -= dicsiz;
- for (i = 0; i < HSHSIZ; i++) {
- j = hash[i];
- hash[i] = (j > dicsiz) ? j - dicsiz : NIL;
- too_flag[i] = 0;
- }
- for (i = 0; i < dicsiz; i++) {
- j = prev[i];
- prev[i] = (j > dicsiz) ? j - dicsiz : NIL;
- }
+ pos -= dicsiz;
+ for (i = 0; i < HSHSIZ; i++) {
+ j = hash[i];
+ hash[i] = (j > dicsiz) ? j - dicsiz : NIL;
+ too_flag[i] = 0;
+ }
+ for (i = 0; i < dicsiz; i++) {
+ j = prev[i];
+ prev[i] = (j > dicsiz) ? j - dicsiz : NIL;
+ }
return crc;
}
static void insert()
{
- prev[pos & (dicsiz - 1)] = hash[hval];
- hash[hval] = pos;
+ prev[pos & (dicsiz - 1)] = hash[hval];
+ hash[hval] = pos;
}
static void match_insert()
{
- unsigned int scan_pos, scan_end, len;
- unsigned char *a, *b;
- unsigned int chain, off, h, max;
-
- max = maxmatch; /* MAXMATCH; */
- if (matchlen < THRESHOLD - 1) matchlen = THRESHOLD - 1;
- matchpos = pos;
-
- off = 0;
- for (h = hval; too_flag[h] && off < maxmatch - THRESHOLD; ) {
- h = ((h << 5) ^ text[pos + (++off) + 2]) & (unsigned)(HSHSIZ - 1);
- }
- if (off == maxmatch - THRESHOLD) off = 0;
- for (;;) {
- chain = 0;
- scan_pos = hash[h];
- scan_end = (pos > dicsiz) ? pos + off - dicsiz : off;
- while (scan_pos > scan_end) {
- chain++;
-
- if (text[scan_pos + matchlen - off] == text[pos + matchlen]) {
- {
- a = text + scan_pos - off; b = text + pos;
- for (len = 0; len < max && *a++ == *b++; len++);
- }
-
- if (len > matchlen) {
- matchpos = scan_pos - off;
- if ((matchlen = len) == max) {
- break;
- }
+ unsigned int scan_pos, scan_end, len;
+ unsigned char *a, *b;
+ unsigned int chain, off, h, max;
+
+ max = maxmatch; /* MAXMATCH; */
+ if (matchlen < THRESHOLD - 1) matchlen = THRESHOLD - 1;
+ matchpos = pos;
+
+ off = 0;
+ for (h = hval; too_flag[h] && off < maxmatch - THRESHOLD; ) {
+ h = ((h << 5) ^ text[pos + (++off) + 2]) & (unsigned)(HSHSIZ - 1);
+ }
+ if (off == maxmatch - THRESHOLD) off = 0;
+ for (;;) {
+ chain = 0;
+ scan_pos = hash[h];
+ scan_end = (pos > dicsiz) ? pos + off - dicsiz : off;
+ while (scan_pos > scan_end) {
+ chain++;
+
+ if (text[scan_pos + matchlen - off] == text[pos + matchlen]) {
+ {
+ a = text + scan_pos - off; b = text + pos;
+ for (len = 0; len < max && *a++ == *b++; len++);
+ }
+
+ if (len > matchlen) {
+ matchpos = scan_pos - off;
+ if ((matchlen = len) == max) {
+ break;
+ }
#ifdef DEBUG
- if (noslide) {
- if (matchpos < dicsiz) {
- printf("matchpos=%u scan_pos=%u dicsiz=%u\n"
- ,matchpos, scan_pos, dicsiz);
- }
- }
+ if (noslide) {
+ if (matchpos < dicsiz) {
+ printf("matchpos=%u scan_pos=%u dicsiz=%u\n"
+ ,matchpos, scan_pos, dicsiz);
+ }
+ }
#endif
- }
- }
- scan_pos = prev[scan_pos & (dicsiz - 1)];
- }
-
- if (chain >= LIMIT)
- too_flag[h] = 1;
-
- if (matchlen > off + 2 || off == 0)
- break;
- max = off + 2;
- off = 0;
- h = hval;
- }
- prev[pos & (dicsiz - 1)] = hash[hval];
- hash[hval] = pos;
+ }
+ }
+ scan_pos = prev[scan_pos & (dicsiz - 1)];
+ }
+
+ if (chain >= LIMIT)
+ too_flag[h] = 1;
+
+ if (matchlen > off + 2 || off == 0)
+ break;
+ max = off + 2;
+ off = 0;
+ h = hval;
+ }
+ prev[pos & (dicsiz - 1)] = hash[hval];
+ hash[hval] = pos;
}
get_next(crc)
unsigned int crc;
{
- remainder--;
- if (++pos >= txtsiz - maxmatch) {
- crc = update(crc);
+ remainder--;
+ if (++pos >= txtsiz - maxmatch) {
+ crc = update(crc);
#ifdef DEBUG
- noslide = 0;
+ noslide = 0;
#endif
- }
- hval = ((hval << 5) ^ text[pos + 2]) & (unsigned)(HSHSIZ - 1);
+ }
+ hval = ((hval << 5) ^ text[pos + 2]) & (unsigned)(HSHSIZ - 1);
return crc;
}
encode(interface)
struct interfacing *interface;
{
- int lastmatchlen;
- unsigned int lastmatchoffset;
+ int lastmatchlen;
+ unsigned int lastmatchoffset;
unsigned int crc;
#ifdef DEBUG
- unsigned int addr;
+ unsigned int addr;
- addr = 0;
+ addr = 0;
- fout = fopen("en", "wt");
- if (fout == NULL) exit(1);
+ fout = fopen("en", "wt");
+ if (fout == NULL) exit(1);
#endif
- infile = interface->infile;
- outfile = interface->outfile;
- origsize = interface->original;
- compsize = count = 0L;
- unpackable = 0;
+ infile = interface->infile;
+ outfile = interface->outfile;
+ origsize = interface->original;
+ compsize = count = 0L;
+ unpackable = 0;
INITIALIZE_CRC(crc);
- /* encode_alloc(); */ /* allocate_memory(); */
- init_slide();
+ /* encode_alloc(); */ /* allocate_memory(); */
+ init_slide();
- encode_set.encode_start();
+ encode_set.encode_start();
memset(&text[0], ' ', TXTSIZ);
- remainder = fread_crc(&crc, &text[dicsiz], txtsiz-dicsiz, infile);
- encoded_origsize = remainder;
- matchlen = THRESHOLD - 1;
+ remainder = fread_crc(&crc, &text[dicsiz], txtsiz-dicsiz, infile);
+ encoded_origsize = remainder;
+ matchlen = THRESHOLD - 1;
- pos = dicsiz;
+ pos = dicsiz;
- if (matchlen > remainder) matchlen = remainder;
- hval = ((((text[dicsiz] << 5) ^ text[dicsiz + 1]) << 5)
- ^ text[dicsiz + 2]) & (unsigned)(HSHSIZ - 1);
+ if (matchlen > remainder) matchlen = remainder;
+ hval = ((((text[dicsiz] << 5) ^ text[dicsiz + 1]) << 5)
+ ^ text[dicsiz + 2]) & (unsigned)(HSHSIZ - 1);
- insert();
- while (remainder > 0 && ! unpackable) {
- lastmatchlen = matchlen; lastmatchoffset = pos - matchpos - 1;
- --matchlen;
- crc = get_next(crc); match_insert();
- if (matchlen > remainder) matchlen = remainder;
- if (matchlen > lastmatchlen || lastmatchlen < THRESHOLD) {
- encode_set.output(text[pos - 1], 0);
+ insert();
+ while (remainder > 0 && ! unpackable) {
+ lastmatchlen = matchlen; lastmatchoffset = pos - matchpos - 1;
+ --matchlen;
+ crc = get_next(crc); match_insert();
+ if (matchlen > remainder) matchlen = remainder;
+ if (matchlen > lastmatchlen || lastmatchlen < THRESHOLD) {
+ encode_set.output(text[pos - 1], 0);
#ifdef DEBUG
- fprintf(fout, "%u C %02X\n", addr, text[pos-1]);
- addr++;
+ fprintf(fout, "%u C %02X\n", addr, text[pos-1]);
+ addr++;
#endif
- count++;
- } else {
- encode_set.output(lastmatchlen + (UCHAR_MAX + 1 - THRESHOLD),
- (lastmatchoffset) & (dicsiz-1) );
- --lastmatchlen;
+ count++;
+ } else {
+ encode_set.output(lastmatchlen + (UCHAR_MAX + 1 - THRESHOLD),
+ (lastmatchoffset) & (dicsiz-1) );
+ --lastmatchlen;
#ifdef DEBUG
- fprintf(fout, "%u M %u %u ", addr,
- lastmatchoffset & (dicsiz-1), lastmatchlen+1);
- addr += lastmatchlen +1 ;
+ fprintf(fout, "%u M %u %u ", addr,
+ lastmatchoffset & (dicsiz-1), lastmatchlen+1);
+ addr += lastmatchlen +1 ;
- {
+ {
int t,cc;
for (t=0; t<lastmatchlen+1; t++) {
cc = text[pos - lastmatchoffset - 2 + t];
fprintf(fout, "%02X ", cc);
}
fprintf(fout, "\n");
- }
+ }
#endif
- while (--lastmatchlen > 0) {
- crc = get_next(crc); insert();
- count++;
- }
- crc = get_next(crc);
- matchlen = THRESHOLD - 1;
- match_insert();
- if (matchlen > remainder) matchlen = remainder;
- }
- }
- encode_set.encode_end();
-
- interface->packed = compsize;
- interface->original = encoded_origsize;
+ while (--lastmatchlen > 0) {
+ crc = get_next(crc); insert();
+ count++;
+ }
+ crc = get_next(crc);
+ matchlen = THRESHOLD - 1;
+ match_insert();
+ if (matchlen > remainder) matchlen = remainder;
+ }
+ }
+ encode_set.encode_end();
+
+ interface->packed = compsize;
+ interface->original = encoded_origsize;
return crc;
}
/* ------------------------------------------------------------------------ */
unsigned int
decode(interface)
- struct interfacing *interface;
+ struct interfacing *interface;
{
- unsigned int i, j, k, c;
- unsigned int dicsiz1, offset;
- unsigned char *dtext;
- unsigned int crc;
+ unsigned int i, j, k, c;
+ unsigned int dicsiz1, offset;
+ unsigned char *dtext;
+ unsigned int crc;
#ifdef DEBUG
- fout = fopen("de", "wt");
- if (fout == NULL) exit(1);
+ fout = fopen("de", "wt");
+ if (fout == NULL) exit(1);
#endif
- infile = interface->infile;
- outfile = interface->outfile;
- dicbit = interface->dicbit;
- origsize = interface->original;
- compsize = interface->packed;
- decode_set = decode_define[interface->method - 1];
-
- INITIALIZE_CRC(crc);
- prev_char = -1;
- dicsiz = 1L << dicbit;
- dtext = (unsigned char *)xmalloc(dicsiz);
- for (i=0; i<dicsiz; i++) dtext[i] = 0x20;
- decode_set.decode_start();
- dicsiz1 = dicsiz - 1;
- offset = (interface->method == LARC_METHOD_NUM) ? 0x100 - 2 : 0x100 - 3;
- count = 0;
- loc = 0;
- while (count < origsize) {
- c = decode_set.decode_c();
- if (c <= UCHAR_MAX) {
+ infile = interface->infile;
+ outfile = interface->outfile;
+ dicbit = interface->dicbit;
+ origsize = interface->original;
+ compsize = interface->packed;
+ decode_set = decode_define[interface->method - 1];
+
+ INITIALIZE_CRC(crc);
+ prev_char = -1;
+ dicsiz = 1L << dicbit;
+ dtext = (unsigned char *)xmalloc(dicsiz);
+ for (i=0; i<dicsiz; i++) dtext[i] = 0x20;
+ decode_set.decode_start();
+ dicsiz1 = dicsiz - 1;
+ offset = (interface->method == LARC_METHOD_NUM) ? 0x100 - 2 : 0x100 - 3;
+ count = 0;
+ loc = 0;
+ while (count < origsize) {
+ c = decode_set.decode_c();
+ if (c <= UCHAR_MAX) {
#ifdef DEBUG
- fprintf(fout, "%u C %02X\n", count, c);
+ fprintf(fout, "%u C %02X\n", count, c);
#endif
- dtext[loc++] = c;
- if (loc == dicsiz) {
- fwrite_crc(&crc, dtext, dicsiz, outfile);
- loc = 0;
- }
- count++;
- }
- else {
- j = c - offset;
- i = (loc - decode_set.decode_p() - 1) & dicsiz1;
+ dtext[loc++] = c;
+ if (loc == dicsiz) {
+ fwrite_crc(&crc, dtext, dicsiz, outfile);
+ loc = 0;
+ }
+ count++;
+ }
+ else {
+ j = c - offset;
+ i = (loc - decode_set.decode_p() - 1) & dicsiz1;
#ifdef DEBUG
- fprintf(fout, "%u M %u %u ", count, (loc-1-i) & dicsiz1, j);
+ fprintf(fout, "%u M %u %u ", count, (loc-1-i) & dicsiz1, j);
#endif
- count += j;
- for (k = 0; k < j; k++) {
- c = dtext[(i + k) & dicsiz1];
+ count += j;
+ for (k = 0; k < j; k++) {
+ c = dtext[(i + k) & dicsiz1];
#ifdef DEBUG
- fprintf(fout, "%02X ", c & 0xff);
+ fprintf(fout, "%02X ", c & 0xff);
#endif
- dtext[loc++] = c;
- if (loc == dicsiz) {
- fwrite_crc(&crc, dtext, dicsiz, outfile);
- loc = 0;
- }
- }
+ dtext[loc++] = c;
+ if (loc == dicsiz) {
+ fwrite_crc(&crc, dtext, dicsiz, outfile);
+ loc = 0;
+ }
+ }
#ifdef DEBUG
- fprintf(fout, "\n");
+ fprintf(fout, "\n");
#endif
- }
- }
- if (loc != 0) {
- fwrite_crc(&crc, dtext, loc, outfile);
- }
+ }
+ }
+ if (loc != 0) {
+ fwrite_crc(&crc, dtext, loc, outfile);
+ }
- free(dtext);
+ free(dtext);
return crc;
}
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* End: */
-/* vi: set tabstop=4: */
/* ------------------------------------------------------------------------ */
-/* LHa for UNIX */
-/* util.c -- LHarc Util */
-/* */
-/* Modified Nobutaka Watazaki */
-/* */
-/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
-/* Ver. 1.14e Support for sfx archives 1999.05.28 T.Okamoto */
+/* LHa for UNIX */
+/* util.c -- LHarc Util */
+/* */
+/* Modified Nobutaka Watazaki */
+/* */
+/* Ver. 1.14 Source All chagned 1995.01.14 N.Watazaki */
+/* Ver. 1.14e Support for sfx archives 1999.05.28 T.Okamoto */
/* ------------------------------------------------------------------------ */
#include "lha.h"
/*
/* ------------------------------------------------------------------------ */
long
-copyfile(f1, f2, size, text_flg, crcp) /* return: size of source file */
- FILE *f1;
- FILE *f2;
- long size;
+copyfile(f1, f2, size, text_flg, crcp) /* return: size of source file */
+ FILE *f1;
+ FILE *f2;
+ long size;
int text_flg; /* 0: binary, 1: read text, 2: write text */
- unsigned int *crcp;
+ unsigned int *crcp;
{
- unsigned short xsize;
- char *buf;
- long rsize = 0;
+ unsigned short xsize;
+ char *buf;
+ long rsize = 0;
if (!text_mode)
text_flg = 0;
- buf = (char *)xmalloc(BUFFERSIZE);
+ buf = (char *)xmalloc(BUFFERSIZE);
if (crcp)
INITIALIZE_CRC(*crcp);
- if (text_flg)
- init_code_cache();
- while (size > 0) {
- /* read */
- if (text_flg & 1) {
- xsize = fread_txt(buf, BUFFERSIZE, f1);
- if (xsize == 0)
- break;
- if (ferror(f1)) {
- fatal_error("file read error");
- }
- }
- else {
- xsize = (size > BUFFERSIZE) ? BUFFERSIZE : size;
- if (fread(buf, 1, xsize, f1) != xsize) {
- fatal_error("file read error");
- }
- size -= xsize;
- }
- /* write */
- if (f2) {
- if (text_flg & 2) {
- if (fwrite_txt(buf, xsize, f2)) {
- fatal_error("file write error");
- }
- }
- else {
- if (fwrite(buf, 1, xsize, f2) != xsize) {
- fatal_error("file write error");
- }
- }
- }
- /* calculate crc */
- if (crcp) {
- *crcp = calccrc(*crcp, buf, xsize);
+ if (text_flg)
+ init_code_cache();
+ while (size > 0) {
+ /* read */
+ if (text_flg & 1) {
+ xsize = fread_txt(buf, BUFFERSIZE, f1);
+ if (xsize == 0)
+ break;
+ if (ferror(f1)) {
+ fatal_error("file read error");
+ }
+ }
+ else {
+ xsize = (size > BUFFERSIZE) ? BUFFERSIZE : size;
+ if (fread(buf, 1, xsize, f1) != xsize) {
+ fatal_error("file read error");
+ }
+ size -= xsize;
+ }
+ /* write */
+ if (f2) {
+ if (text_flg & 2) {
+ if (fwrite_txt(buf, xsize, f2)) {
+ fatal_error("file write error");
+ }
+ }
+ else {
+ if (fwrite(buf, 1, xsize, f2) != xsize) {
+ fatal_error("file write error");
+ }
+ }
+ }
+ /* calculate crc */
+ if (crcp) {
+ *crcp = calccrc(*crcp, buf, xsize);
#ifdef NEED_INCREMENTAL_INDICATOR
put_indicator(xsize);
#endif
- }
- rsize += xsize;
- }
- free(buf);
- return rsize;
+ }
+ rsize += xsize;
+ }
+ free(buf);
+ return rsize;
}
/* ------------------------------------------------------------------------ */
int
encode_stored_crc(ifp, ofp, size, original_size_var, write_size_var)
- FILE *ifp, *ofp;
- long size;
- long *original_size_var;
- long *write_size_var;
+ FILE *ifp, *ofp;
+ long size;
+ long *original_size_var;
+ long *write_size_var;
{
- int save_quiet;
+ int save_quiet;
unsigned int crc;
- save_quiet = quiet;
- quiet = 1;
- size = copyfile(ifp, ofp, size, 1, &crc);
- *original_size_var = *write_size_var = size;
- quiet = save_quiet;
- return crc;
+ save_quiet = quiet;
+ quiet = 1;
+ size = copyfile(ifp, ofp, size, 1, &crc);
+ *original_size_var = *write_size_var = size;
+ quiet = save_quiet;
+ return crc;
}
/* ------------------------------------------------------------------------ */
/* If TRUE, archive file name is msdos SFX file name. */
boolean
archive_is_msdos_sfx1(name)
- char *name;
+ char *name;
{
- int len = strlen(name);
+ int len = strlen(name);
- return ((len >= 4) &&
- (strucmp(".COM", name + len - 4) == 0 ||
- strucmp(".EXE", name + len - 4) == 0)) ||
- ((len >= 2) &&
- (strucmp(".x", name + len - 2) == 0));
+ return ((len >= 4) &&
+ (strucmp(".COM", name + len - 4) == 0 ||
+ strucmp(".EXE", name + len - 4) == 0)) ||
+ ((len >= 2) &&
+ (strucmp(".x", name + len - 2) == 0));
}
/*
#ifndef HAVE_STRDUP
char *
strdup(buf)
- char *buf;
+ char *buf;
{
- char *p;
+ char *p;
- if ((p = (char *) malloc(strlen(buf) + 1)) == NULL)
- return NULL;
- strcpy(p, buf);
- return p;
+ if ((p = (char *) malloc(strlen(buf) + 1)) == NULL)
+ return NULL;
+ strcpy(p, buf);
+ return p;
}
#endif
#ifndef HAVE_MEMMOVE
void *
memmove(dst, src, cnt)
- register char *dst, *src;
- register int cnt;
+ register char *dst, *src;
+ register int cnt;
{
- if (dst == src)
- return dst;
- if (src > dst) {
- while (--cnt >= 0)
- *dst++ = *src++;
- }
- else {
- dst += cnt;
- src += cnt;
- while (--cnt >= 0)
- *--dst = *--src;
- }
- return dst;
+ if (dst == src)
+ return dst;
+ if (src > dst) {
+ while (--cnt >= 0)
+ *dst++ = *src++;
+ }
+ else {
+ dst += cnt;
+ src += cnt;
+ while (--cnt >= 0)
+ *--dst = *--src;
+ }
+ return dst;
}
#endif
/* ------------------------------------------------------------------------ */
int
rename(from, to)
- const char *from, *to;
+ const char *from, *to;
{
- struct stat s1, s2;
- extern int errno;
-
- if (stat(from, &s1) < 0)
- return (-1);
- /* is 'FROM' file a directory? */
- if ((s1.st_mode & S_IFMT) == S_IFDIR) {
- errno = ENOTDIR;
- return (-1);
- }
- if (stat(to, &s2) >= 0) { /* 'TO' exists! */
- /* is 'TO' file a directory? */
- if ((s2.st_mode & S_IFMT) == S_IFDIR) {
- errno = EISDIR;
- return (-1);
- }
- if (unlink(to) < 0)
- return (-1);
- }
- if (link(from, to) < 0)
- return (-1);
- if (unlink(from) < 0)
- return (-1);
- return (0);
+ struct stat s1, s2;
+ extern int errno;
+
+ if (stat(from, &s1) < 0)
+ return (-1);
+ /* is 'FROM' file a directory? */
+ if ((s1.st_mode & S_IFMT) == S_IFDIR) {
+ errno = ENOTDIR;
+ return (-1);
+ }
+ if (stat(to, &s2) >= 0) { /* 'TO' exists! */
+ /* is 'TO' file a directory? */
+ if ((s2.st_mode & S_IFMT) == S_IFDIR) {
+ errno = EISDIR;
+ return (-1);
+ }
+ if (unlink(to) < 0)
+ return (-1);
+ }
+ if (link(from, to) < 0)
+ return (-1);
+ if (unlink(from) < 0)
+ return (-1);
+ return (0);
}
-#endif /* !HAVE_FTRUNCATE */
+#endif /* !HAVE_FTRUNCATE */
/* ------------------------------------------------------------------------ */
#if !HAVE_MKDIR && HAVE_WORKING_FORK
-#ifndef MKDIRPATH
-#define MKDIRPATH "/bin/mkdir"
+#ifndef MKDIRPATH
+#define MKDIRPATH "/bin/mkdir"
#endif
-#ifndef RMDIRPATH
-#define RMDIRPATH "/bin/rmdir"
+#ifndef RMDIRPATH
+#define RMDIRPATH "/bin/rmdir"
#endif
int
rmdir(path)
- char *path;
+ char *path;
{
- int stat, rtn = 0;
- char *cmdname;
- if ((cmdname = (char *) malloc(strlen(RMDIRPATH) + 1 + strlen(path) + 1))
- == 0)
- return (-1);
- strcpy(cmdname, RMDIRPATH);
- *(cmdname + strlen(RMDIRPATH)) = ' ';
- strcpy(cmdname + strlen(RMDIRPATH) + 1, path);
- if ((stat = system(cmdname)) < 0)
- rtn = -1; /* fork or exec error */
- else if (stat) { /* RMDIR command error */
- errno = EIO;
- rtn = -1;
- }
- free(cmdname);
- return (rtn);
+ int stat, rtn = 0;
+ char *cmdname;
+ if ((cmdname = (char *) malloc(strlen(RMDIRPATH) + 1 + strlen(path) + 1))
+ == 0)
+ return (-1);
+ strcpy(cmdname, RMDIRPATH);
+ *(cmdname + strlen(RMDIRPATH)) = ' ';
+ strcpy(cmdname + strlen(RMDIRPATH) + 1, path);
+ if ((stat = system(cmdname)) < 0)
+ rtn = -1; /* fork or exec error */
+ else if (stat) { /* RMDIR command error */
+ errno = EIO;
+ rtn = -1;
+ }
+ free(cmdname);
+ return (rtn);
}
/* ------------------------------------------------------------------------ */
int
mkdir(path, mode)
- char *path;
- int mode;
+ char *path;
+ int mode;
{
- int child, stat;
- char *cmdname, *cmdpath = MKDIRPATH;
- if ((cmdname = (char *) strrchr(cmdpath, '/')) == (char *) 0)
- cmdname = cmdpath;
- if ((child = fork()) < 0)
- return (-1); /* fork error */
- else if (child) { /* parent process */
- while (child != wait(&stat)) /* ignore signals */
- continue;
- }
- else { /* child process */
- int maskvalue;
- maskvalue = umask(0); /* get current umask() value */
- umask(maskvalue | (0777 & ~mode)); /* set it! */
- execl(cmdpath, cmdname, path, (char *) 0);
- /* never come here except execl is error */
- return (-1);
- }
- if (stat != 0) {
- errno = EIO; /* cannot get error num. */
- return (-1);
- }
- return (0);
+ int child, stat;
+ char *cmdname, *cmdpath = MKDIRPATH;
+ if ((cmdname = (char *) strrchr(cmdpath, '/')) == (char *) 0)
+ cmdname = cmdpath;
+ if ((child = fork()) < 0)
+ return (-1); /* fork error */
+ else if (child) { /* parent process */
+ while (child != wait(&stat)) /* ignore signals */
+ continue;
+ }
+ else { /* child process */
+ int maskvalue;
+ maskvalue = umask(0); /* get current umask() value */
+ umask(maskvalue | (0777 & ~mode)); /* set it! */
+ execl(cmdpath, cmdname, path, (char *) 0);
+ /* never come here except execl is error */
+ return (-1);
+ }
+ if (stat != 0) {
+ errno = EIO; /* cannot get error num. */
+ return (-1);
+ }
+ return (0);
}
#endif
#ifndef HAVE_STRCASECMP
static int
my_toupper(n)
- register int n;
+ register int n;
{
- if (n >= 'a' && n <= 'z')
- return n & (~('a' - 'A'));
- return n;
+ if (n >= 'a' && n <= 'z')
+ return n & (~('a' - 'A'));
+ return n;
}
/* ------------------------------------------------------------------------ */
int
strucmp(s, t)
- register char *s, *t;
+ register char *s, *t;
{
- while (my_toupper(*s++) == my_toupper(*t++))
- if (!*s || !*t)
- break;
- if (!*s && !*t)
- return 0;
- return 1;
+ while (my_toupper(*s++) == my_toupper(*t++))
+ if (!*s || !*t)
+ break;
+ if (!*s && !*t)
+ return 0;
+ return 1;
}
#endif
/* Public Domain memset(3) */
char *
memset(s, c, n)
- char *s;
- int c, n;
+ char *s;
+ int c, n;
{
- char *p = s;
- while (n--)
- *p++ = (char) c;
- return s;
+ char *p = s;
+ while (n--)
+ *p++ = (char) c;
+ return s;
}
#endif
return p;
}
#endif
-
-/* Local Variables: */
-/* mode:c */
-/* tab-width:4 */
-/* compile-command:"gcc -c util.c" */
-/* End: */
-/* vi: set tabstop=4: */
OSDN Git Service
