| /* |
| * Copyright 2011 - 2014 |
| * Andr\xe9 Malo or his licensors, as applicable |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "cext.h" |
| EXT_INIT_FUNC; |
| |
| #ifdef EXT3 |
| typedef Py_UNICODE rchar; |
| #else |
| typedef unsigned char rchar; |
| #endif |
| #define U(c) ((rchar)(c)) |
| |
| typedef struct { |
| const rchar *start; |
| const rchar *sentinel; |
| const rchar *tsentinel; |
| Py_ssize_t at_group; |
| int in_macie5; |
| int in_rule; |
| int keep_bang_comments; |
| } rcssmin_ctx_t; |
| |
| typedef enum { |
| NEED_SPACE_MAYBE = 0, |
| NEED_SPACE_NEVER |
| } need_space_flag; |
| |
| |
| #define RCSSMIN_DULL_BIT (1 << 0) |
| #define RCSSMIN_HEX_BIT (1 << 1) |
| #define RCSSMIN_ESC_BIT (1 << 2) |
| #define RCSSMIN_SPACE_BIT (1 << 3) |
| #define RCSSMIN_STRING_DULL_BIT (1 << 4) |
| #define RCSSMIN_NMCHAR_BIT (1 << 5) |
| #define RCSSMIN_URI_DULL_BIT (1 << 6) |
| #define RCSSMIN_PRE_CHAR_BIT (1 << 7) |
| #define RCSSMIN_POST_CHAR_BIT (1 << 8) |
| |
| static const unsigned short rcssmin_charmask[128] = { |
| 21, 21, 21, 21, 21, 21, 21, 21, |
| 21, 28, 8, 21, 8, 8, 21, 21, |
| 21, 21, 21, 21, 21, 21, 21, 21, |
| 21, 21, 21, 21, 21, 21, 21, 21, |
| 28, 469, 4, 85, 85, 85, 85, 4, |
| 149, 277, 85, 469, 469, 117, 85, 84, |
| 115, 115, 115, 115, 115, 115, 115, 115, |
| 115, 115, 468, 340, 85, 469, 468, 85, |
| 84, 115, 115, 115, 115, 115, 115, 117, |
| 117, 117, 117, 117, 117, 117, 117, 117, |
| 117, 117, 117, 117, 117, 117, 117, 117, |
| 117, 117, 117, 213, 4, 341, 85, 117, |
| 85, 115, 115, 115, 115, 115, 115, 117, |
| 117, 117, 117, 117, 117, 117, 117, 117, |
| 117, 117, 117, 117, 117, 116, 117, 117, |
| 117, 117, 117, 468, 85, 468, 85, 21 |
| }; |
| |
| #define RCSSMIN_IS_DULL(c) ((U(c) > 127) || \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_DULL_BIT)) |
| |
| #define RCSSMIN_IS_HEX(c) ((U(c) <= 127) && \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_HEX_BIT)) |
| |
| #define RCSSMIN_IS_ESC(c) ((U(c) > 127) || \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_ESC_BIT)) |
| |
| #define RCSSMIN_IS_SPACE(c) ((U(c) <= 127) && \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_SPACE_BIT)) |
| |
| #define RCSSMIN_IS_STRING_DULL(c) ((U(c) > 127) || \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_STRING_DULL_BIT)) |
| |
| #define RCSSMIN_IS_NMCHAR(c) ((U(c) > 127) || \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_NMCHAR_BIT)) |
| |
| #define RCSSMIN_IS_URI_DULL(c) ((U(c) > 127) || \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_URI_DULL_BIT)) |
| |
| #define RCSSMIN_IS_PRE_CHAR(c) ((U(c) <= 127) && \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_PRE_CHAR_BIT)) |
| |
| #define RCSSMIN_IS_POST_CHAR(c) ((U(c) <= 127) && \ |
| (rcssmin_charmask[U(c) & 0x7F] & RCSSMIN_POST_CHAR_BIT)) |
| |
| |
| static const rchar pattern_url[] = { |
| /*U('u'),*/ U('r'), U('l'), U('(') |
| }; |
| |
| static const rchar pattern_ie7[] = { |
| /*U('>'),*/ U('/'), U('*'), U('*'), U('/') |
| }; |
| |
| static const rchar pattern_media[] = { |
| U('m'), U('e'), U('d'), U('i'), U('a'), |
| U('M'), U('E'), U('D'), U('I'), U('A') |
| }; |
| |
| static const rchar pattern_document[] = { |
| U('d'), U('o'), U('c'), U('u'), U('m'), U('e'), U('n'), U('t'), |
| U('D'), U('O'), U('C'), U('U'), U('M'), U('E'), U('N'), U('T') |
| }; |
| |
| static const rchar pattern_supports[] = { |
| U('s'), U('u'), U('p'), U('p'), U('o'), U('r'), U('t'), U('s'), |
| U('S'), U('U'), U('P'), U('P'), U('O'), U('R'), U('T'), U('S') |
| }; |
| |
| static const rchar pattern_keyframes[] = { |
| U('k'), U('e'), U('y'), U('f'), U('r'), U('a'), U('m'), U('e'), U('s'), |
| U('K'), U('E'), U('Y'), U('F'), U('R'), U('A'), U('M'), U('E'), U('S') |
| }; |
| |
| static const rchar pattern_vendor_o[] = { |
| U('-'), U('o'), U('-'), |
| U('-'), U('O'), U('-') |
| }; |
| |
| static const rchar pattern_vendor_moz[] = { |
| U('-'), U('m'), U('o'), U('z'), U('-'), |
| U('-'), U('M'), U('O'), U('Z'), U('-') |
| }; |
| |
| static const rchar pattern_vendor_webkit[] = { |
| U('-'), U('w'), U('e'), U('b'), U('k'), U('i'), U('t'), U('-'), |
| U('-'), U('W'), U('E'), U('B'), U('K'), U('I'), U('T'), U('-') |
| }; |
| |
| static const rchar pattern_vendor_ms[] = { |
| U('-'), U('m'), U('s'), U('-'), |
| U('-'), U('M'), U('S'), U('-') |
| }; |
| |
| static const rchar pattern_first[] = { |
| U('f'), U('i'), U('r'), U('s'), U('t'), U('-'), U('l'), |
| U('F'), U('I'), U('R'), U('S'), U('T'), U('-'), U('L') |
| }; |
| |
| static const rchar pattern_line[] = { |
| U('i'), U('n'), U('e'), |
| U('I'), U('N'), U('E'), |
| }; |
| |
| static const rchar pattern_letter[] = { |
| U('e'), U('t'), U('t'), U('e'), U('r'), |
| U('E'), U('T'), U('T'), U('E'), U('R') |
| }; |
| |
| static const rchar pattern_macie5_init[] = { |
| U('/'), U('*'), U('\\'), U('*'), U('/') |
| }; |
| |
| static const rchar pattern_macie5_exit[] = { |
| U('/'), U('*'), U('*'), U('/') |
| }; |
| |
| /* |
| * Match a pattern (and copy immediately to target) |
| */ |
| #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wstrict-overflow" |
| #endif |
| static int |
| copy_match(const rchar *pattern, const rchar *psentinel, |
| const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| rchar c; |
| |
| while (pattern < psentinel |
| && source < ctx->sentinel && target < ctx->tsentinel |
| && ((c = *source++) == *pattern++)) |
| *target++ = c; |
| |
| *source_ = source; |
| *target_ = target; |
| |
| return (pattern == psentinel); |
| } |
| #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) |
| #pragma GCC diagnostic pop |
| #endif |
| |
| #define MATCH(PAT, source, target, ctx) ( \ |
| copy_match(pattern_##PAT, \ |
| pattern_##PAT + sizeof(pattern_##PAT) / sizeof(rchar), \ |
| source, target, ctx) \ |
| ) |
| |
| |
| /* |
| * Match a pattern (and copy immediately to target) - CI version |
| */ |
| static int |
| copy_imatch(const rchar *pattern, const rchar *psentinel, |
| const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_, *pstart = pattern; |
| rchar *target = *target_; |
| rchar c; |
| |
| while (pattern < psentinel |
| && source < ctx->sentinel && target < ctx->tsentinel |
| && ((c = *source++) == *pattern |
| || c == pstart[(pattern - pstart) + (psentinel - pstart)])) { |
| ++pattern; |
| *target++ = c; |
| } |
| |
| *source_ = source; |
| *target_ = target; |
| |
| return (pattern == psentinel); |
| } |
| |
| #define IMATCH(PAT, source, target, ctx) ( \ |
| copy_imatch(pattern_##PAT, \ |
| pattern_##PAT + sizeof(pattern_##PAT) / sizeof(rchar) / 2, \ |
| source, target, ctx) \ |
| ) |
| |
| |
| /* |
| * Copy characters |
| */ |
| #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wstrict-overflow" |
| #endif |
| static int |
| copy(const rchar *source, const rchar *sentinel, rchar **target_, |
| rcssmin_ctx_t *ctx) |
| { |
| rchar *target = *target_; |
| |
| while (source < sentinel && target < ctx->tsentinel) |
| *target++ = *source++; |
| |
| *target_ = target; |
| |
| return (source == sentinel); |
| } |
| #if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) |
| #pragma GCC diagnostic pop |
| #endif |
| |
| #define COPY_PAT(PAT, target, ctx) ( \ |
| copy(pattern_##PAT, \ |
| pattern_##PAT + sizeof(pattern_##PAT) / sizeof(rchar), \ |
| target, ctx) \ |
| ) |
| |
| |
| /* |
| * The ABORT macros work with known local variables! |
| */ |
| #define ABORT_(RET) do { \ |
| if (source < ctx->sentinel && !(target < ctx->tsentinel)) { \ |
| *source_ = source; \ |
| *target_ = target; \ |
| } \ |
| return RET; \ |
| } while(0) |
| |
| |
| #define CRAPPY_C90_COMPATIBLE_EMPTY |
| #define ABORT ABORT_(CRAPPY_C90_COMPATIBLE_EMPTY) |
| #define RABORT(RET) ABORT_((RET)) |
| |
| |
| /* |
| * Copy escape |
| */ |
| static void |
| copy_escape(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_, *hsentinel; |
| rchar *target = *target_; |
| rchar c; |
| |
| *target++ = U('\\'); |
| *target_ = target; |
| |
| if (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source++; |
| if (RCSSMIN_IS_ESC(c)) { |
| *target++ = c; |
| } |
| else if (RCSSMIN_IS_HEX(c)) { |
| *target++ = c; |
| |
| /* 6 hex chars max, one we got already */ |
| if (ctx->sentinel - source > 5) |
| hsentinel = source + 5; |
| else |
| hsentinel = ctx->sentinel; |
| |
| while (source < hsentinel && target < ctx->tsentinel |
| && (c = *source, RCSSMIN_IS_HEX(c))) { |
| ++source; |
| *target++ = c; |
| } |
| |
| /* One optional space after */ |
| if (source < ctx->sentinel && target < ctx->tsentinel) { |
| if (source == hsentinel) |
| c = *source; |
| if (RCSSMIN_IS_SPACE(c)) { |
| ++source; |
| *target++ = U(' '); |
| if (c == U('\r') && source < ctx->sentinel |
| && *source == U('\n')) |
| ++source; |
| } |
| } |
| } |
| } |
| |
| *target_ = target; |
| *source_ = source; |
| } |
| |
| |
| /* |
| * Copy string |
| */ |
| static void |
| copy_string(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| rchar c, quote = source[-1]; |
| |
| *target++ = quote; |
| *target_ = target; |
| |
| while (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *target++ = *source++; |
| if (RCSSMIN_IS_STRING_DULL(c)) |
| continue; |
| |
| switch (c) { |
| case U('\''): case U('"'): |
| if (c == quote) { |
| *target_ = target; |
| *source_ = source; |
| return; |
| } |
| continue; |
| |
| case U('\\'): |
| if (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source++; |
| switch (c) { |
| case U('\r'): |
| if (source < ctx->sentinel && *source == U('\n')) |
| ++source; |
| /* fall through */ |
| |
| case U('\n'): case U('\f'): |
| --target; |
| break; |
| |
| default: |
| *target++ = c; |
| } |
| } |
| continue; |
| } |
| break; /* forbidden characters */ |
| } |
| |
| ABORT; |
| } |
| |
| |
| /* |
| * Copy URI string |
| */ |
| static int |
| copy_uri_string(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| rchar c, quote = source[-1]; |
| |
| *target++ = quote; |
| *target_ = target; |
| |
| while (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source++; |
| if (RCSSMIN_IS_SPACE(c)) |
| continue; |
| *target++ = c; |
| if (RCSSMIN_IS_STRING_DULL(c)) |
| continue; |
| |
| switch (c) { |
| case U('\''): case U('"'): |
| if (c == quote) { |
| *target_ = target; |
| *source_ = source; |
| return 0; |
| } |
| continue; |
| |
| case U('\\'): |
| if (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source; |
| switch (c) { |
| case U('\r'): |
| if ((source + 1) < ctx->sentinel && source[1] == U('\n')) |
| ++source; |
| /* fall through */ |
| |
| case U('\n'): case U('\f'): |
| --target; |
| ++source; |
| break; |
| |
| default: |
| --target; |
| copy_escape(&source, &target, ctx); |
| } |
| } |
| continue; |
| } |
| |
| break; /* forbidden characters */ |
| } |
| |
| RABORT(-1); |
| } |
| |
| |
| /* |
| * Copy URI (unquoted) |
| */ |
| static int |
| copy_uri_unquoted(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| rchar c; |
| |
| *target++ = source[-1]; |
| *target_ = target; |
| |
| while (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source++; |
| if (RCSSMIN_IS_SPACE(c)) |
| continue; |
| *target++ = c; |
| if (RCSSMIN_IS_URI_DULL(c)) |
| continue; |
| |
| switch (c) { |
| |
| case U(')'): |
| *target_ = target - 1; |
| *source_ = source - 1; |
| return 0; |
| |
| case U('\\'): |
| if (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source; |
| switch (c) { |
| case U('\r'): |
| if ((source + 1) < ctx->sentinel && source[1] == U('\n')) |
| ++source; |
| /* fall through */ |
| |
| case U('\n'): case U('\f'): |
| --target; |
| ++source; |
| break; |
| |
| default: |
| --target; |
| copy_escape(&source, &target, ctx); |
| } |
| } |
| continue; |
| } |
| |
| break; /* forbidden characters */ |
| } |
| |
| RABORT(-1); |
| } |
| |
| |
| /* |
| * Copy url |
| */ |
| static void |
| copy_url(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| rchar c; |
| |
| *target++ = U('u'); |
| *target_ = target; |
| |
| /* Must not be inside an identifier */ |
| if ((source != ctx->start + 1) && RCSSMIN_IS_NMCHAR(source[-2])) |
| return; |
| |
| if (!MATCH(url, &source, &target, ctx) |
| || !(source < ctx->sentinel && target < ctx->tsentinel)) |
| ABORT; |
| |
| while (source < ctx->sentinel && RCSSMIN_IS_SPACE(*source)) |
| ++source; |
| |
| if (!(source < ctx->sentinel)) |
| ABORT; |
| |
| c = *source++; |
| switch (c) { |
| case U('"'): case U('\''): |
| if (copy_uri_string(&source, &target, ctx) == -1) |
| ABORT; |
| |
| while (source < ctx->sentinel && RCSSMIN_IS_SPACE(*source)) |
| ++source; |
| break; |
| |
| default: |
| if (copy_uri_unquoted(&source, &target, ctx) == -1) |
| ABORT; |
| } |
| |
| if (!(source < ctx->sentinel && target < ctx->tsentinel)) |
| ABORT; |
| |
| if ((*target++ = *source++) != U(')')) |
| ABORT; |
| |
| *target_ = target; |
| *source_ = source; |
| } |
| |
| |
| /* |
| * Copy @-group |
| */ |
| static void |
| copy_at_group(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| |
| *target++ = U('@'); |
| *target_ = target; |
| |
| #define REMATCH(what) ( \ |
| source = *source_, \ |
| target = *target_, \ |
| IMATCH(what, &source, &target, ctx) \ |
| ) |
| #define CMATCH(what) IMATCH(what, &source, &target, ctx) |
| |
| if (( !CMATCH(media) |
| && !REMATCH(supports) |
| && !REMATCH(document) |
| && !REMATCH(keyframes) |
| && !(REMATCH(vendor_webkit) && CMATCH(keyframes)) |
| && !(REMATCH(vendor_moz) && CMATCH(keyframes)) |
| && !(REMATCH(vendor_o) && CMATCH(keyframes)) |
| && !(REMATCH(vendor_ms) && CMATCH(keyframes))) |
| || !(source < ctx->sentinel && target < ctx->tsentinel) |
| || RCSSMIN_IS_NMCHAR(*source)) |
| ABORT; |
| |
| #undef CMATCH |
| #undef REMATCH |
| |
| ++ctx->at_group; |
| |
| *target_ = target; |
| *source_ = source; |
| } |
| |
| |
| /* |
| * Skip space |
| */ |
| static const rchar * |
| skip_space(const rchar *source, rcssmin_ctx_t *ctx) |
| { |
| const rchar *begin = source; |
| int res; |
| rchar c; |
| |
| while (source < ctx->sentinel) { |
| c = *source; |
| if (RCSSMIN_IS_SPACE(c)) { |
| ++source; |
| continue; |
| } |
| else if (c == U('/')) { |
| ++source; |
| if (!(source < ctx->sentinel && *source == U('*'))) { |
| --source; |
| break; |
| } |
| ++source; |
| res = 0; |
| while (source < ctx->sentinel) { |
| c = *source++; |
| if (c != U('*')) |
| continue; |
| if (!(source < ctx->sentinel)) |
| return begin; |
| if (*source != U('/')) |
| continue; |
| |
| /* Comment complete */ |
| ++source; |
| res = 1; |
| break; |
| } |
| if (!res) |
| return begin; |
| |
| continue; |
| } |
| |
| break; |
| } |
| |
| return source; |
| } |
| |
| |
| /* |
| * Copy space |
| */ |
| static void |
| copy_space(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx, |
| need_space_flag need_space) |
| { |
| const rchar *source = *source_, *end, *comment; |
| rchar *target = *target_; |
| int res; |
| rchar c; |
| |
| --source; |
| if (need_space == NEED_SPACE_MAYBE |
| && source > ctx->start |
| && !RCSSMIN_IS_PRE_CHAR(source[-1]) |
| && (end = skip_space(source, ctx)) < ctx->sentinel |
| && (!RCSSMIN_IS_POST_CHAR(*end) |
| || (*end == U(':') && !ctx->in_rule && !ctx->at_group))) { |
| |
| if (!(target < ctx->tsentinel)) |
| ABORT; |
| *target++ = U(' '); |
| } |
| |
| while (source < ctx->sentinel) { |
| switch (c = *source) { |
| |
| /* comment */ |
| case U('/'): |
| comment = source++; |
| if (!((source < ctx->sentinel && *source == U('*')))) { |
| --source; |
| break; |
| } |
| ++source; |
| res = 0; |
| while (source < ctx->sentinel) { |
| c = *source++; |
| if (c != U('*')) |
| continue; |
| if (!(source < ctx->sentinel)) |
| ABORT; |
| if (*source != U('/')) |
| continue; |
| |
| /* Comment complete */ |
| ++source; |
| res = 1; |
| |
| if (ctx->keep_bang_comments && comment[2] == U('!')) { |
| ctx->in_macie5 = (source[-3] == U('\\')); |
| if (!copy(comment, source, &target, ctx)) |
| ABORT; |
| } |
| else if (source[-3] == U('\\')) { |
| if (!ctx->in_macie5) { |
| if (!COPY_PAT(macie5_init, &target, ctx)) |
| ABORT; |
| } |
| ctx->in_macie5 = 1; |
| } |
| else if (ctx->in_macie5) { |
| if (!COPY_PAT(macie5_exit, &target, ctx)) |
| ABORT; |
| ctx->in_macie5 = 0; |
| } |
| /* else don't copy anything */ |
| break; |
| } |
| if (!res) |
| ABORT; |
| continue; |
| |
| /* space */ |
| case U(' '): case U('\t'): case U('\r'): case U('\n'): case U('\f'): |
| ++source; |
| continue; |
| } |
| |
| break; |
| } |
| |
| *source_ = source; |
| *target_ = target; |
| } |
| |
| |
| /* |
| * Copy space if comment |
| */ |
| static int |
| copy_space_comment(const rchar **source_, rchar **target_, |
| rcssmin_ctx_t *ctx, need_space_flag need_space) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| |
| if (source < ctx->sentinel && *source == U('*')) { |
| copy_space(source_, target_, ctx, need_space); |
| if (*source_ > source) |
| return 0; |
| } |
| if (!(target < ctx->tsentinel)) |
| RABORT(-1); |
| |
| *target++ = source[-1]; |
| |
| /* *source_ = source; <-- unchanged */ |
| *target_ = target; |
| |
| return -1; |
| } |
| |
| |
| /* |
| * Copy space if exists |
| */ |
| static int |
| copy_space_optional(const rchar **source_, rchar **target_, |
| rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| |
| if (!(source < ctx->sentinel)) |
| return -1; |
| |
| if (*source == U('/')) { |
| *source_ = source + 1; |
| return copy_space_comment(source_, target_, ctx, NEED_SPACE_NEVER); |
| } |
| else if (RCSSMIN_IS_SPACE(*source)) { |
| *source_ = source + 1; |
| copy_space(source_, target_, ctx, NEED_SPACE_NEVER); |
| return 0; |
| } |
| |
| return -1; |
| } |
| |
| |
| /* |
| * Copy :first-line|letter |
| */ |
| static void |
| copy_first(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_, *next, *source_fork; |
| rchar *target = *target_, *target_fork; |
| |
| *target++ = U(':'); |
| *target_ = target; |
| |
| if (!IMATCH(first, &source, &target, ctx) |
| || !(source < ctx->sentinel && target < ctx->tsentinel)) |
| ABORT; |
| |
| source_fork = source; |
| target_fork = target; |
| |
| if (!IMATCH(line, &source, &target, ctx)) { |
| source = source_fork; |
| target = target_fork; |
| |
| if (!IMATCH(letter, &source, &target, ctx) |
| || !(source < ctx->sentinel && target < ctx->tsentinel)) |
| ABORT; |
| } |
| |
| next = skip_space(source, ctx); |
| if (!(next < ctx->sentinel && target < ctx->tsentinel |
| && (*next == U('{') || *next == U(',')))) |
| ABORT; |
| |
| *target++ = U(' '); |
| *target_ = target; |
| *source_ = source; |
| (void)copy_space_optional(source_, target_, ctx); |
| } |
| |
| |
| /* |
| * Copy IE7 hack |
| */ |
| static void |
| copy_ie7hack(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_; |
| rchar *target = *target_; |
| |
| *target++ = U('>'); |
| *target_ = target; |
| |
| if (ctx->in_rule || ctx->at_group) |
| return; /* abort */ |
| |
| if (!MATCH(ie7, &source, &target, ctx)) |
| ABORT; |
| |
| ctx->in_macie5 = 0; |
| |
| *target_ = target; |
| *source_ = source; |
| |
| (void)copy_space_optional(source_, target_, ctx); |
| } |
| |
| |
| /* |
| * Copy semicolon; miss out duplicates or even this one (before '}') |
| */ |
| static void |
| copy_semicolon(const rchar **source_, rchar **target_, rcssmin_ctx_t *ctx) |
| { |
| const rchar *source = *source_, *begin, *end; |
| rchar *target = *target_; |
| |
| begin = source; |
| while (source < ctx->sentinel) { |
| end = skip_space(source, ctx); |
| if (!(end < ctx->sentinel)) { |
| if (!(target < ctx->tsentinel)) |
| ABORT; |
| *target++ = U(';'); |
| break; |
| } |
| switch (*end) { |
| case U(';'): |
| source = end + 1; |
| continue; |
| |
| case U('}'): |
| if (ctx->in_rule) |
| break; |
| |
| /* fall through */ |
| default: |
| if (!(target < ctx->tsentinel)) |
| ABORT; |
| *target++ = U(';'); |
| break; |
| } |
| |
| break; |
| } |
| |
| source = begin; |
| *target_ = target; |
| while (source < ctx->sentinel) { |
| if (*source == U(';')) { |
| ++source; |
| continue; |
| } |
| |
| if (copy_space_optional(&source, target_, ctx) == 0) |
| continue; |
| |
| break; |
| } |
| |
| *source_ = source; |
| } |
| |
| |
| /* |
| * Main function |
| * |
| * The return value determines the result length (kept in the target buffer). |
| * However, if the target buffer is too small, the return value is greater |
| * than tlength. The difference to tlength is the number of unconsumed source |
| * characters at the time the buffer was full. In this case you should resize |
| * the target buffer to the return value and call rcssmin again. Repeat as |
| * often as needed. |
| */ |
| static Py_ssize_t |
| rcssmin(const rchar *source, rchar *target, Py_ssize_t slength, |
| Py_ssize_t tlength, int keep_bang_comments) |
| { |
| rcssmin_ctx_t ctx_, *ctx = &ctx_; |
| const rchar *tstart = target; |
| rchar c; |
| |
| ctx->start = source; |
| ctx->sentinel = source + slength; |
| ctx->tsentinel = target + tlength; |
| ctx->at_group = 0; |
| ctx->in_macie5 = 0; |
| ctx->in_rule = 0; |
| ctx->keep_bang_comments = keep_bang_comments; |
| |
| while (source < ctx->sentinel && target < ctx->tsentinel) { |
| c = *source++; |
| if (RCSSMIN_IS_DULL(c)) { |
| *target++ = c; |
| continue; |
| } |
| else if (RCSSMIN_IS_SPACE(c)) { |
| copy_space(&source, &target, ctx, NEED_SPACE_MAYBE); |
| continue; |
| } |
| |
| switch (c) { |
| |
| /* Escape */ |
| case U('\\'): |
| copy_escape(&source, &target, ctx); |
| continue; |
| |
| /* String */ |
| case U('"'): case U('\''): |
| copy_string(&source, &target, ctx); |
| continue; |
| |
| /* URL */ |
| case U('u'): |
| copy_url(&source, &target, ctx); |
| continue; |
| |
| /* IE7hack */ |
| case U('>'): |
| copy_ie7hack(&source, &target, ctx); |
| continue; |
| |
| /* @-group */ |
| case U('@'): |
| copy_at_group(&source, &target, ctx); |
| continue; |
| |
| /* ; */ |
| case U(';'): |
| copy_semicolon(&source, &target, ctx); |
| continue; |
| |
| /* :first-line|letter followed by [{,] */ |
| /* (apparently needed for IE6) */ |
| case U(':'): |
| copy_first(&source, &target, ctx); |
| continue; |
| |
| /* { */ |
| case U('{'): |
| if (ctx->at_group) |
| --ctx->at_group; |
| else |
| ++ctx->in_rule; |
| *target++ = c; |
| continue; |
| |
| /* } */ |
| case U('}'): |
| if (ctx->in_rule) |
| --ctx->in_rule; |
| *target++ = c; |
| continue; |
| |
| /* space starting with comment */ |
| case U('/'): |
| (void)copy_space_comment(&source, &target, ctx, NEED_SPACE_MAYBE); |
| continue; |
| |
| /* Fallback: copy character. Better safe than sorry. Should not be |
| * reached, though */ |
| default: |
| *target++ = c; |
| continue; |
| } |
| } |
| |
| return |
| (Py_ssize_t)(target - tstart) + (Py_ssize_t)(ctx->sentinel - source); |
| } |
| |
| |
| PyDoc_STRVAR(rcssmin_cssmin__doc__, |
| "cssmin(style, keep_bang_comments=False)\n\ |
| \n\ |
| Minify CSS.\n\ |
| \n\ |
| :Note: This is a hand crafted C implementation built on the regex\n\ |
| semantics.\n\ |
| \n\ |
| :Parameters:\n\ |
| `style` : ``str``\n\ |
| CSS to minify\n\ |
| \n\ |
| :Return: Minified style\n\ |
| :Rtype: ``str``"); |
| |
| static PyObject * |
| rcssmin_cssmin(PyObject *self, PyObject *args, PyObject *kwds) |
| { |
| PyObject *style, *keep_bang_comments_ = NULL, *result; |
| static char *kwlist[] = {"style", "keep_bang_comments", NULL}; |
| Py_ssize_t rlength, slength, length; |
| int keep_bang_comments; |
| #ifdef EXT2 |
| int uni; |
| #define UOBJ "O" |
| #endif |
| #ifdef EXT3 |
| #define UOBJ "U" |
| #endif |
| |
| if (!PyArg_ParseTupleAndKeywords(args, kwds, UOBJ "|O", kwlist, |
| &style, &keep_bang_comments_)) |
| return NULL; |
| |
| if (!keep_bang_comments_) |
| keep_bang_comments = 0; |
| else { |
| keep_bang_comments = PyObject_IsTrue(keep_bang_comments_); |
| if (keep_bang_comments == -1) |
| return NULL; |
| } |
| |
| #ifdef EXT2 |
| if (PyUnicode_Check(style)) { |
| if (!(style = PyUnicode_AsUTF8String(style))) |
| return NULL; |
| uni = 1; |
| } |
| else { |
| if (!(style = PyObject_Str(style))) |
| return NULL; |
| uni = 0; |
| } |
| #endif |
| |
| #ifdef EXT3 |
| Py_INCREF(style); |
| #define PyString_GET_SIZE PyUnicode_GET_SIZE |
| #define PyString_AS_STRING PyUnicode_AS_UNICODE |
| #define _PyString_Resize PyUnicode_Resize |
| #define PyString_FromStringAndSize PyUnicode_FromUnicode |
| #endif |
| |
| rlength = slength = PyString_GET_SIZE(style); |
| |
| again: |
| if (!(result = PyString_FromStringAndSize(NULL, rlength))) { |
| Py_DECREF(style); |
| return NULL; |
| } |
| Py_BEGIN_ALLOW_THREADS |
| length = rcssmin((rchar *)PyString_AS_STRING(style), |
| (rchar *)PyString_AS_STRING(result), |
| slength, rlength, keep_bang_comments); |
| Py_END_ALLOW_THREADS |
| |
| if (length > rlength) { |
| Py_DECREF(result); |
| rlength = length; |
| goto again; |
| } |
| |
| Py_DECREF(style); |
| if (length < 0) { |
| Py_DECREF(result); |
| return NULL; |
| } |
| if (length != rlength && _PyString_Resize(&result, length) == -1) |
| return NULL; |
| |
| #ifdef EXT2 |
| if (uni) { |
| style = PyUnicode_DecodeUTF8(PyString_AS_STRING(result), |
| PyString_GET_SIZE(result), "strict"); |
| Py_DECREF(result); |
| if (!style) |
| return NULL; |
| result = style; |
| } |
| #endif |
| return result; |
| } |
| |
| /* ------------------------ BEGIN MODULE DEFINITION ------------------------ */ |
| |
| EXT_METHODS = { |
| {"cssmin", |
| (PyCFunction)rcssmin_cssmin, METH_VARARGS | METH_KEYWORDS, |
| rcssmin_cssmin__doc__}, |
| |
| {NULL} /* Sentinel */ |
| }; |
| |
| PyDoc_STRVAR(EXT_DOCS_VAR, |
| "C implementation of rcssmin\n\ |
| ===========================\n\ |
| \n\ |
| C implementation of rcssmin."); |
| |
| |
| EXT_DEFINE(EXT_MODULE_NAME, EXT_METHODS_VAR, EXT_DOCS_VAR); |
| |
| EXT_INIT_FUNC { |
| PyObject *m; |
| |
| /* Create the module and populate stuff */ |
| if (!(m = EXT_CREATE(&EXT_DEFINE_VAR))) |
| EXT_INIT_ERROR(NULL); |
| |
| EXT_ADD_UNICODE(m, "__author__", "Andr\xe9 Malo", "latin-1"); |
| EXT_ADD_STRING(m, "__docformat__", "restructuredtext en"); |
| |
| EXT_INIT_RETURN(m); |
| } |
| |
| /* ------------------------- END MODULE DEFINITION ------------------------- */ |
