| /* |
| * Javascript Compressor |
| * |
| * Copyright (c) 2008-2018 Fabrice Bellard |
| * Copyright (c) 2017-2018 Charlie Gordon |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <getopt.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <inttypes.h> |
| #include <unistd.h> |
| |
| #include "cutils.h" |
| |
| typedef struct JSToken { |
| int tok; |
| char buf[20]; |
| char *str; |
| int len; |
| int size; |
| int line_num; /* line number for start of token */ |
| int lines; /* number of embedded linefeeds in token */ |
| } JSToken; |
| |
| enum { |
| TOK_EOF = 256, |
| TOK_IDENT, |
| TOK_STR1, |
| TOK_STR2, |
| TOK_STR3, |
| TOK_NUM, |
| TOK_COM, |
| TOK_LCOM, |
| }; |
| |
| void tok_reset(JSToken *tt) |
| { |
| if (tt->str != tt->buf) { |
| free(tt->str); |
| tt->str = tt->buf; |
| tt->size = sizeof(tt->buf); |
| } |
| tt->len = 0; |
| } |
| |
| void tok_add_ch(JSToken *tt, int c) |
| { |
| if (tt->len + 1 > tt->size) { |
| tt->size *= 2; |
| if (tt->str == tt->buf) { |
| tt->str = malloc(tt->size); |
| memcpy(tt->str, tt->buf, tt->len); |
| } else { |
| tt->str = realloc(tt->str, tt->size); |
| } |
| } |
| tt->str[tt->len++] = c; |
| } |
| |
| FILE *infile; |
| const char *filename; |
| int output_line_num; |
| int line_num; |
| int ch; |
| JSToken tokc; |
| |
| int skip_mask; |
| #define DEFINE_MAX 20 |
| char *define_tab[DEFINE_MAX]; |
| int define_len; |
| |
| void error(const char *fmt, ...) |
| { |
| va_list ap; |
| va_start(ap, fmt); |
| if (filename) { |
| fprintf(stderr, "%s:%d: ", filename, line_num); |
| } else { |
| fprintf(stderr, "jscompress: "); |
| } |
| vfprintf(stderr, fmt, ap); |
| fprintf(stderr, "\n"); |
| va_end(ap); |
| exit(1); |
| } |
| |
| void define_symbol(const char *def) |
| { |
| int i; |
| for (i = 0; i < define_len; i++) { |
| if (!strcmp(tokc.str, define_tab[i])) |
| return; |
| } |
| if (define_len >= DEFINE_MAX) |
| error("too many defines"); |
| define_tab[define_len++] = strdup(def); |
| } |
| |
| void undefine_symbol(const char *def) |
| { |
| int i, j; |
| for (i = j = 0; i < define_len; i++) { |
| if (!strcmp(tokc.str, define_tab[i])) { |
| free(define_tab[i]); |
| } else { |
| define_tab[j++] = define_tab[i]; |
| } |
| } |
| define_len = j; |
| } |
| |
| const char *find_symbol(const char *def) |
| { |
| int i; |
| for (i = 0; i < define_len; i++) { |
| if (!strcmp(tokc.str, define_tab[i])) |
| return "1"; |
| } |
| return NULL; |
| } |
| |
| void next(void); |
| |
| void nextch(void) |
| { |
| ch = fgetc(infile); |
| if (ch == '\n') |
| line_num++; |
| } |
| |
| int skip_blanks(void) |
| { |
| for (;;) { |
| next(); |
| if (tokc.tok != ' ' && tokc.tok != '\t' && |
| tokc.tok != TOK_COM && tokc.tok != TOK_LCOM) |
| return tokc.tok; |
| } |
| } |
| |
| void parse_directive(void) |
| { |
| int ifdef, mask = skip_mask; |
| /* simplistic preprocessor: |
| #define / #undef / #ifdef / #ifndef / #else / #endif |
| no symbol substitution. |
| */ |
| skip_mask = 0; /* disable skipping to parse preprocessor line */ |
| nextch(); |
| if (skip_blanks() != TOK_IDENT) |
| error("expected preprocessing directive after #"); |
| |
| if (!strcmp(tokc.str, "define")) { |
| if (skip_blanks() != TOK_IDENT) |
| error("expected identifier after #define"); |
| define_symbol(tokc.str); |
| } else if (!strcmp(tokc.str, "undef")) { |
| if (skip_blanks() != TOK_IDENT) |
| error("expected identifier after #undef"); |
| undefine_symbol(tokc.str); |
| } else if ((ifdef = 1, !strcmp(tokc.str, "ifdef")) || |
| (ifdef = 0, !strcmp(tokc.str, "ifndef"))) { |
| if (skip_blanks() != TOK_IDENT) |
| error("expected identifier after #ifdef/#ifndef"); |
| mask = (mask << 2) | 2 | ifdef; |
| if (find_symbol(tokc.str)) |
| mask ^= 1; |
| } else if (!strcmp(tokc.str, "else")) { |
| if (!(mask & 2)) |
| error("#else without a #if"); |
| mask ^= 1; |
| } else if (!strcmp(tokc.str, "endif")) { |
| if (!(mask & 2)) |
| error("#endif without a #if"); |
| mask >>= 2; |
| } else { |
| error("unsupported preprocessing directive"); |
| } |
| if (skip_blanks() != '\n') |
| error("extra characters on preprocessing line"); |
| skip_mask = mask; |
| } |
| |
| /* return -1 if invalid char */ |
| static int hex_to_num(int ch) |
| { |
| if (ch >= 'a' && ch <= 'f') |
| return ch - 'a' + 10; |
| else if (ch >= 'A' && ch <= 'F') |
| return ch - 'A' + 10; |
| else if (ch >= '0' && ch <= '9') |
| return ch - '0'; |
| else |
| return -1; |
| } |
| |
| void next(void) |
| { |
| again: |
| tok_reset(&tokc); |
| tokc.line_num = line_num; |
| tokc.lines = 0; |
| switch(ch) { |
| case EOF: |
| tokc.tok = TOK_EOF; |
| if (skip_mask) |
| error("missing #endif"); |
| break; |
| case 'a' ... 'z': |
| case 'A' ... 'Z': |
| case '_': |
| case '$': |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| while ((ch >= 'a' && ch <= 'z') || |
| (ch >= 'A' && ch <= 'Z') || |
| (ch >= '0' && ch <= '9') || |
| (ch == '_' || ch == '$')) { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| tok_add_ch(&tokc, '\0'); |
| tokc.tok = TOK_IDENT; |
| break; |
| case '.': |
| nextch(); |
| if (ch >= '0' && ch <= '9') { |
| tok_add_ch(&tokc, '.'); |
| goto has_dot; |
| } |
| tokc.tok = '.'; |
| break; |
| case '0': |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| if (ch == 'x' || ch == 'X') { |
| /* hexa */ |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| while ((ch >= 'a' && ch <= 'f') || |
| (ch >= 'A' && ch <= 'F') || |
| (ch >= '0' && ch <= '9')) { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| tok_add_ch(&tokc, '\0'); |
| tokc.tok = TOK_NUM; |
| break; |
| } |
| goto has_digit; |
| |
| case '1' ... '9': |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| has_digit: |
| /* decimal */ |
| while (ch >= '0' && ch <= '9') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| if (ch == '.') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| has_dot: |
| while (ch >= '0' && ch <= '9') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| } |
| if (ch == 'e' || ch == 'E') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| if (ch == '+' || ch == '-') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| while (ch >= '0' && ch <= '9') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| } |
| tok_add_ch(&tokc, '\0'); |
| tokc.tok = TOK_NUM; |
| break; |
| case '`': |
| { |
| nextch(); |
| while (ch != '`' && ch != EOF) { |
| if (ch == '\\') { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| if (ch == EOF) { |
| error("unexpected char after '\\'"); |
| } |
| tok_add_ch(&tokc, ch); |
| } else { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| } |
| nextch(); |
| tok_add_ch(&tokc, 0); |
| tokc.tok = TOK_STR3; |
| } |
| break; |
| case '\"': |
| case '\'': |
| { |
| int n, i, c, hex_digit_count; |
| int quote_ch; |
| quote_ch = ch; |
| nextch(); |
| while (ch != quote_ch && ch != EOF) { |
| if (ch == '\\') { |
| nextch(); |
| switch(ch) { |
| case 'n': |
| tok_add_ch(&tokc, '\n'); |
| nextch(); |
| break; |
| case 'r': |
| tok_add_ch(&tokc, '\r'); |
| nextch(); |
| break; |
| case 't': |
| tok_add_ch(&tokc, '\t'); |
| nextch(); |
| break; |
| case 'v': |
| tok_add_ch(&tokc, '\v'); |
| nextch(); |
| break; |
| case '\"': |
| case '\'': |
| case '\\': |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| break; |
| case '0' ... '7': |
| n = 0; |
| while (ch >= '0' && ch <= '7') { |
| n = n * 8 + (ch - '0'); |
| nextch(); |
| } |
| tok_add_ch(&tokc, n); |
| break; |
| case 'x': |
| case 'u': |
| if (ch == 'x') |
| hex_digit_count = 2; |
| else |
| hex_digit_count = 4; |
| nextch(); |
| n = 0; |
| for(i = 0; i < hex_digit_count; i++) { |
| c = hex_to_num(ch); |
| if (c < 0) |
| error("unexpected char after '\\x'"); |
| n = n * 16 + c; |
| nextch(); |
| } |
| if (n >= 256) |
| error("unicode is currently unsupported"); |
| tok_add_ch(&tokc, n); |
| break; |
| |
| default: |
| error("unexpected char after '\\'"); |
| } |
| } else { |
| /* XXX: should refuse embedded newlines */ |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| } |
| nextch(); |
| tok_add_ch(&tokc, 0); |
| if (quote_ch == '\'') |
| tokc.tok = TOK_STR1; |
| else |
| tokc.tok = TOK_STR2; |
| } |
| break; |
| case '/': |
| nextch(); |
| if (ch == '/') { |
| tok_add_ch(&tokc, '/'); |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| while (ch != '\n' && ch != EOF) { |
| tok_add_ch(&tokc, ch); |
| nextch(); |
| } |
| tok_add_ch(&tokc, '\0'); |
| tokc.tok = TOK_LCOM; |
| } else if (ch == '*') { |
| int last; |
| tok_add_ch(&tokc, '/'); |
| tok_add_ch(&tokc, ch); |
| last = 0; |
| for(;;) { |
| nextch(); |
| if (ch == EOF) |
| error("unterminated comment"); |
| if (ch == '\n') |
| tokc.lines++; |
| tok_add_ch(&tokc, ch); |
| if (last == '*' && ch == '/') |
| break; |
| last = ch; |
| } |
| nextch(); |
| tok_add_ch(&tokc, '\0'); |
| tokc.tok = TOK_COM; |
| } else { |
| tokc.tok = '/'; |
| } |
| break; |
| case '#': |
| parse_directive(); |
| goto again; |
| case '\n': |
| /* adjust line number */ |
| tokc.line_num--; |
| tokc.lines++; |
| /* fall thru */ |
| default: |
| tokc.tok = ch; |
| nextch(); |
| break; |
| } |
| if (skip_mask & 1) |
| goto again; |
| } |
| |
| void print_tok(FILE *f, JSToken *tt) |
| { |
| /* keep output lines in sync with input lines */ |
| while (output_line_num < tt->line_num) { |
| putc('\n', f); |
| output_line_num++; |
| } |
| |
| switch(tt->tok) { |
| case TOK_IDENT: |
| case TOK_COM: |
| case TOK_LCOM: |
| fprintf(f, "%s", tt->str); |
| break; |
| case TOK_NUM: |
| { |
| unsigned long a; |
| char *p; |
| a = strtoul(tt->str, &p, 0); |
| if (*p == '\0' && a <= 0x7fffffff) { |
| /* must be an integer */ |
| fprintf(f, "%d", (int)a); |
| } else { |
| fprintf(f, "%s", tt->str); |
| } |
| } |
| break; |
| case TOK_STR3: |
| fprintf(f, "`%s`", tt->str); |
| break; |
| case TOK_STR1: |
| case TOK_STR2: |
| { |
| int i, c, quote_ch; |
| if (tt->tok == TOK_STR1) |
| quote_ch = '\''; |
| else |
| quote_ch = '\"'; |
| fprintf(f, "%c", quote_ch); |
| for(i = 0; i < tt->len - 1; i++) { |
| c = (uint8_t)tt->str[i]; |
| switch(c) { |
| case '\r': |
| fprintf(f, "\\r"); |
| break; |
| case '\n': |
| fprintf(f, "\\n"); |
| break; |
| case '\t': |
| fprintf(f, "\\t"); |
| break; |
| case '\v': |
| fprintf(f, "\\v"); |
| break; |
| case '\"': |
| case '\'': |
| if (c == quote_ch) |
| fprintf(f, "\\%c", c); |
| else |
| fprintf(f, "%c", c); |
| break; |
| case '\\': |
| fprintf(f, "\\\\"); |
| break; |
| default: |
| /* XXX: no utf-8 support! */ |
| if (c >= 32 && c <= 255) { |
| fprintf(f, "%c", c); |
| } else if (c <= 255) |
| fprintf(f, "\\x%02x", c); |
| else |
| fprintf(f, "\\u%04x", c); |
| break; |
| } |
| } |
| fprintf(f, "%c", quote_ch); |
| } |
| break; |
| default: |
| if (tokc.tok >= 256) |
| error("unsupported token in print_tok: %d", tt->tok); |
| fprintf(f, "%c", tt->tok); |
| break; |
| } |
| output_line_num += tt->lines; |
| } |
| |
| /* check if token pasting could occur */ |
| static BOOL compat_token(int c1, int c2) |
| { |
| if ((c1 == TOK_IDENT || c1 == TOK_NUM) && |
| (c2 == TOK_IDENT || c2 == TOK_NUM)) |
| return FALSE; |
| |
| if ((c1 == c2 && strchr("+-<>&|=*/.", c1)) |
| || (c2 == '=' && strchr("+-<>&|!*/^%", c1)) |
| || (c1 == '=' && c2 == '>') |
| || (c1 == '/' && c2 == '*') |
| || (c1 == '.' && c2 == TOK_NUM) |
| || (c1 == TOK_NUM && c2 == '.')) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| void js_compress(const char *filename, const char *outfilename, |
| BOOL do_strip, BOOL keep_header) |
| { |
| FILE *outfile; |
| int ltok, seen_space; |
| |
| line_num = 1; |
| infile = fopen(filename, "rb"); |
| if (!infile) { |
| perror(filename); |
| exit(1); |
| } |
| |
| output_line_num = 1; |
| outfile = fopen(outfilename, "wb"); |
| if (!outfile) { |
| perror(outfilename); |
| exit(1); |
| } |
| |
| nextch(); |
| next(); |
| ltok = 0; |
| seen_space = 0; |
| if (do_strip) { |
| if (keep_header) { |
| while (tokc.tok == ' ' || |
| tokc.tok == '\n' || |
| tokc.tok == '\t' || |
| tokc.tok == '\v' || |
| tokc.tok == '\b' || |
| tokc.tok == '\f') { |
| seen_space = 1; |
| next(); |
| } |
| if (tokc.tok == TOK_COM) { |
| print_tok(outfile, &tokc); |
| //fprintf(outfile, "\n"); |
| ltok = tokc.tok; |
| seen_space = 0; |
| next(); |
| } |
| } |
| |
| for(;;) { |
| if (tokc.tok == TOK_EOF) |
| break; |
| if (tokc.tok == ' ' || |
| tokc.tok == '\r' || |
| tokc.tok == '\t' || |
| tokc.tok == '\v' || |
| tokc.tok == '\b' || |
| tokc.tok == '\f' || |
| tokc.tok == TOK_LCOM || |
| tokc.tok == TOK_COM) { |
| /* don't print spaces or comments */ |
| seen_space = 1; |
| } else if (tokc.tok == TOK_STR3) { |
| print_tok(outfile, &tokc); |
| ltok = tokc.tok; |
| seen_space = 0; |
| } else if (tokc.tok == TOK_STR1 || tokc.tok == TOK_STR2) { |
| int count, i; |
| /* find the optimal quote char */ |
| count = 0; |
| for(i = 0; i < tokc.len; i++) { |
| if (tokc.str[i] == '\'') |
| count++; |
| else if (tokc.str[i] == '\"') |
| count--; |
| } |
| if (count > 0) |
| tokc.tok = TOK_STR2; |
| else if (count < 0) |
| tokc.tok = TOK_STR1; |
| print_tok(outfile, &tokc); |
| ltok = tokc.tok; |
| seen_space = 0; |
| } else { |
| if (seen_space && !compat_token(ltok, tokc.tok)) { |
| fprintf(outfile, " "); |
| } |
| print_tok(outfile, &tokc); |
| ltok = tokc.tok; |
| seen_space = 0; |
| } |
| next(); |
| } |
| } else { |
| /* just handle preprocessing */ |
| while (tokc.tok != TOK_EOF) { |
| print_tok(outfile, &tokc); |
| next(); |
| } |
| } |
| |
| fclose(outfile); |
| fclose(infile); |
| } |
| |
| #define HASH_SIZE 30011 |
| #define MATCH_LEN_MIN 3 |
| #define MATCH_LEN_MAX (4 + 63) |
| #define DIST_MAX 65535 |
| |
| static int find_longest_match(int *pdist, const uint8_t *src, int src_len, |
| const int *hash_next, int cur_pos) |
| { |
| int pos, i, match_len, match_pos, pos_min, len_max; |
| |
| len_max = min_int(src_len - cur_pos, MATCH_LEN_MAX); |
| match_len = 0; |
| match_pos = 0; |
| pos_min = max_int(cur_pos - DIST_MAX - 1, 0); |
| pos = hash_next[cur_pos]; |
| while (pos >= pos_min) { |
| for(i = 0; i < len_max; i++) { |
| if (src[cur_pos + i] != src[pos + i]) |
| break; |
| } |
| if (i > match_len) { |
| match_len = i; |
| match_pos = pos; |
| } |
| pos = hash_next[pos]; |
| } |
| *pdist = cur_pos - match_pos - 1; |
| return match_len; |
| } |
| |
| int lz_compress(uint8_t **pdst, const uint8_t *src, int src_len) |
| { |
| int *hash_table, *hash_next; |
| uint32_t h, v; |
| int i, dist, len, len1, dist1; |
| uint8_t *dst, *q; |
| |
| /* build the hash table */ |
| |
| hash_table = malloc(sizeof(hash_table[0]) * HASH_SIZE); |
| for(i = 0; i < HASH_SIZE; i++) |
| hash_table[i] = -1; |
| hash_next = malloc(sizeof(hash_next[0]) * src_len); |
| for(i = 0; i < src_len; i++) |
| hash_next[i] = -1; |
| |
| for(i = 0; i < src_len - MATCH_LEN_MIN + 1; i++) { |
| h = ((src[i] << 16) | (src[i + 1] << 8) | src[i + 2]) % HASH_SIZE; |
| hash_next[i] = hash_table[h]; |
| hash_table[h] = i; |
| } |
| for(;i < src_len; i++) { |
| hash_next[i] = -1; |
| } |
| free(hash_table); |
| |
| dst = malloc(src_len + 4); /* never larger than the source */ |
| q = dst; |
| *q++ = src_len >> 24; |
| *q++ = src_len >> 16; |
| *q++ = src_len >> 8; |
| *q++ = src_len >> 0; |
| /* compress */ |
| i = 0; |
| while (i < src_len) { |
| if (src[i] >= 128) |
| return -1; |
| len = find_longest_match(&dist, src, src_len, hash_next, i); |
| if (len >= MATCH_LEN_MIN) { |
| /* heuristic: see if better length just after */ |
| len1 = find_longest_match(&dist1, src, src_len, hash_next, i + 1); |
| if (len1 > len) |
| goto no_match; |
| } |
| if (len < MATCH_LEN_MIN) { |
| no_match: |
| *q++ = src[i]; |
| i++; |
| } else if (len <= (3 + 15) && dist < (1 << 10)) { |
| v = 0x8000 | ((len - 3) << 10) | dist; |
| *q++ = v >> 8; |
| *q++ = v; |
| i += len; |
| } else if (len >= 4 && len <= (4 + 63) && dist < (1 << 16)) { |
| v = 0xc00000 | ((len - 4) << 16) | dist; |
| *q++ = v >> 16; |
| *q++ = v >> 8; |
| *q++ = v; |
| i += len; |
| } else { |
| goto no_match; |
| } |
| } |
| free(hash_next); |
| *pdst = dst; |
| return q - dst; |
| } |
| |
| static int load_file(uint8_t **pbuf, const char *filename) |
| { |
| FILE *f; |
| uint8_t *buf; |
| int buf_len; |
| |
| f = fopen(filename, "rb"); |
| if (!f) { |
| perror(filename); |
| exit(1); |
| } |
| fseek(f, 0, SEEK_END); |
| buf_len = ftell(f); |
| fseek(f, 0, SEEK_SET); |
| buf = malloc(buf_len + 1); |
| fread(buf, 1, buf_len, f); |
| buf[buf_len] = '\0'; |
| fclose(f); |
| *pbuf = buf; |
| return buf_len; |
| } |
| |
| static void save_file(const char *filename, const uint8_t *buf, int buf_len) |
| { |
| FILE *f; |
| |
| f = fopen(filename, "wb"); |
| if (!f) { |
| perror(filename); |
| exit(1); |
| } |
| fwrite(buf, 1, buf_len, f); |
| fclose(f); |
| } |
| |
| static void save_c_source(const char *filename, const uint8_t *buf, int buf_len, |
| const char *var_name) |
| { |
| FILE *f; |
| int i; |
| |
| f = fopen(filename, "wb"); |
| if (!f) { |
| perror(filename); |
| exit(1); |
| } |
| fprintf(f, "/* This file is automatically generated - do not edit */\n\n"); |
| fprintf(f, "const uint8_t %s[] = {\n", var_name); |
| for(i = 0; i < buf_len; i++) { |
| fprintf(f, " 0x%02x,", buf[i]); |
| if ((i % 8) == 7 || (i == buf_len - 1)) |
| fprintf(f, "\n"); |
| } |
| fprintf(f, "};\n"); |
| fclose(f); |
| } |
| |
| #define DEFAULT_OUTPUT_FILENAME "out.js" |
| |
| void help(void) |
| { |
| printf("jscompress version 1.0 Copyright (c) 2008-2018 Fabrice Bellard\n" |
| "usage: jscompress [options] filename\n" |
| "Javascript compressor\n" |
| "\n" |
| "-h print this help\n" |
| "-n do not compress spaces\n" |
| "-H keep the first comment\n" |
| "-c compress to file\n" |
| "-C name compress to C source ('name' is the variable name)\n" |
| "-D symbol define preprocessor symbol\n" |
| "-U symbol undefine preprocessor symbol\n" |
| "-o outfile set the output filename (default=%s)\n", |
| DEFAULT_OUTPUT_FILENAME); |
| exit(1); |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int c, do_strip, keep_header, compress; |
| const char *out_filename, *c_var, *fname; |
| char tmpfilename[1024]; |
| |
| do_strip = 1; |
| keep_header = 0; |
| out_filename = DEFAULT_OUTPUT_FILENAME; |
| compress = 0; |
| c_var = NULL; |
| for(;;) { |
| c = getopt(argc, argv, "hno:HcC:D:U:"); |
| if (c == -1) |
| break; |
| switch(c) { |
| case 'h': |
| help(); |
| break; |
| case 'n': |
| do_strip = 0; |
| break; |
| case 'o': |
| out_filename = optarg; |
| break; |
| case 'H': |
| keep_header = 1; |
| break; |
| case 'c': |
| compress = 1; |
| break; |
| case 'C': |
| c_var = optarg; |
| compress = 1; |
| break; |
| case 'D': |
| define_symbol(optarg); |
| break; |
| case 'U': |
| undefine_symbol(optarg); |
| break; |
| } |
| } |
| if (optind >= argc) |
| help(); |
| |
| filename = argv[optind++]; |
| |
| if (compress) { |
| #if defined(__ANDROID__) |
| /* XXX: use another directory ? */ |
| snprintf(tmpfilename, sizeof(tmpfilename), "out.%d", getpid()); |
| #else |
| snprintf(tmpfilename, sizeof(tmpfilename), "/tmp/out.%d", getpid()); |
| #endif |
| fname = tmpfilename; |
| } else { |
| fname = out_filename; |
| } |
| js_compress(filename, fname, do_strip, keep_header); |
| |
| if (compress) { |
| uint8_t *buf1, *buf2; |
| int buf1_len, buf2_len; |
| |
| buf1_len = load_file(&buf1, fname); |
| unlink(fname); |
| buf2_len = lz_compress(&buf2, buf1, buf1_len); |
| if (buf2_len < 0) { |
| fprintf(stderr, "Could not compress file (UTF8 chars are forbidden)\n"); |
| exit(1); |
| } |
| |
| if (c_var) { |
| save_c_source(out_filename, buf2, buf2_len, c_var); |
| } else { |
| save_file(out_filename, buf2, buf2_len); |
| } |
| free(buf1); |
| free(buf2); |
| } |
| return 0; |
| } |
