Wow, that's really striking. I know that goto statements have their uses but for something written in the last couple of years to have over a thousand of them is very surprising (it might not be surprising at all for those who write C code all the time). I guess they're mostly just for error handlers?
"goto considered harmful" is taken out of context and bemoaned mostly by people unfamiliar with idiomatic C, I think. (Edit: sorry, I mean just for C. For other languages, e.g. Go, there may be more appropriate patterns like the 'defer' keyword.)
If you're writing a recursive descent parser for C while keeping minimal lookahead, I can think of a place or two where goto might really help. One is to deal with casts, compound literals and subexpressions. They all begin with a left-parenthesis, so you can't tell what you're dealing with until a bit further. Since these all appear in the parsing of simple expressions (identifiers, constants, unary operators), the code can go in one function and you can jump to the right place with goto as soon as you know what you are dealing with.
I did not look in the Go code but C programmers mostly use goto for error paths.
Some are for single error return, but others are just to make a nice structure for the code.
This smells of very old code (as the header testifies)
> Portions Copyright © 2009 The Go Authors. All rights reserved
That's pretty recent.
And here's BSD style(9): http://www.freebsd.org/cgi/man.cgi?query=style&sektion=9
The function type should be on a line by itself preceding the function. int
main
(int argc, char **argv)
{
//body..
}
int main(int argc, char **argv) {
//body..
}
for x in y; do
# body
doneIt is also a pretty common style in the open source world.
> It is also a pretty common style in the open source world.
Depends, one proeminent C project doesn't use that: the linux kernel
And I can do it without ctags. That's the point.
>Depends, one proeminent C project doesn't use that: the linux kernel
That doesn't make his statement "depends" at all. A single project not using that style does not contradict it being "pretty common".
I do wish that in C1x (for x > 1), they could find a way to let us declare multiple formal arguments of the same type without repeating the type:
float
my_graphics_hack(float x, y, z, r, g, b, u, v) { ...
float my_graphics_hack(float x, float y, float z, float r, float g, float b, float u, float v) { ...
Preferring that function names start at the first column to make searching easier is a perfectly good justification.
You, on the other hand, seemingly would impose your tools (which have their shortcomings) and workflow on people with no justification at all.
Just because a tool exists, doesn't mean it's good (or better than what people are accustomed to) or that everyone must use it.
Do you think everyone should use Vim on Linux too?
Adding syntactic sugar to a language makes the language bigger and harder to completely understand, it makes it easier to misuse a feature (and C already has a lot of trickery with types, like when you declare a parameter as an array but it behaves like a pointer). I'm a strong believer that implicit is better than explicit and that while there are many ways to do the same thing some are better than other in practice. Of course, "in practice" can change from one project to the other, what matters in consistency. I applaud the choice of Go to standardize on a single coding style for instance.
For the particular example of the parent, while I write a lot of C code for work and for fun I have yet to encounter a situation where I saw a function taking 10 floats as arguments and thinking "yup, that's completely the right way to do that". If you have an example of such a code I'd me more that willing to reconsider my position, otherwise we're just talking about the best way to tame a unicorn.
You can also search for something like "\w+\s(.?)\s*{"
It's not about finding the function name in general, it's about finding where the function is actually declared -- not in the call sites.
>You can also search for something like "\w+\s(.?)\s{"*
Yeah, or use ctags. That's why they said "simpler".
"^foo" beats that.
> "^foo" beats that
because it's so hard to use ctags...
grep -n ^functionname *.c
Hardly surprising. Gotos will be found by the hundrends or thousands in C projects like compilers, kernels etc.
It's used for localized consolidated error handling, but also for stuff like parsing code (bison generates tons of gotos IIRC), state machines, etc.
If anything it's the old "Goto statement considered harmful" that's a little too naive.
No, people who didn't read it and just repeat the title without knowing what he was talking about may be too naive, but the original point was not.
I don't think the authors were very goto-averse.