Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Ifs and &&s and Plan 9's Source Code

computationallyendowed.com

Post reply on HN
Print view View original

91–100 of 150 posts

Re: Ifs and &&s and Plan 9's Source Code

#91

Post by calebegg »

Someone wrote: post #63
calebegg wrote: post #49

Earlier quoted context omitted.

What? Not for me, not with cindent on. It indents each if statement by one level, just like it "should". How would it somehow know to not indent them?

An auto-indenter could easily detect the idiom if hit backspace after the auto-indent it produced after the first 'if'. Once you have your two ifs at the same indent, the indenter can use that info to keep them at the same indentation level. It could even assume you mean (a&&b) vs (!a&&!b) and not the three-way (a&&b), (a&&!b), (!a) when you follow it with an else block (I think that would be the best heuristic) Impl…

That's all good and well, but vim does not do this and, more generally, does not support this style, which is what I was saying.

Re: Ifs and &&s and Plan 9's Source Code

#92

Post by rayiner »

DannyBee wrote: post #82
rayiner wrote: post #24

Earlier quoted context omitted.

Because something you do relatively early in the compiler is throw away all of the structure of the source, including flattening nested expressions into a linear IR. Mapping back to line numbers in the debugger is a bit hacky to begin with, and mapping back in an even more fine-grained way would be more complex still.

Both line and column information are completely carried through the process, and put into debug info, these days. It's not hacky, it's actually completely well structured. Even debugging info for C/C++ macros is there and done properly. None of this is new. DWARF2 (or 3 or 4), the standard debugging format for all non-MS compilers, has been able to do this well since 1993 .

It's hacky in the sense that it's somewhat ad-hoc the manner in which line/column information makes it through from the source text, through the intermediate representation and optimizations, into the generated code and debug information.

In Clang/LLVM, for example, nodes are annotated with debug information using LLVM's metadata system. However, it is strictly optional for any given transformation to preserve the metadata on IR nodes. So what makes it through after optimizations is kind of a "best effort" affair.

Re: Ifs and &&s and Plan 9's Source Code

#94

Post by notaddicted »

Avshalom wrote: post #80
triztian wrote: post #14

How about using this alternative form: if((b != nil) &&(b->qid.type==a->qid.type) &&(b->qid.path==a->qid.path) &&(b->qid.vers==a->qid.vers) &&(b->dev==a->dev) &&(b->type==a->type)){ fprint(2, "cp: %s and %s are the same file\n", an, bn); ret = 1; } It keeps almost the same visual look and it uses the common convetion, except for the && at the beginning of each line.

if(b != nil){ if(b->qid.type==a->qid.type){ if(b->qid.path==a->qid.path){ if(b->qid.vers==a->qid.vers){ if(b->dev==a->dev){ if(b->type==a->type){ fprint(2, "cp: %s and %s are the same file\n", an, bn); ret = 1; }}}}}} I will never understand the allergy to multiple braces on one line.

I think the aversion is because the way that they line up visually is the opposite of the way that they are matched by the parser. I think everyone needs a dose of LISP to get over any problems they have with any frequency or arrangement of brackets/parens/braces. Anyway, having a function that compares two structs and returns 0 or 1 with a printf out to stderr is just gross in my opinion.

Re: Ifs and &&s and Plan 9's Source Code

#95

Post by __david__ »

ebbv wrote: post #31

Oh god that code is fucking hideous. If someone who worked with me wrote that I'd talk to them about it and make sure they never did anything like that ever again. From the terrible argument names to the abuse of the single line if syntax (which should never be used anyway, always use curly braces.)

No. Single line if syntax is good. Gratuitous curlies make the code longer and ultimately harder to read (since you can't fit as much on a page). Being able to see your whole function/algorithm at once is more important that almost any other consideration.

Re: Ifs and &&s and Plan 9's Source Code

#96

Post by glurgh »

OldSchool wrote: post #81
glurgh wrote: post #75

Earlier quoted context omitted.

Short circuit is guaranteed by the language standard. On top of that, plan9 comes with its own C compiler so the people who wrote this also wrote the compiler used to compile it.

I see, I just have no idea how complete the Plan 9 tools are. Working with in-house domain specific language interpreters or compilers I've twice seen unary minus support missing so I assumed anything was possible when something's not fully commercialized.

This popped up in some other thread recently. It was (still is, I suppose) a standard ANSI C89 compiler with a couple of small extensions and tweaks. Ken Thompson's short overview is here -

http://plan9.bell-labs.com/sys/doc/compiler.html

You can nerdmuse yourself a little by googling why it had a

    #pragma hjdicks

Re: Ifs and &&s and Plan 9's Source Code

#97

Post by DannyBee »

rayiner wrote: post #92
DannyBee wrote: post #82

Earlier quoted context omitted.

Both line and column information are completely carried through the process, and put into debug info, these days. It's not hacky, it's actually completely well structured. Even debugging info for C/C++ macros is there and done properly. None of this is new. DWARF2 (or 3 or 4), the standard debugging format for all non-MS compilers, has been able to do this well since 1993 .

It's hacky in the sense that it's somewhat ad-hoc the manner in which line/column information makes it through from the source text, through the intermediate representation and optimizations, into the generated code and debug information. In Clang/LLVM, for example, nodes are annotated with debug information using LLVM's metadata system. However, it is strictly optional for any given transformation to preserve the me…

But this is not ad-hoc at all. This is how it is deliberately designed so it degrades gracefully depending on what optimizations you choose.

Not all compilers even really degrade. GCC does post-hoc variable tracking (and thus is mostly unaffected by optimization except when values are optiized out completely). For declarations and statements, the info is always on the declaration, so it won't be lost.

Both compiler guarantee that at -O0, all debug info will be kept.

Re: Ifs and &&s and Plan 9's Source Code

#98

Post by LeonidasXIV »

jamesaguilar wrote: post #66
adrianmsmith wrote: post #20

Earlier quoted context omitted.

I believe that the layout of code is done by humans for humans. An auto code formatter destroys all of that meaning. I blogged about this more here: http://www.databasesandlife.com/do-not-use-automatic-code-re...

Yeah, I saw that. I think it's misguided. The amount of time spent on arguing about style far exceeds the time savings of the changes you propose. People can get used to different formats quite easily, but time spent arguing about and maintaining formats can never be recovered. Also, your formatter looks pretty brain-dead. clang-format formats all of those cases (in C++) as in your green examples with Google style tu…

I agree and for this reason, gofmt, an automatic formatter for Go code is possibly my favorite part of the toolchain. It is kinda like PEP8 for Python but formalized into a program (there is a third party pep8 program) or Emacs for Common Lisp. The advantage is that it is a standard tool.

So I can just run it over my code, no matter what editor I used and the code is fine. No arguing what is right, no thinking about where to put some stupid spaces or how to break a fucking line, just run gofmt, done.

Re: Ifs and &&s and Plan 9's Source Code

#99

Post by ufo »

cnvogel wrote: post #46
adrusi wrote: post #25

I use this convention often for loops: for (int x = 0; x The semantics are kind of like using a comprehension.

I abhor deep indents, and when I have deeply nested loops that just serve to trivially enumerate things, in C I sometimes add a helper function for the iteration. e.g. instead of: for(int i=0;i it might become i=j=k=0; while(all_frob_indices(&i,&j,&k)){ .... with all_frob_indices() doing the i++; if(i>N){ i=0; j++ }... This makes code look more similar to e.g. itertools-constructs in python where you can easily make…

The biggest problem I see in doing this is that since C++ does not have yield statements / coroutines / continuations you need to write the iterator code "inside out" and with explicit state, something that usually ends up harder to read than a regular nested-for-loop iteration.

Re: Ifs and &&s and Plan 9's Source Code

#100

Post by carlob »

In Mathematica the FullForm of a && b is And[a, b]. You can use this to format long lists of conditions as

    And[
        a,
        b
    ]
You can also rely on the fact that logical expressions are always short-circuited, so False && Print["won't be printed"], doesn't print anything.

Finally, you can put a bunch of conditions in a list and do And @@ list.

Post reply on HN