Emacs vs pg_indent's weird indentation for function declarations
Hello,
Using either the .dir-locals.el settings or the "more complete"
src/tools/editors/emacs.samples, I have never convinced Emacs to
produce multi-line function declarations in .h files that satisfy
pg_indent.
For example, latch.c has the following definition:
int
WaitEventSetWait(WaitEventSet *set, long timeout,
WaitEvent *occurred_events, int nevents,
uint32 wait_event_info)
And now let's see the declaration in latch.h:
extern int WaitEventSetWait(WaitEventSet *set, long timeout,
WaitEvent *occurred_events, int nevents,
uint32 wait_event_info);
(I replaced all tabs with four space here; if you're reading in a
monospace font, you'll see that the first arguments off all lines
begin in the same column in the definition by not in the declaration.)
For a while I've been baffled by that: the first arguments of later
lines don't line up with that of the first line, but they're also not
in a constant column (it varies from function to function), and it's
also not caused by 8-space vs 4-space confusion. It was only when I
put those two things next to each other just now in this email that I
finally spotted the logic it's using: if you remove "extern int " then
the later lines line up with the first argument of the top line. This
works for other examples I looked at too. Huh.
That's ... annoying. I wish indent wouldn't do that, because it means
that my declarations get moved around every time I write code. But if
it's not possible to change that for whatever technical or political
reason, I wonder if it's possible to teach Emacs to understand that
weird rule...
--
Thomas Munro
http://www.enterprisedb.com
Thomas Munro <thomas.munro@enterprisedb.com> writes:
For a while I've been baffled by that: the first arguments of later
lines don't line up with that of the first line, but they're also not
in a constant column (it varies from function to function), and it's
also not caused by 8-space vs 4-space confusion. It was only when I
put those two things next to each other just now in this email that I
finally spotted the logic it's using: if you remove "extern int " then
the later lines line up with the first argument of the top line. This
works for other examples I looked at too. Huh.
Yeah. I suspect that the underlying cause is that pgindent doesn't
really distinguish function declarations from definitions, at least
not when it comes time to indent the lines after the first one.
That's ... annoying. I wish indent wouldn't do that, because it means
that my declarations get moved around every time I write code.
If you can fix it, I'd vote for accepting the patch. I don't personally
have the desire to dig into the indent code that much ...
regards, tom lane
On Mon, Jan 28, 2019 at 12:28:30AM -0500, Tom Lane wrote:
Thomas Munro <thomas.munro@enterprisedb.com> writes:
That's ... annoying. I wish indent wouldn't do that, because it means
that my declarations get moved around every time I write code.If you can fix it, I'd vote for accepting the patch. I don't personally
have the desire to dig into the indent code that much ...
If you could get pgindent smarter in this area, it would be really
nice..
--
Michael
On Mon, Jan 28, 2019 at 8:08 PM Michael Paquier <michael@paquier.xyz> wrote:
On Mon, Jan 28, 2019 at 12:28:30AM -0500, Tom Lane wrote:
Thomas Munro <thomas.munro@enterprisedb.com> writes:
That's ... annoying. I wish indent wouldn't do that, because it means
that my declarations get moved around every time I write code.If you can fix it, I'd vote for accepting the patch. I don't personally
have the desire to dig into the indent code that much ...If you could get pgindent smarter in this area, it would be really
nice..
Ah, it's not indent doing it, it's pgindent's post_indent subroutine
trying to correct the effects of the (implied) -psl option, but not
doing a complete job of it (it should adjust the indentation lines of
later lines if it changes the first line).
One idea I had was to tell indent not to do that by using -npsl when
processing headers, like in the attached. That fixes all the headers
I looked at, though of course it doesn't fix the static function
declarations that appear in .c files, so it's not quite the right
answer.
--
Thomas Munro
http://www.enterprisedb.com
Attachments:
hack-pgindent.patchapplication/octet-stream; name=hack-pgindent.patchDownload
diff --git a/src/tools/pgindent/pgindent b/src/tools/pgindent/pgindent
index 2d81672e15..10cd8ee4ff 100755
--- a/src/tools/pgindent/pgindent
+++ b/src/tools/pgindent/pgindent
@@ -274,8 +274,14 @@ sub run_indent
{
my $source = shift;
my $error_message = shift;
+ my $is_header = shift;
+ my $options = $indent_opts;
- my $cmd = "$indent $indent_opts -U" . $filtered_typedefs_fh->filename;
+ if ($is_header) {
+ $options .= " -npsl";
+ }
+
+ my $cmd = "$indent $options -U" . $filtered_typedefs_fh->filename;
my $tmp_fh = new File::Temp(TEMPLATE => "pgsrcXXXXX");
my $filename = $tmp_fh->filename;
@@ -431,10 +437,11 @@ foreach my $source_filename (@files)
my $source = read_source($source_filename);
my $orig_source = $source;
my $error_message = '';
+ my $is_header = ($source_filename =~ m/\.h$/);
$source = pre_indent($source);
- $source = run_indent($source, \$error_message);
+ $source = run_indent($source, \$error_message, $is_header);
if ($source eq "")
{
print STDERR "Failure in $source_filename: " . $error_message . "\n";
On Mon, Jan 28, 2019 at 9:48 PM Thomas Munro
<thomas.munro@enterprisedb.com> wrote:
On Mon, Jan 28, 2019 at 8:08 PM Michael Paquier <michael@paquier.xyz> wrote:
If you could get pgindent smarter in this area, it would be really
nice..Ah, it's not indent doing it, it's pgindent's post_indent subroutine
trying to correct the effects of the (implied) -psl option, but not
doing a complete job of it (it should adjust the indentation lines of
later lines if it changes the first line).One idea I had was to tell indent not to do that by using -npsl when
processing headers, like in the attached. That fixes all the headers
I looked at, though of course it doesn't fix the static function
declarations that appear in .c files, so it's not quite the right
answer.
I tried teaching pgindent's post_indent subroutine to unmangle the
multi-line declarations it mangles. That produces correct
indentation! But can also produce lines that exceed the column limit
we would normally wrap at (of course, because pg_bsd_indent had less
whitespace on the left when it made wrapping decisions). Doh.
Attached for posterity, but it's useless.
So I think pg_bsd_indent itself needs to be fixed. I think I know
where the problem is. lexi.c isn't looking far ahead enough to
recognise multi-line function declarations:
if (*buf_ptr == '(' && state->tos <= 1 && state->ind_level == 0 &&
state->in_parameter_declaration == 0 && state->block_init == 0) {
char *tp = buf_ptr;
while (tp < buf_end)
if (*tp++ == ')' && (*tp == ';' || *tp == ','))
goto not_proc;
strncpy(state->procname, token, sizeof state->procname - 1);
if (state->in_decl)
state->in_parameter_declaration = 1;
return (funcname);
not_proc:;
}
That loop that looks for ')' followed by ';' is what causes the lexer
to conclude that the "foo" is an "ident" rather than a "funcname",
given the following input:
extern void foo(int i);
But if because buf_end ends at the newline, it can't see the
semi-colon and concludes that "foo" is a "funcname" here:
extern void foo(int i,
int j);
That determination causes indent.c's procnames_start_line (-psl) mode
to put "extern void" on its own line here and stop thinking of it as a
declaration:
case funcname:
case ident: /* got an identifier or constant */
if (ps.in_decl) {
if (type_code == funcname) {
ps.in_decl = false;
if (procnames_start_line && s_code != e_code) {
*e_code = '\0';
dump_line();
}
I guess it'd need something smarter than fill_buffer() to see far
enough, but simply loading N lines at once wouldn't be enough because
you could still happen to be looking at the final line in the buffer;
you'd probably need a sliding window. I'm not planning on trying to
fix that myself in the short term, but since it annoys me every time I
commit anything, I couldn't resist figuring out where it's coming from
at least...
--
Thomas Munro
https://enterprisedb.com
Attachments:
0001-Fix-pgindent-s-postprocessing-of-multi-line-prototyp.patchapplication/octet-stream; name=0001-Fix-pgindent-s-postprocessing-of-multi-line-prototyp.patchDownload
From eaf73c7a06ed889f79a9e8dd3ea7e6e01c23a5b7 Mon Sep 17 00:00:00 2001
From: Thomas Munro <thomas.munro@gmail.com>
Date: Sun, 7 Apr 2019 00:00:27 +1300
Subject: [PATCH] Fix pgindent's postprocessing of multi-line prototypes.
---
src/tools/pgindent/pgindent | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/src/tools/pgindent/pgindent b/src/tools/pgindent/pgindent
index 2d81672e15..0220fcdd72 100755
--- a/src/tools/pgindent/pgindent
+++ b/src/tools/pgindent/pgindent
@@ -266,6 +266,25 @@ sub post_indent
)
!$1 . (substr($1,-1,1) eq '*' ? '' : ' ') . $2!gmxe;
+ # Fix the formatting of multi-line arguments in prototypes that were
+ # mangled by the above.
+ my @lines = split /\n/, $source;
+ my $level;
+ $source = "";
+ foreach my $line (@lines) {
+ if ($line =~ /^([a-zA-Z][^(]*\().*,$/) {
+ $level = length($1);
+ print "got level = $level, line = $line\n";
+ $source = $source . $line . "\n";
+ } elsif ($level && $line =~ /^\s+(.*)$/) {
+ $line = "\t" x ($level / 4) . " " x ($level % 4) . $1;
+ $source = $source . $line . "\n";
+ } else {
+ $level = undef;
+ $source = $source . $line . "\n";
+ }
+ }
+
return $source;
}
--
2.21.0
Thomas Munro <thomas.munro@gmail.com> writes:
I tried teaching pgindent's post_indent subroutine to unmangle the
multi-line declarations it mangles. That produces correct
indentation! But can also produce lines that exceed the column limit
we would normally wrap at (of course, because pg_bsd_indent had less
whitespace on the left when it made wrapping decisions). Doh.
Attached for posterity, but it's useless.
So I think pg_bsd_indent itself needs to be fixed. I think I know
where the problem is. lexi.c isn't looking far ahead enough to
recognise multi-line function declarations:
I experimented with fixing this. I was able to get pg_bsd_indent to
distinguish multi-line function declarations from definitions, but it
turns out that it doesn't help your concern about the lines being too
long after re-indenting. Contrary to what you imagine above, it seems
pg_bsd_indent will not reflow argument lists, regardless of whether it
thinks there needs to be more or less leading whitespace. I'm a bit
surprised that -bc doesn't cause that to happen, but it doesn't (and I'm
not sure we'd really want to force one-parameter-per-line, anyway).
Anyway, the attached hasty-and-undercommented change to pg_bsd_indent
allows removal of the "Move prototype names to the same line as return
type" hack in pgindent, and we then get prototypes with properly
lined-up arguments, but we'll have a lot of places with over-length
lines needing manual fixing. Unless somebody wants to find where to
fix that in pg_bsd_indent, but I've had my fill of looking at that
spaghetti code for today.
regards, tom lane
Attachments:
wip-handle-multiline-function-declarations.patchtext/x-diff; charset=us-ascii; name=wip-handle-multiline-function-declarations.patchDownload
diff --git a/indent.h b/indent.h
index 0fffd89..1708dbc 100644
--- a/indent.h
+++ b/indent.h
@@ -41,6 +41,8 @@ void diag2(int, const char *);
void diag3(int, const char *, int);
void diag4(int, const char *, int, int);
void dump_line(void);
+int lookahead(void);
+void lookahead_reset(void);
void fill_buffer(void);
void parse(int);
void pr_comment(void);
diff --git a/io.c b/io.c
index df11094..8d13a52 100644
--- a/io.c
+++ b/io.c
@@ -51,6 +51,13 @@ static char sccsid[] = "@(#)io.c 8.1 (Berkeley) 6/6/93";
int comment_open;
static int paren_target;
+
+static char *lookahead_buf; /* malloc'd buffer, or NULL initially */
+static char *lookahead_buf_end; /* end+1 of allocated space */
+static char *lookahead_start; /* => next char for fill_buffer() to fetch */
+static char *lookahead_ptr; /* => next char for lookahead() to fetch */
+static char *lookahead_end; /* last+1 valid char in lookahead_buf */
+
static int pad_output(int current, int target);
void
@@ -252,6 +259,58 @@ compute_label_target(void)
: ps.ind_size * (ps.ind_level - label_offset) + 1;
}
+/*
+ * Read data ahead of what has been collected into in_buffer.
+ *
+ * Successive calls get further and further ahead, until we hit EOF.
+ * Call lookahead_reset to rescan from just beyond in_buffer.
+ */
+int
+lookahead(void)
+{
+ while (lookahead_ptr >= lookahead_end) {
+ int i = getc(input);
+
+ if (i == EOF)
+ return i;
+ if (i == '\0')
+ continue; /* fill_buffer drops nulls, so do we */
+
+ if (lookahead_end >= lookahead_buf_end) {
+ /* Need to allocate or enlarge lookahead_buf */
+ char *new_buf;
+ size_t req;
+
+ if (lookahead_buf == NULL) {
+ req = 64;
+ new_buf = malloc(req);
+ } else {
+ req = (lookahead_buf_end - lookahead_buf) * 2;
+ new_buf = realloc(lookahead_buf, req);
+ }
+ if (new_buf == NULL)
+ errx(1, "too much lookahead required");
+ lookahead_start = new_buf + (lookahead_start - lookahead_buf);
+ lookahead_ptr = new_buf + (lookahead_ptr - lookahead_buf);
+ lookahead_end = new_buf + (lookahead_end - lookahead_buf);
+ lookahead_buf = new_buf;
+ lookahead_buf_end = new_buf + req;
+ }
+
+ *lookahead_end++ = i;
+ }
+ return (unsigned char) *lookahead_ptr++;
+}
+
+/*
+ * Reset so that lookahead() will again scan from just beyond what's in
+ * in_buffer.
+ */
+void
+lookahead_reset(void)
+{
+ lookahead_ptr = lookahead_start;
+}
/*
* Copyright (C) 1976 by the Board of Trustees of the University of Illinois
@@ -293,11 +352,16 @@ fill_buffer(void)
p = in_buffer + offset;
in_buffer_limit = in_buffer + size - 2;
}
- if ((i = getc(f)) == EOF) {
- *p++ = ' ';
- *p++ = '\n';
- had_eof = true;
- break;
+ if (lookahead_start < lookahead_end) {
+ i = (unsigned char) *lookahead_start++;
+ } else {
+ lookahead_start = lookahead_ptr = lookahead_end = lookahead_buf;
+ if ((i = getc(f)) == EOF) {
+ *p++ = ' ';
+ *p++ = '\n';
+ had_eof = true;
+ break;
+ }
}
if (i != '\0')
*p++ = i;
diff --git a/lexi.c b/lexi.c
index 3c7bfef..e637e1a 100644
--- a/lexi.c
+++ b/lexi.c
@@ -148,6 +148,39 @@ strcmp_type(const void *e1, const void *e2)
return (strcmp(e1, *(const char * const *)e2));
}
+/*
+ * Scan over a function argument declaration list, then see if it is
+ * followed by ';' or ',' indicating that it's just a prototype.
+ *
+ * We do not detect comments, so you can fool this by putting unbalanced
+ * parens inside a comment within the argument list. So don't do that.
+ */
+static int
+is_prototype(char *tp)
+{
+ int paren_depth = 0;
+
+ lookahead_reset();
+ for (;;) {
+ int c;
+
+ if (tp < buf_end)
+ c = *tp++;
+ else {
+ c = lookahead();
+ if (c == EOF)
+ break;
+ }
+ if (c == '(')
+ paren_depth++;
+ else if (c == ')')
+ paren_depth--;
+ else if (paren_depth == 0 && !isspace((unsigned char) c))
+ return (c == ';' || c == ',');
+ }
+ return false;
+}
+
int
lexi(struct parser_state *state)
{
@@ -348,15 +381,12 @@ lexi(struct parser_state *state)
} /* end of if (found_it) */
if (*buf_ptr == '(' && state->tos <= 1 && state->ind_level == 0 &&
state->in_parameter_declaration == 0 && state->block_init == 0) {
- char *tp = buf_ptr;
- while (tp < buf_end)
- if (*tp++ == ')' && (*tp == ';' || *tp == ','))
- goto not_proc;
+ if (!is_prototype(buf_ptr)) {
strncpy(state->procname, token, sizeof state->procname - 1);
if (state->in_decl)
state->in_parameter_declaration = 1;
return (funcname);
- not_proc:;
+ }
}
/*
* The following hack attempts to guess whether or not the current
I wrote:
I experimented with fixing this. I was able to get pg_bsd_indent to
distinguish multi-line function declarations from definitions, but it
turns out that it doesn't help your concern about the lines being too
long after re-indenting. Contrary to what you imagine above, it seems
pg_bsd_indent will not reflow argument lists, regardless of whether it
thinks there needs to be more or less leading whitespace.
Actually, now that I think about it, pgindent seldom revisits line-break
decisions in code anyway; it's only aggressive about reflowing comments.
So maybe we shouldn't be expecting it to fix this.
Also, looking at sample results (attached), it seems like we don't have
such a large problem as one might guess. It looks like people have
mostly formatted declarations to work with this indentation already,
either because their editors did it automatically, or because they were
thinking that this might get fixed someday. (I know I've often had that
in the back of my mind.) There are some places in the attached diff
that I might take the trouble to clean up manually, but not that many.
I found out that my initial draft of a multi-line lookahead function was
not nearly smart enough to survive contact with the PG source corpus,
but after rejiggering it to cope with comments and attributes, it seems
to do quite well.
A small problem with the "rejiggering" is that it now makes the wrong
choice for K&R-style function definitions, causing them to be weirdly
indented. For our purposes, that's a non-problem so I'm not excited
about trying to make it smart enough to recognize those. We do have
a couple of amazingly old and crufty K&R-style functions in src/port/,
though, so probably we'd wish to fix those.
Attached is working draft of pg_bsd_indent changes (still sans comments)
as well as a patch showing the difference between current pgindent
results on HEAD and the results of this version. I think there's no
question that this is an improvement.
regards, tom lane
Attachments:
bsdindent.patchtext/x-diff; charset=us-ascii; name=bsdindent.patchDownload
diff --git a/indent.h b/indent.h
index 0fffd89..1708dbc 100644
--- a/indent.h
+++ b/indent.h
@@ -41,6 +41,8 @@ void diag2(int, const char *);
void diag3(int, const char *, int);
void diag4(int, const char *, int, int);
void dump_line(void);
+int lookahead(void);
+void lookahead_reset(void);
void fill_buffer(void);
void parse(int);
void pr_comment(void);
diff --git a/io.c b/io.c
index df11094..8d13a52 100644
--- a/io.c
+++ b/io.c
@@ -51,6 +51,13 @@ static char sccsid[] = "@(#)io.c 8.1 (Berkeley) 6/6/93";
int comment_open;
static int paren_target;
+
+static char *lookahead_buf; /* malloc'd buffer, or NULL initially */
+static char *lookahead_buf_end; /* end+1 of allocated space */
+static char *lookahead_start; /* => next char for fill_buffer() to fetch */
+static char *lookahead_ptr; /* => next char for lookahead() to fetch */
+static char *lookahead_end; /* last+1 valid char in lookahead_buf */
+
static int pad_output(int current, int target);
void
@@ -252,6 +259,58 @@ compute_label_target(void)
: ps.ind_size * (ps.ind_level - label_offset) + 1;
}
+/*
+ * Read data ahead of what has been collected into in_buffer.
+ *
+ * Successive calls get further and further ahead, until we hit EOF.
+ * Call lookahead_reset to rescan from just beyond in_buffer.
+ */
+int
+lookahead(void)
+{
+ while (lookahead_ptr >= lookahead_end) {
+ int i = getc(input);
+
+ if (i == EOF)
+ return i;
+ if (i == '\0')
+ continue; /* fill_buffer drops nulls, so do we */
+
+ if (lookahead_end >= lookahead_buf_end) {
+ /* Need to allocate or enlarge lookahead_buf */
+ char *new_buf;
+ size_t req;
+
+ if (lookahead_buf == NULL) {
+ req = 64;
+ new_buf = malloc(req);
+ } else {
+ req = (lookahead_buf_end - lookahead_buf) * 2;
+ new_buf = realloc(lookahead_buf, req);
+ }
+ if (new_buf == NULL)
+ errx(1, "too much lookahead required");
+ lookahead_start = new_buf + (lookahead_start - lookahead_buf);
+ lookahead_ptr = new_buf + (lookahead_ptr - lookahead_buf);
+ lookahead_end = new_buf + (lookahead_end - lookahead_buf);
+ lookahead_buf = new_buf;
+ lookahead_buf_end = new_buf + req;
+ }
+
+ *lookahead_end++ = i;
+ }
+ return (unsigned char) *lookahead_ptr++;
+}
+
+/*
+ * Reset so that lookahead() will again scan from just beyond what's in
+ * in_buffer.
+ */
+void
+lookahead_reset(void)
+{
+ lookahead_ptr = lookahead_start;
+}
/*
* Copyright (C) 1976 by the Board of Trustees of the University of Illinois
@@ -293,11 +352,16 @@ fill_buffer(void)
p = in_buffer + offset;
in_buffer_limit = in_buffer + size - 2;
}
- if ((i = getc(f)) == EOF) {
- *p++ = ' ';
- *p++ = '\n';
- had_eof = true;
- break;
+ if (lookahead_start < lookahead_end) {
+ i = (unsigned char) *lookahead_start++;
+ } else {
+ lookahead_start = lookahead_ptr = lookahead_end = lookahead_buf;
+ if ((i = getc(f)) == EOF) {
+ *p++ = ' ';
+ *p++ = '\n';
+ had_eof = true;
+ break;
+ }
}
if (i != '\0')
*p++ = i;
diff --git a/lexi.c b/lexi.c
index 3c7bfef..df71a20 100644
--- a/lexi.c
+++ b/lexi.c
@@ -148,6 +148,54 @@ strcmp_type(const void *e1, const void *e2)
return (strcmp(e1, *(const char * const *)e2));
}
+/*
+ * Scan over a function argument declaration list, then see if it is
+ * followed by '{', indicating that it's a function definition.
+ * If it's followed by ';' or ',', it's a prototype. Otherwise keep
+ * scanning, because there might be whitespace, comments, or attribute
+ * declarations before we get to the telltale punctuation.
+ *
+ * Note that this will make the wrong decision for a K&R-style function
+ * definition. Too bad.
+ */
+static int
+is_func_definition(char *tp)
+{
+ int paren_depth = 0;
+ int in_comment = false;
+ int lastc = 0;
+
+ lookahead_reset();
+ for (;;) {
+ int c;
+
+ if (tp < buf_end)
+ c = *tp++;
+ else {
+ c = lookahead();
+ if (c == EOF)
+ break;
+ }
+ if (in_comment) {
+ if (lastc == '*' && c == '/')
+ in_comment = false;
+ } else if (lastc == '/' && c == '*')
+ in_comment = true;
+ else if (c == '(')
+ paren_depth++;
+ else if (c == ')') {
+ paren_depth--;
+ if (paren_depth < 0)
+ return false;
+ } else if (paren_depth == 0 && c == '{')
+ return true;
+ else if (paren_depth == 0 && (c == ';' || c == ','))
+ return false;
+ lastc = c;
+ }
+ return false;
+}
+
int
lexi(struct parser_state *state)
{
@@ -348,15 +396,12 @@ lexi(struct parser_state *state)
} /* end of if (found_it) */
if (*buf_ptr == '(' && state->tos <= 1 && state->ind_level == 0 &&
state->in_parameter_declaration == 0 && state->block_init == 0) {
- char *tp = buf_ptr;
- while (tp < buf_end)
- if (*tp++ == ')' && (*tp == ';' || *tp == ','))
- goto not_proc;
+ if (is_func_definition(buf_ptr)) {
strncpy(state->procname, token, sizeof state->procname - 1);
if (state->in_decl)
state->in_parameter_declaration = 1;
return (funcname);
- not_proc:;
+ }
}
/*
* The following hack attempts to guess whether or not the current
diff --git a/tests/declarations.0.stdout b/tests/declarations.0.stdout
index e97e447..ec63596 100644
--- a/tests/declarations.0.stdout
+++ b/tests/declarations.0.stdout
@@ -64,10 +64,10 @@ static int ald_shutingdown = 0;
struct thread *ald_thread;
static int
-do_execve(td, args, mac_p)
- struct thread *td;
- struct image_args *args;
- struct mac *mac_p;
+ do_execve(td, args, mac_p)
+struct thread *td;
+struct image_args *args;
+struct mac *mac_p;
{
}
diff --git a/tests/list_head.0.stdout b/tests/list_head.0.stdout
index b6f0762..a8f985f 100644
--- a/tests/list_head.0.stdout
+++ b/tests/list_head.0.stdout
@@ -1,10 +1,10 @@
/* $FreeBSD$ */
/* See r309380 */
static int
-do_execve(td, args, mac_p)
- struct thread *td;
- struct image_args *args;
- struct mac *mac_p;
+ do_execve(td, args, mac_p)
+struct thread *td;
+struct image_args *args;
+struct mac *mac_p;
{
}
indent-delta-results.patch.gzapplication/x-gzip; name=indent-delta-results.patch.gzDownload
�W�\indent-delta-results.patch �<ko�8���_A����c;��`���G:��~d�t�
p�@I���^���3���WU�$R/;�,.b�,��b�H��=��~��s���8�S�>������V���hEv�
1u�����\��9'��v�SW��������j�<|����^������oc����dy���/�\Y�~~w���u�����|d��e�W�C%<Q^�,����m���D��H#��@T�"�� ��8`�M_�UlOxQB�q��"sD�B�G���-J*��DI,�J������ ���Z�rxr`��h�
&�zC��D��U�>��,��(�����q���b��a�sQ7t3�-2�#�=����8�G/�,�;���������f�@GD��i�z���~����A�B����>��;�G�Q&�Q��z�c�2����T��?P�)��K���m;���)s6~��X�qe �����2?Z�����E�5��
Bbsh_�2����
t��l-��e�=�����<(D��m�gQSW��������1Q[�v��� ^p?����q8r 0�(NC���aI1�Z���$�]YvJ$�����Wt��(�E�b��`1���5�nQ�y~�� ��7 �_��,��z-~��J�$��j������<�9HN`I��������$�
e?��0�}i�����`/����������?����k�#pC�J�����*M�U�I�i@(�u�V�����!��� l�aT��ij��8v,���E��a�,�&*���4M]��l����8�O����T�yH��_�J��Ex����D.���s�������b��v�)���
!q71y��, �T�e�~���J��P� �����]�f��}<>dl�p�G2dH�� x6�t�����C�3R)��?�����bF+�P*b�s:�.�S�|>��yO�2���@b�rv69gG�^��X��q�k;�P�����)L\���Y����-/'
9^��Y�jb�-�nJp���S���r������VK�������,�8ro�S���P>