* [GSoC][RFC][PATCH 0/2] STRBUF_INIT_CONST Cover @ 2020-02-18 4:18 Robear Selwans 2020-02-18 4:18 ` [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf Robear Selwans 2020-02-18 4:18 ` [GSoC][RFC][PATCH 2/2] STRBUF_INIT_CONST: Adapting strbuf_* functions Robear Selwans 0 siblings, 2 replies; 11+ messages in thread From: Robear Selwans @ 2020-02-18 4:18 UTC (permalink / raw) To: git This was added according to the issue opened at [https://github.com/gitgitgadget/git/issues/398] [Copied directly from the issue description] > This new way to initialize an strbuf would set buf to the specified > constant string, the appropriate len = strlen(string), and alloc to 0. > That way, we can initialize strbufs with constant values, only > allocating memory when/if needed. Things Done: - Added a new way to initialize constant `strbuf` - Edited functions that try to edit the `strbuf` to check if it was initialized as a constant Robear Selwans (2): STRBUF_INIT_CONST: a new way to initialize strbuf STRBUF_INIT_CONST: Adapting strbuf_* functions strbuf.c | 25 +++++++++++++++++++++++++ strbuf.h | 15 +++++++++++++++ 2 files changed, 40 insertions(+) -- 2.17.1 ^ permalink raw reply [flat|nested] 11+ messages in thread
* [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-18 4:18 [GSoC][RFC][PATCH 0/2] STRBUF_INIT_CONST Cover Robear Selwans @ 2020-02-18 4:18 ` Robear Selwans 2020-02-18 6:21 ` Jeff King 2020-02-19 8:13 ` Johannes Sixt 2020-02-18 4:18 ` [GSoC][RFC][PATCH 2/2] STRBUF_INIT_CONST: Adapting strbuf_* functions Robear Selwans 1 sibling, 2 replies; 11+ messages in thread From: Robear Selwans @ 2020-02-18 4:18 UTC (permalink / raw) To: git; +Cc: brian m. carlson, Jeff King, Junio C Hamano A new function `STRBUF_INIT_CONST(const_str)` was added to allow for a quick initialization of strbuf. Details: Using `STRBUF_INIT_CONST(str)` creates a new struct of type `strbuf` and initializes its `buf`, `len` and `alloc` as `str`, `strlen(str)` and `0`, respectively. Use Case: This is meant to be used to initialize strbufs with constant values and thus, only allocating memory when needed. Usage Example: ``` strbuf env_var = STRBUF_INIT_CONST("dev"); ``` This was added according to the issue opened at [https://github.com/gitgitgadget/git/issues/398] Signed-off-by: Robear Selwans <robear.selwans@outlook.com> --- strbuf.h | 1 + 1 file changed, 1 insertion(+) diff --git a/strbuf.h b/strbuf.h index bfa66569a4..1a1753424c 100644 --- a/strbuf.h +++ b/strbuf.h @@ -71,6 +71,7 @@ struct strbuf { extern char strbuf_slopbuf[]; #define STRBUF_INIT { .alloc = 0, .len = 0, .buf = strbuf_slopbuf } +#define STRBUF_INIT_CONST(const_str) { .alloc = 0, .len = strlen(const_str), .buf = const_str } /* * Predeclare this here, since cache.h includes this file before it defines the -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-18 4:18 ` [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf Robear Selwans @ 2020-02-18 6:21 ` Jeff King 2020-02-18 14:19 ` Robear Selwans 2020-02-19 8:13 ` Johannes Sixt 1 sibling, 1 reply; 11+ messages in thread From: Jeff King @ 2020-02-18 6:21 UTC (permalink / raw) To: Robear Selwans; +Cc: git, brian m. carlson, Junio C Hamano On Tue, Feb 18, 2020 at 04:18:04AM +0000, Robear Selwans wrote: > A new function `STRBUF_INIT_CONST(const_str)` was added to allow for a > quick initialization of strbuf. > > Details: > Using `STRBUF_INIT_CONST(str)` creates a new struct of type `strbuf` and > initializes its `buf`, `len` and `alloc` as `str`, `strlen(str)` and > `0`, respectively. > > Use Case: > This is meant to be used to initialize strbufs with constant values and > thus, only allocating memory when needed. > > Usage Example: > ``` > strbuf env_var = STRBUF_INIT_CONST("dev"); > ``` This seems a bit dangerous to me, as we're initializing a non-const pointer with a string literal. In fact, I'm a little surprised that the compiler doesn't complain, but I think it's mostly due to historical C-isms (the type of string literals is array-of-char). Using gcc's -Wwrite-strings does complain, but there are several other cases already in Git (looking at a few, I think there are some opportunities for cleanup). Your second patch catches cases where the strbuf functions want to write to the buffer. But we've always been pretty open about the fact that strbuf.buf is a writeable C-style string. So something like this: struct strbuf x = STRBUF_INIT_CONST("foo"); size_t i; for (i = 0; i < x.len; i++) x.buf[i] = toupper(x.buf[i]); would generate no compile-time warnings, but would invoke undefined behavior (on my system it segfaults when run, but it could have even more confusing outcomes). Even though this is called out specifically in the strbuf docs: However, it is totally safe to modify anything in the string pointed by the `buf` member, between the indices `0` and `len-1` (inclusive). Of course it would be easy to fix that by adding a strbuf_make_var() call. But my concern is cases where the const-ness and the use of the strbuf are far apart. The point of a strbuf is that you can just use it without worrying, but now it's carrying this extra hidden state. If we want to pursue this direction, I think we'd do better to give each strbuf a matching array. Something like: #define STRBUF_INIT_FROM(buf) { .alloc = 0, .buf = buf, .len = ARRAY_SIZE(buf)-1 } ... char foo_buf[] = "this is the constant value"; struct strbuf foo = STRBUF_INIT_FROM(foo_buf); That gives you a true writeable buffer with the const data in it. _And_ it opens up the option of strbufs using stack buffers with an empty initial value for efficiency (i.e., avoiding the heap at all for short common cases, but being able to grow when needed). One trouble is that you can't do it all in a single variable. You'd need something like: #define DECLARE_STACK_STRBUF(name, contents) \ char name##_buf[] = (contents); struct strbuf name = STRBUF_INIT_FROM(name##_buf) ... DECLARE_STACK_STRBUF(foo, "this is the constant value"); But that gets weirdly un-C-like (your macro expands to multiple statements, which is usually a macro pitfall; but we can't use the usual "do { } while(0)" trick here, because the variables would go out of scope at the end of the fake block. So I think there are interesting directions here, but there's a lot of stuff to figure out. I notice you put GSoC in your subject line. If you're looking at this as a microproject, IMHO this is _way_ more complicated and subtle than a microproject should be. The goal there is to give something so easy that you get to focus on getting your patches in and interacting with the community. The scope I'd expect is more along the lines of compiling with -Wwrite-strings and cleaning up some of the locations that complain. -Peff ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-18 6:21 ` Jeff King @ 2020-02-18 14:19 ` Robear Selwans 2020-02-18 20:33 ` Jeff King 0 siblings, 1 reply; 11+ messages in thread From: Robear Selwans @ 2020-02-18 14:19 UTC (permalink / raw) To: Jeff King; +Cc: git, brian m. carlson, Junio C Hamano On Tue, Feb 18, 2020 at 8:21 AM Jeff King <peff@peff.net> wrote: > Your second patch catches cases where the strbuf functions want to write > to the buffer. But we've always been pretty open about the fact that > strbuf.buf is a writeable C-style string. So something like this: > ... > would generate no compile-time warnings, but would invoke undefined > behavior (on my system it segfaults when run, but it could have even > more confusing outcomes). Oh right, I didn't think about that. Ignorant of me to expect everyone to just call the functions and not edit the buf directly. > If we want to pursue this direction, I think we'd do better to give each > strbuf a matching array. Something like: > ... > So I think there are interesting directions here, but there's a lot of > stuff to figure out. I think that got me a bit fired up now. > I notice you put GSoC in your subject line. If you're looking at this as > a microproject, IMHO this is _way_ more complicated and subtle than a > microproject should be. The goal there is to give something so easy that > you get to focus on getting your patches in and interacting with the > community. The scope I'd expect is more along the lines of compiling > with -Wwrite-strings and cleaning up some of the locations that > complain. I'm actually planning to keep on contributing to git, so I kind of didn't want to do something trivial. Despite the fact that I'm planning to apply to git for GSoC, I'm mostly putting the [GSoC] so that reviewers would go easy on me :D. That said, I might actually do the -Wwrite-strings clean-up after this one is finished. Thanks for the help, I guess I'll start editing it ASAP, then. - mo7sener ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-18 14:19 ` Robear Selwans @ 2020-02-18 20:33 ` Jeff King 0 siblings, 0 replies; 11+ messages in thread From: Jeff King @ 2020-02-18 20:33 UTC (permalink / raw) To: Robear Selwans; +Cc: git, brian m. carlson, Junio C Hamano On Tue, Feb 18, 2020 at 04:19:38PM +0200, Robear Selwans wrote: > > I notice you put GSoC in your subject line. If you're looking at this as > > a microproject, IMHO this is _way_ more complicated and subtle than a > > microproject should be. The goal there is to give something so easy that > > you get to focus on getting your patches in and interacting with the > > community. The scope I'd expect is more along the lines of compiling > > with -Wwrite-strings and cleaning up some of the locations that > > complain. > I'm actually planning to keep on contributing to git, so I kind of > didn't want to > do something trivial. Despite the fact that I'm planning to apply to > git for GSoC, > I'm mostly putting the [GSoC] so that reviewers would go easy on me :D. That > said, I might actually do the -Wwrite-strings clean-up after this one > is finished. OK. If you want to go further, I certainly won't stop you. :) -Peff ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-18 4:18 ` [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf Robear Selwans 2020-02-18 6:21 ` Jeff King @ 2020-02-19 8:13 ` Johannes Sixt 2020-02-20 18:49 ` René Scharfe 1 sibling, 1 reply; 11+ messages in thread From: Johannes Sixt @ 2020-02-19 8:13 UTC (permalink / raw) To: Robear Selwans; +Cc: git, brian m. carlson, Jeff King, Junio C Hamano Am 18.02.20 um 05:18 schrieb Robear Selwans: > A new function `STRBUF_INIT_CONST(const_str)` was added to allow for a > quick initialization of strbuf. > > Details: > Using `STRBUF_INIT_CONST(str)` creates a new struct of type `strbuf` and > initializes its `buf`, `len` and `alloc` as `str`, `strlen(str)` and > `0`, respectively. > > Use Case: > This is meant to be used to initialize strbufs with constant values and > thus, only allocating memory when needed. > > Usage Example: > ``` > strbuf env_var = STRBUF_INIT_CONST("dev"); > ``` > > This was added according to the issue opened at [https://github.com/gitgitgadget/git/issues/398] I am not a friend of this change at all. Why do so many functions and strbuf instances have to pay a price (check for immutable string) for a feature that they are not using? As the macro is just intended for convenience, I suggest to implement it using strbuf_addstr() under the hood. That is much less code churn, and the price is paid only by the strbufs that actually use the feature. -- Hannes ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-19 8:13 ` Johannes Sixt @ 2020-02-20 18:49 ` René Scharfe 2020-02-21 5:21 ` Robear Selwans 2020-02-27 6:50 ` Derrick Stolee 0 siblings, 2 replies; 11+ messages in thread From: René Scharfe @ 2020-02-20 18:49 UTC (permalink / raw) To: Johannes Sixt, Robear Selwans Cc: git, brian m. carlson, Jeff King, Junio C Hamano, Derrick Stolee Am 19.02.20 um 09:13 schrieb Johannes Sixt: > Am 18.02.20 um 05:18 schrieb Robear Selwans: >> A new function `STRBUF_INIT_CONST(const_str)` was added to allow for a >> quick initialization of strbuf. >> >> Details: >> Using `STRBUF_INIT_CONST(str)` creates a new struct of type `strbuf` and >> initializes its `buf`, `len` and `alloc` as `str`, `strlen(str)` and >> `0`, respectively. >> >> Use Case: >> This is meant to be used to initialize strbufs with constant values and >> thus, only allocating memory when needed. >> >> Usage Example: >> ``` >> strbuf env_var = STRBUF_INIT_CONST("dev"); >> ``` >> >> This was added according to the issue opened at [https://github.com/gitgitgadget/git/issues/398] > > I am not a friend of this change at all. Why do so many functions and > strbuf instances have to pay a price (check for immutable string) for a > feature that they are not using? > > As the macro is just intended for convenience, I suggest to implement it > using strbuf_addstr() under the hood. That is much less code churn, and > the price is paid only by the strbufs that actually use the feature. I was also wondering what the benefits of this change might be. Saving one line and thus increasing convenience slightly doesn't justify all this added complexity. Saving an allocation in the following sequence might be worthwhile: struct strbuf sb = STRBUF_INIT; strbuf_addstr(&sb, "foo"); /* Use sb without modifying it. */ strbuf_release(&sb); /* or leak it */ I found two examples of this pattern in the code, one in range-diff.c in the function show_range_diff(), and below is a patch for getting rid of the second one. Are there other reasons why we'd want that feature? Could you perhaps include a patch that makes use of it in this series, to highlight its benefits? -- >8 -- Subject: [PATCH] commit-graph: use progress title directly merge_commit_graphs() copies the (translated) progress message into a strbuf and passes the copy to start_delayed_progress() at each loop iteration. The latter function takes a string pointer, so let's avoid the detour and hand the string to it directly. That's shorter, simpler and slightly more efficient. Signed-off-by: René Scharfe <l.s.r@web.de> --- commit-graph.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/commit-graph.c b/commit-graph.c index 656dd647d5..f013a84e29 100644 --- a/commit-graph.c +++ b/commit-graph.c @@ -1657,19 +1657,15 @@ static void merge_commit_graphs(struct write_commit_graph_context *ctx) { struct commit_graph *g = ctx->r->objects->commit_graph; uint32_t current_graph_number = ctx->num_commit_graphs_before; - struct strbuf progress_title = STRBUF_INIT; while (g && current_graph_number >= ctx->num_commit_graphs_after) { current_graph_number--; - if (ctx->report_progress) { - strbuf_addstr(&progress_title, _("Merging commit-graph")); - ctx->progress = start_delayed_progress(progress_title.buf, 0); - } + if (ctx->report_progress) + ctx->progress = start_delayed_progress(_("Merging commit-graph"), 0); merge_commit_graph(ctx, g); stop_progress(&ctx->progress); - strbuf_release(&progress_title); g = g->base_graph; } -- 2.25.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-20 18:49 ` René Scharfe @ 2020-02-21 5:21 ` Robear Selwans 2020-02-27 6:50 ` Derrick Stolee 1 sibling, 0 replies; 11+ messages in thread From: Robear Selwans @ 2020-02-21 5:21 UTC (permalink / raw) To: René Scharfe Cc: Johannes Sixt, git, brian m. carlson, Jeff King, Junio C Hamano, Derrick Stolee On Thu, Feb 20, 2020 at 8:49 PM René Scharfe <l.s.r@web.de> wrote: > > Could you perhaps include a patch that makes use of it in this series, > to highlight its benefits? Well to begin with, I'm actually doing this in response to this issue [https://github.com/gitgitgadget/git/issues/398]. The issue was created because of the following mail thread, though. [https://public-inbox.org/git/20180601200146.114919-1-sbeller@google.com/] To be honest, I'm not entirely sure about how making these changes would help, as my experience is still quite limited. But from what I've read, I think the main use-case would be using const `strbuf`s to avoid memory leaks when dealing with config strings. ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-20 18:49 ` René Scharfe 2020-02-21 5:21 ` Robear Selwans @ 2020-02-27 6:50 ` Derrick Stolee 2020-02-27 15:55 ` René Scharfe 1 sibling, 1 reply; 11+ messages in thread From: Derrick Stolee @ 2020-02-27 6:50 UTC (permalink / raw) To: René Scharfe, Johannes Sixt, Robear Selwans Cc: git, brian m. carlson, Jeff King, Junio C Hamano On 2/20/2020 1:49 PM, René Scharfe wrote: > Am 19.02.20 um 09:13 schrieb Johannes Sixt: >> As the macro is just intended for convenience, I suggest to implement it >> using strbuf_addstr() under the hood. That is much less code churn, and >> the price is paid only by the strbufs that actually use the feature. > > I was also wondering what the benefits of this change might be. Saving > one line and thus increasing convenience slightly doesn't justify all > this added complexity. Saving an allocation in the following sequence > might be worthwhile: > > struct strbuf sb = STRBUF_INIT; > strbuf_addstr(&sb, "foo"); > /* Use sb without modifying it. */ > strbuf_release(&sb); /* or leak it */ > > I found two examples of this pattern in the code, one in range-diff.c in > the function show_range_diff(), and below is a patch for getting rid of > the second one. Are there other reasons why we'd want that feature? > Could you perhaps include a patch that makes use of it in this series, > to highlight its benefits? > > -- >8 -- > Subject: [PATCH] commit-graph: use progress title directly > > merge_commit_graphs() copies the (translated) progress message into a > strbuf and passes the copy to start_delayed_progress() at each loop > iteration. The latter function takes a string pointer, so let's avoid > the detour and hand the string to it directly. That's shorter, simpler > and slightly more efficient. > > Signed-off-by: René Scharfe <l.s.r@web.de> > --- > commit-graph.c | 8 ++------ > 1 file changed, 2 insertions(+), 6 deletions(-) > > diff --git a/commit-graph.c b/commit-graph.c > index 656dd647d5..f013a84e29 100644 > --- a/commit-graph.c > +++ b/commit-graph.c > @@ -1657,19 +1657,15 @@ static void merge_commit_graphs(struct write_commit_graph_context *ctx) > { > struct commit_graph *g = ctx->r->objects->commit_graph; > uint32_t current_graph_number = ctx->num_commit_graphs_before; > - struct strbuf progress_title = STRBUF_INIT; > > while (g && current_graph_number >= ctx->num_commit_graphs_after) { > current_graph_number--; > > - if (ctx->report_progress) { > - strbuf_addstr(&progress_title, _("Merging commit-graph")); > - ctx->progress = start_delayed_progress(progress_title.buf, 0); > - } > + if (ctx->report_progress) > + ctx->progress = start_delayed_progress(_("Merging commit-graph"), 0); > > merge_commit_graph(ctx, g); > stop_progress(&ctx->progress); > - strbuf_release(&progress_title); > > g = g->base_graph; > } > -- Not only is this a good change, it no longer leaks memory. Thanks! -Stolee ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf 2020-02-27 6:50 ` Derrick Stolee @ 2020-02-27 15:55 ` René Scharfe 0 siblings, 0 replies; 11+ messages in thread From: René Scharfe @ 2020-02-27 15:55 UTC (permalink / raw) To: Derrick Stolee, Johannes Sixt, Robear Selwans Cc: git, brian m. carlson, Jeff King, Junio C Hamano Am 27.02.20 um 07:50 schrieb Derrick Stolee: > On 2/20/2020 1:49 PM, René Scharfe wrote: >> Subject: [PATCH] commit-graph: use progress title directly >> >> merge_commit_graphs() copies the (translated) progress message into a >> strbuf and passes the copy to start_delayed_progress() at each loop >> iteration. The latter function takes a string pointer, so let's avoid >> the detour and hand the string to it directly. That's shorter, simpler >> and slightly more efficient. >> >> Signed-off-by: René Scharfe <l.s.r@web.de> >> --- >> commit-graph.c | 8 ++------ >> 1 file changed, 2 insertions(+), 6 deletions(-) >> >> diff --git a/commit-graph.c b/commit-graph.c >> index 656dd647d5..f013a84e29 100644 >> --- a/commit-graph.c >> +++ b/commit-graph.c >> @@ -1657,19 +1657,15 @@ static void merge_commit_graphs(struct write_commit_graph_context *ctx) >> { >> struct commit_graph *g = ctx->r->objects->commit_graph; >> uint32_t current_graph_number = ctx->num_commit_graphs_before; >> - struct strbuf progress_title = STRBUF_INIT; >> >> while (g && current_graph_number >= ctx->num_commit_graphs_after) { >> current_graph_number--; >> >> - if (ctx->report_progress) { >> - strbuf_addstr(&progress_title, _("Merging commit-graph")); >> - ctx->progress = start_delayed_progress(progress_title.buf, 0); >> - } >> + if (ctx->report_progress) >> + ctx->progress = start_delayed_progress(_("Merging commit-graph"), 0); >> >> merge_commit_graph(ctx, g); >> stop_progress(&ctx->progress); >> - strbuf_release(&progress_title); >> >> g = g->base_graph; >> } >> -- > > Not only is this a good change, it no longer leaks memory. > Thanks! strbuf_release() frees the allocated memory, so I don't think the code was leaking before. (It would have with strbuf_reset()). René ^ permalink raw reply [flat|nested] 11+ messages in thread
* [GSoC][RFC][PATCH 2/2] STRBUF_INIT_CONST: Adapting strbuf_* functions 2020-02-18 4:18 [GSoC][RFC][PATCH 0/2] STRBUF_INIT_CONST Cover Robear Selwans 2020-02-18 4:18 ` [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf Robear Selwans @ 2020-02-18 4:18 ` Robear Selwans 1 sibling, 0 replies; 11+ messages in thread From: Robear Selwans @ 2020-02-18 4:18 UTC (permalink / raw) To: git Cc: Pratik Karki, Junio C Hamano, René Scharfe, Nguyễn Thái Ngọc Duy, Jeff King In a previous commit, a new function `STRBUF_INIT_CONST(const_str)`, which would allow for the quick initialization of constant `strbuf`s, was introduced. In this commit, I check through the strbuf_* functions to edit the ones that would try to edit the passed `strbuf` so that they are guaranteed to behave in a predictable way when met with a constant. Added Functions: `strbuf_make_var` Updated Functions: `strbuf_grow` `strbuf_setlen` `strbuf_trim` `strbuf_trim_trailing_dir_sep` `strbuf_trim_trailing_newline` `strbuf_tolower` `strbuf_splice` Functions where comments were added to clarify the expected behavior: `strbuf_getcwd` Signed-off-by: Robear Selwans <robear.selwans@outlook.com> --- strbuf.c | 25 +++++++++++++++++++++++++ strbuf.h | 14 ++++++++++++++ 2 files changed, 39 insertions(+) diff --git a/strbuf.c b/strbuf.c index f19da55b07..48af039b6e 100644 --- a/strbuf.c +++ b/strbuf.c @@ -89,6 +89,8 @@ void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc) void strbuf_grow(struct strbuf *sb, size_t extra) { + if (sb->len > sb->alloc) + strbuf_make_var(sb); int new_buf = !sb->alloc; if (unsigned_add_overflows(extra, 1) || unsigned_add_overflows(sb->len, extra + 1)) @@ -100,8 +102,18 @@ void strbuf_grow(struct strbuf *sb, size_t extra) sb->buf[0] = '\0'; } +void strbuf_make_var(struct strbuf *sb) +{ + char* str_cpy; + ALLOC_ARRAY(str_cpy, sb->len + 1); + memcpy(str_cpy, sb->buf, sb->len); + strbuf_attach(sb, str_cpy, sb->len, sb->len + 1); +} + void strbuf_trim(struct strbuf *sb) { + if (sb->len > sb->alloc) + strbuf_make_var(sb); strbuf_rtrim(sb); strbuf_ltrim(sb); } @@ -115,6 +127,8 @@ void strbuf_rtrim(struct strbuf *sb) void strbuf_trim_trailing_dir_sep(struct strbuf *sb) { + if (sb->len > sb->alloc) + strbuf_make_var(sb); while (sb->len > 0 && is_dir_sep((unsigned char)sb->buf[sb->len - 1])) sb->len--; sb->buf[sb->len] = '\0'; @@ -122,6 +136,9 @@ void strbuf_trim_trailing_dir_sep(struct strbuf *sb) void strbuf_trim_trailing_newline(struct strbuf *sb) { + if (sb->buf[sb->len - 1] == '\n') + if (sb->len > sb->alloc) + strbuf_make_var(sb); if (sb->len > 0 && sb->buf[sb->len - 1] == '\n') { if (--sb->len > 0 && sb->buf[sb->len - 1] == '\r') --sb->len; @@ -158,6 +175,8 @@ int strbuf_reencode(struct strbuf *sb, const char *from, const char *to) void strbuf_tolower(struct strbuf *sb) { + if (sb->len > sb->alloc) + strbuf_make_var(sb); char *p = sb->buf, *end = sb->buf + sb->len; for (; p < end; p++) *p = tolower(*p); @@ -234,6 +253,8 @@ void strbuf_splice(struct strbuf *sb, size_t pos, size_t len, die("`pos' is too far after the end of the buffer"); if (pos + len > sb->len) die("`pos + len' is too far after the end of the buffer"); + if (sb->len > sb->alloc) + strbuf_make_var(sb); if (dlen >= len) strbuf_grow(sb, dlen - len); @@ -572,6 +593,10 @@ int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint) int strbuf_getcwd(struct strbuf *sb) { + /* + * If sb was a constant, then an error would lead to + * strbuf_release() being called on the sb. + */ size_t oldalloc = sb->alloc; size_t guessed_len = 128; diff --git a/strbuf.h b/strbuf.h index 1a1753424c..a33bc4d90e 100644 --- a/strbuf.h +++ b/strbuf.h @@ -128,6 +128,10 @@ static inline void strbuf_swap(struct strbuf *a, struct strbuf *b) SWAP(*a, *b); } +/** + * Constant string buffer is turned into a variable one. + */ +void strbuf_make_var(struct strbuf *sb); /** * Functions related to the size of the buffer @@ -160,6 +164,16 @@ void strbuf_grow(struct strbuf *sb, size_t amount); */ static inline void strbuf_setlen(struct strbuf *sb, size_t len) { + if (sb->len > sb->alloc) + { + if (!len) + { + sb->buf = strbuf_slopbuf; + return; + } + else + strbuf_make_var(sb); + } if (len > (sb->alloc ? sb->alloc - 1 : 0)) die("BUG: strbuf_setlen() beyond buffer"); sb->len = len; -- 2.17.1 ^ permalink raw reply related [flat|nested] 11+ messages in thread
end of thread, other threads:[~2020-02-27 15:55 UTC | newest] Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2020-02-18 4:18 [GSoC][RFC][PATCH 0/2] STRBUF_INIT_CONST Cover Robear Selwans 2020-02-18 4:18 ` [GSoC][RFC][PATCH 1/2] STRBUF_INIT_CONST: a new way to initialize strbuf Robear Selwans 2020-02-18 6:21 ` Jeff King 2020-02-18 14:19 ` Robear Selwans 2020-02-18 20:33 ` Jeff King 2020-02-19 8:13 ` Johannes Sixt 2020-02-20 18:49 ` René Scharfe 2020-02-21 5:21 ` Robear Selwans 2020-02-27 6:50 ` Derrick Stolee 2020-02-27 15:55 ` René Scharfe 2020-02-18 4:18 ` [GSoC][RFC][PATCH 2/2] STRBUF_INIT_CONST: Adapting strbuf_* functions Robear Selwans
Code repositories for project(s) associated with this public inbox https://80x24.org/mirrors/git.git This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).