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

Why does the C preprocessor interpret the word “linux” as the constant “1”?

stackoverflow.com

Post reply on HN
Print view View original

31–40 of 60 posts

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#31

Post by pcwalton »

simias wrote: post #24
pcwalton wrote: post #21

Earlier quoted context omitted.

Yup. This is why in Rust macros have to end with a ! (and syntax highlighters know about this). This was a hard call, because it prevents using macros to create forms that look exactly like the built-in ones, but it prevents issues such as the one described in the OP.

Ah! That's great, I didn't know that. The more I hear about rust the more I like it. But then I'm reminded that it bakes garbage collection into the core language... Oh well, perfection is no of this world.

GC is being removed from the core language and will migrate to a library before 1.0.

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#32

Post by kibwen »

rbehrends wrote: post #27
pcwalton wrote: post #21

Earlier quoted context omitted.

Yup. This is why in Rust macros have to end with a ! (and syntax highlighters know about this). This was a hard call, because it prevents using macros to create forms that look exactly like the built-in ones, but it prevents issues such as the one described in the OP.

That's not the original issue. The problem is that the compiler silently predefines an undocumented macro. If the compiler silently predefined an undocumented variable, type, or function called "linux" or "unix", that too can be a problem. E.g., if there were a global function linux() on Linux systems only and you tried to define a global variable linux in your code, you'd get an error, too. The clean solution is to…

But Patrick isn't responding to the original issue, he was responding to simias' assertion that macros should be syntactically disambiguated.

  > If the compiler silently predefined an undocumented 
  > variable, type, or function called "linux" or "unix", 
  > that too can be a problem.
While we're on the topic of Rust, the compiler actually used to do this! In the early days, the identifiers "error", "warn", "info", and "debug" were all magical, undocumented constants for controlling logging levels. As you might expect, this caused problems. :P So don't think that Patrick isn't keenly aware of the perils of including non-keyword identifiers by default.

As for clang, their solution is the best they can do given that they don't have the authority to make the call over whether to syntactically disambiguate macros. It's definitely a debate to be had in the case of a language designed from scratch, and the Rust devs decided to err on the side of explicitness (you can contrast e.g. Elixir, which has the same sort of structural macros but chose not to distinguish their invocation syntax).

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#33

Post by pcwalton »

ajross wrote: post #22
pcwalton wrote: post #21

Earlier quoted context omitted.

Yup. This is why in Rust macros have to end with a ! (and syntax highlighters know about this). This was a hard call, because it prevents using macros to create forms that look exactly like the built-in ones, but it prevents issues such as the one described in the OP.

But... the ability to use macros to create forms that look like "real" syntax is sort of the point. I don't think you can fix this with a language feature or style convention. Metaprogramming is "dangerous" because the meta constructs don't (can't!) act like what they look liks. Metaprogramming is "great" because the meta constructs look like simple programming but have surprisingly deep behavior. As I see it all you…

People don't expect an ordinary-looking identifier like "linux" to macro-expand to something else, like the number 1. That was the source of the confusion in the OP. Syntactically distinguishing identifiers that will be macro-expanded from identifiers that won't does solve this problem.

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#36

Post by agscala »

simias wrote: post #24
pcwalton wrote: post #21

Earlier quoted context omitted.

Yup. This is why in Rust macros have to end with a ! (and syntax highlighters know about this). This was a hard call, because it prevents using macros to create forms that look exactly like the built-in ones, but it prevents issues such as the one described in the OP.

Ah! That's great, I didn't know that. The more I hear about rust the more I like it. But then I'm reminded that it bakes garbage collection into the core language... Oh well, perfection is no of this world.

What's wrong with garbage collection being built into the language?

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#37

Post by agscala »

simias wrote: post #24
pcwalton wrote: post #21

Earlier quoted context omitted.

Yup. This is why in Rust macros have to end with a ! (and syntax highlighters know about this). This was a hard call, because it prevents using macros to create forms that look exactly like the built-in ones, but it prevents issues such as the one described in the OP.

Ah! That's great, I didn't know that. The more I hear about rust the more I like it. But then I'm reminded that it bakes garbage collection into the core language... Oh well, perfection is no of this world.

What's wrong with garbage collection being built into the language?

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#38

Post by eropple »

agscala wrote: post #36
simias wrote: post #24

Earlier quoted context omitted.

Ah! That's great, I didn't know that. The more I hear about rust the more I like it. But then I'm reminded that it bakes garbage collection into the core language... Oh well, perfection is no of this world.

What's wrong with garbage collection being built into the language?

Performance. Rust is able to provide its desired expressiveness without forcing you to make that tradeoff every time you use it.

Re: Why does the C preprocessor interpret the word “linux” as the constant “1”?

#40

Post by WTFPL »

simias wrote: post #13

And that's why, in my opinion, non capitalized macros are always evil (yes, I'm looking at you linux kernel). When I see a lowercase symbol used as a variable, I expect it's going to be some actual global variable. When I see a lower case symbol used like a function I expect it's an actual function. And then comes the day I want to take the address of the "function" and it fails. Or worse, I make a syntax error somew…

Completely agreed.
Post reply on HN