diff options
| author | Denys Vlasenko <vda.linux@googlemail.com> | 2011-06-17 03:37:43 +0200 |
|---|---|---|
| committer | Denys Vlasenko <vda.linux@googlemail.com> | 2011-06-17 03:37:43 +0200 |
| commit | a1a448347e71c9899ad1500cbd8739fd82e1bb91 (patch) | |
| tree | b6f60da8a298eb37b672b68245e664dc04951d7f /libbb | |
| parent | 901a53baecd5b8a580f63eb23d481f553de72634 (diff) | |
| download | busybox-w32-a1a448347e71c9899ad1500cbd8739fd82e1bb91.tar.gz busybox-w32-a1a448347e71c9899ad1500cbd8739fd82e1bb91.tar.bz2 busybox-w32-a1a448347e71c9899ad1500cbd8739fd82e1bb91.zip | |
libbb: split bb_get_chunk_from_file and bb_get_chunk_with_continuation
This also moves bb_get_chunk_with_continuation into its sole user,
parse_config.c.
This allows to optimize both functions separately,
they need to be optimized for speed.
(this need was highlighted by slow modprobe caused in part by slow
bb_get_chunk_with_continuation in config parser).
function old new delta
bb_get_chunk_from_file 7 130 +123
config_read 457 558 +101
bb_get_chunk_with_continuation 194 - -194
------------------------------------------------------------------------------
(add/remove: 0/1 grow/shrink: 2/0 up/down: 224/-194) Total: 30 bytes
Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
Diffstat (limited to 'libbb')
| -rw-r--r-- | libbb/get_line_from_file.c | 42 | ||||
| -rw-r--r-- | libbb/parse_config.c | 52 |
2 files changed, 51 insertions, 43 deletions
diff --git a/libbb/get_line_from_file.c b/libbb/get_line_from_file.c index 9be10687b..a98dd35eb 100644 --- a/libbb/get_line_from_file.c +++ b/libbb/get_line_from_file.c | |||
| @@ -11,45 +11,24 @@ | |||
| 11 | 11 | ||
| 12 | #include "libbb.h" | 12 | #include "libbb.h" |
| 13 | 13 | ||
| 14 | /* This function reads an entire line from a text file, up to a newline | 14 | char* FAST_FUNC bb_get_chunk_from_file(FILE *file, int *end) |
| 15 | * or NUL byte, inclusive. It returns a malloc'ed char * which | ||
| 16 | * must be free'ed by the caller. If end is NULL '\n' isn't considered | ||
| 17 | * end of line. If end isn't NULL, length of the chunk is stored in it. | ||
| 18 | * If lineno is not NULL, *lineno is incremented for each line, | ||
| 19 | * and also trailing '\' is recognized as line continuation. | ||
| 20 | * | ||
| 21 | * Returns NULL if EOF/error. */ | ||
| 22 | char* FAST_FUNC bb_get_chunk_with_continuation(FILE *file, int *end, int *lineno) | ||
| 23 | { | 15 | { |
| 24 | int ch; | 16 | int ch; |
| 25 | int idx = 0; | 17 | unsigned idx = 0; |
| 26 | char *linebuf = NULL; | 18 | char *linebuf = NULL; |
| 27 | int linebufsz = 0; | ||
| 28 | 19 | ||
| 29 | while ((ch = getc(file)) != EOF) { | 20 | while ((ch = getc(file)) != EOF) { |
| 30 | /* grow the line buffer as necessary */ | 21 | /* grow the line buffer as necessary */ |
| 31 | if (idx >= linebufsz) { | 22 | if (!(idx & 0xff)) |
| 32 | linebufsz += 256; | 23 | linebuf = xrealloc(linebuf, idx + 0x100); |
| 33 | linebuf = xrealloc(linebuf, linebufsz); | ||
| 34 | } | ||
| 35 | linebuf[idx++] = (char) ch; | 24 | linebuf[idx++] = (char) ch; |
| 36 | if (!ch) | 25 | if (ch == '\0') |
| 26 | break; | ||
| 27 | if (end && ch == '\n') | ||
| 37 | break; | 28 | break; |
| 38 | if (end && ch == '\n') { | ||
| 39 | if (lineno == NULL) | ||
| 40 | break; | ||
| 41 | (*lineno)++; | ||
| 42 | if (idx < 2 || linebuf[idx-2] != '\\') | ||
| 43 | break; | ||
| 44 | idx -= 2; | ||
| 45 | } | ||
| 46 | } | 29 | } |
| 47 | if (end) { | 30 | if (end) |
| 48 | *end = idx; | 31 | *end = idx; |
| 49 | /* handle corner case when the file is not ended with '\n' */ | ||
| 50 | if (ch == EOF && lineno != NULL) | ||
| 51 | (*lineno)++; | ||
| 52 | } | ||
| 53 | if (linebuf) { | 32 | if (linebuf) { |
| 54 | // huh, does fgets discard prior data on error like this? | 33 | // huh, does fgets discard prior data on error like this? |
| 55 | // I don't think so.... | 34 | // I don't think so.... |
| @@ -63,11 +42,6 @@ char* FAST_FUNC bb_get_chunk_with_continuation(FILE *file, int *end, int *lineno | |||
| 63 | return linebuf; | 42 | return linebuf; |
| 64 | } | 43 | } |
| 65 | 44 | ||
| 66 | char* FAST_FUNC bb_get_chunk_from_file(FILE *file, int *end) | ||
| 67 | { | ||
| 68 | return bb_get_chunk_with_continuation(file, end, NULL); | ||
| 69 | } | ||
| 70 | |||
| 71 | /* Get line, including trailing \n if any */ | 45 | /* Get line, including trailing \n if any */ |
| 72 | char* FAST_FUNC xmalloc_fgets(FILE *file) | 46 | char* FAST_FUNC xmalloc_fgets(FILE *file) |
| 73 | { | 47 | { |
diff --git a/libbb/parse_config.c b/libbb/parse_config.c index 4b0236028..769ae5103 100644 --- a/libbb/parse_config.c +++ b/libbb/parse_config.c | |||
| @@ -104,6 +104,44 @@ void FAST_FUNC config_close(parser_t *parser) | |||
| 104 | } | 104 | } |
| 105 | } | 105 | } |
| 106 | 106 | ||
| 107 | /* This function reads an entire line from a text file, up to a newline | ||
| 108 | * or NUL byte, exclusive. It returns a malloc'ed char*. | ||
| 109 | * *lineno is incremented for each line. | ||
| 110 | * Trailing '\' is recognized as line continuation. | ||
| 111 | * Returns NULL if EOF/error. | ||
| 112 | */ | ||
| 113 | static char* get_line_with_continuation(FILE *file, int *lineno) | ||
| 114 | { | ||
| 115 | int ch; | ||
| 116 | unsigned idx = 0; | ||
| 117 | char *linebuf = NULL; | ||
| 118 | |||
| 119 | while ((ch = getc(file)) != EOF) { | ||
| 120 | /* grow the line buffer as necessary */ | ||
| 121 | if (!(idx & 0xff)) | ||
| 122 | linebuf = xrealloc(linebuf, idx + 0x101); | ||
| 123 | if (ch == '\n') | ||
| 124 | ch = '\0'; | ||
| 125 | linebuf[idx] = (char) ch; | ||
| 126 | if (ch == '\0') { | ||
| 127 | (*lineno)++; | ||
| 128 | if (idx == 0 || linebuf[idx-1] != '\\') | ||
| 129 | break; | ||
| 130 | idx--; /* go back to '/' */ | ||
| 131 | continue; | ||
| 132 | } | ||
| 133 | idx++; | ||
| 134 | } | ||
| 135 | if (ch == EOF) { | ||
| 136 | /* handle corner case when the file is not ended with '\n' */ | ||
| 137 | (*lineno)++; | ||
| 138 | if (linebuf) | ||
| 139 | linebuf[idx] = '\0'; | ||
| 140 | } | ||
| 141 | return linebuf; | ||
| 142 | } | ||
| 143 | |||
| 144 | |||
| 107 | /* | 145 | /* |
| 108 | 0. If parser is NULL return 0. | 146 | 0. If parser is NULL return 0. |
| 109 | 1. Read a line from config file. If nothing to read then return 0. | 147 | 1. Read a line from config file. If nothing to read then return 0. |
| @@ -132,28 +170,24 @@ int FAST_FUNC config_read(parser_t *parser, char **tokens, unsigned flags, const | |||
| 132 | { | 170 | { |
| 133 | char *line; | 171 | char *line; |
| 134 | int ntokens, mintokens; | 172 | int ntokens, mintokens; |
| 135 | int t, len; | 173 | int t; |
| 174 | |||
| 175 | if (!parser) | ||
| 176 | return 0; | ||
| 136 | 177 | ||
| 137 | ntokens = (uint8_t)flags; | 178 | ntokens = (uint8_t)flags; |
| 138 | mintokens = (uint8_t)(flags >> 8); | 179 | mintokens = (uint8_t)(flags >> 8); |
| 139 | 180 | ||
| 140 | if (parser == NULL) | ||
| 141 | return 0; | ||
| 142 | |||
| 143 | again: | 181 | again: |
| 144 | memset(tokens, 0, sizeof(tokens[0]) * ntokens); | 182 | memset(tokens, 0, sizeof(tokens[0]) * ntokens); |
| 145 | config_free_data(parser); | 183 | config_free_data(parser); |
| 146 | 184 | ||
| 147 | /* Read one line (handling continuations with backslash) */ | 185 | /* Read one line (handling continuations with backslash) */ |
| 148 | line = bb_get_chunk_with_continuation(parser->fp, &len, &parser->lineno); | 186 | line = get_line_with_continuation(parser->fp, &parser->lineno); |
| 149 | if (line == NULL) | 187 | if (line == NULL) |
| 150 | return 0; | 188 | return 0; |
| 151 | parser->line = line; | 189 | parser->line = line; |
| 152 | 190 | ||
| 153 | /* Strip trailing line-feed if any */ | ||
| 154 | if (len && line[len-1] == '\n') | ||
| 155 | line[len-1] = '\0'; | ||
| 156 | |||
| 157 | /* Skip token in the start of line? */ | 191 | /* Skip token in the start of line? */ |
| 158 | if (flags & PARSE_TRIM) | 192 | if (flags & PARSE_TRIM) |
| 159 | line += strspn(line, delims + 1); | 193 | line += strspn(line, delims + 1); |
