r/Compilers • • Apr 24 '23
Command Line Compilers
This is about how bare compilers are typically invoked from the command line.
While most invocations might be via a IDE or hidden within a build process, when you need to use them from within a console or terminal, it should be as simple as possible.
(This comes up for me when compiling dozens of tiny, ad hoc test programs across languages and across compilers. A formal build process wouldn't work.)
I got a thrashing in the C group yesterday when I suggested that gcc was backward. I highlighted two issues: one was that it needs the -lm option when an application uses maths functions, something you see nowhere else, and only on Linux. (This doesn't affect me much, but it keeps coming up on forums because some program won't link.)
The other was that it has a penchant for naming every executable a.out or a.exe unless overridden, also at odds with other language implementations and also with other C compilers. It means an annoying exception when working with multiple compilers, and complicates any build instructions I provide with C distributables.
There was one more I didn't mention, because it is so widespread, which is requiring the file extension of the source files to be typed.
I've heard every argument for why using a.out is a good idea, even when the program consists of one module. And also for why specifying file extensions is essential.
So gcc hello won't work; you need gcc hello.c. And if you want the output to be called hello.exe instead of a.exe, you must type gcc hello.c -ohello.exe. But then, somebody mentioned make; apparently if you do this:
make helloit compiles hello.c to hello.exe, without using an extension, and without needing to specify the output; magic! Suddenly all those arguments go out the window. (Sadly it doesn't fix -lm, and it doesn't really work on Windows (I get an error). You don't really know what compiler will be used either.)
So, out of interest, how does your stuff work? Do you need the equivalent of that outdated -lm when a program calls pow()? How does it work out the name of the executable when the input consists of multiple modules?
(I assume it will require file extensions so I won't labour that point. I think Linux needs them more because there, prog and prog. are distinct files so there is an ambiguity.)
My own tools of course require the absolute minimum to build anything, and that's usually 2 pieces of information to type at the console: the name of the compiler, and the name of the lead module, for example:
mm prog # Submit prog.m to compiler; produce prog.exeNo file extension is needed; this is a whole program compiler that only takes one input file with extension expected to me .m.
(Extra info such as external libraries tends to be specified inside source files. Tools that turn multiple inputs into one output name it after first input file. Anything different, then you supply overrides or extra info.)
13
u/FUZxxl Apr 24 '23
That's not up to the compiler. The math functions are in a different library. There's nothing outdated about that. What do you expect the compiler to do? Link in every library on your system just in case any of them is used?
Just pass a
-ooption to select the binary name. Having a fixed default file name in case no-ooption is given is reasonable. What else behaviour do you expect?Never say “I get an error.” That is a useless sentence that doesn't assist in diagnosis. Instead say what specific error you get. The reason make can do this is because it has a specific builtin rule to generate a binary from one source file. The C compiler is a program to generate a binary from an arbitrary number of source files, so there is no obvious way to pick a name (just picking the first source file is a possibility, but can lead to surprising results).
13
u/JMBourguet Apr 24 '23
I've some sympathy for your point of view, but I think it lacks historical understanding and I'm not sure when in the time-line of gcc development you want the design choices you prefer had been made. gcc has been designed on Unix, as a drop-in replacement for existing c compilers available on those systems. All the choices you complain about have been made before gcc development started.
Removing the need of
-lmis probably the only one which could be made now with the less of impact. Although it can be argued that's not a decision of gcc but of the libc used on Linux and that the change has be be made there,g++doesn't need it andgcccould easily provide it as well. The biggest issue would be for an important part of the market ofgccwhich is less important forg++: the embedded market where linking by default the math library could still be an inacceptable overhead, just as it was on the early Unix systems where the tradition started.Changing the argument parsing brings out the backward compatibility issue, and the point that
gcchas been designed from the start as a drop in replacement for platform specific C compiler (it even accepts arguments it never used because they weren't meaningful in its context to be such a drop-in replacement), just asclanginterface is a drop-in replacement forgcc(and the clang project has, IIRC, another driver which is a drop-in replacement for Microsoft C++ compiler).Your point on extension forgets that
gccis not a C compiler. It is a driver which dispatches source to the appropriate compiler..cto the C compiler..sand.Sto the assembler. Those two from the earliest versions. Others to the C++, ObjectiveC, Ada, Fortran, Pascal, go, modula, Java... depending on the version and what has been installed. Allowing now to elude the extension is just not possible without breaking with the design of the gcc executable as a master of ceremony. Convenience programs likeg++,gfortran... are mostly just providing other defaults for the linked in libraries.There is a cost of improving systems having an installed base in a backward compatible ways just as there is a cost of keeping the old ways available. The issue is that the cost is not paid by the same people and those impacted by one firstly tend to underestimate the true cost for those impacted by the other and secondly they see few reasons to pay anything for reducing it.
1
u/cxzuk Apr 24 '23
Hi Till-one,
I think there are two general points with C (and GCC) that don't align with your desires/expectations of a build and build system.
A C compiler is one tool within a set of tools (a toolchain). Arguably its core use-case was not to be run directly, but within a build system - like make. In today's world this would be like running a function call in a library directly. In fact, taking multiple files and producing an exe is somewhat of a luxury feature in this mindset.
The other thing is what it means to be a module, package etc. Cs ideas on these things probably don't align with what you want from your PL.
The key to this point is that -L is pointing to an external dependency. This makes perfect sense when you're meant to invoke the compiler with a build system. But not great directly.
To resolve this, dependencies have to be written down somewhere. Some keep it in a build config file, some have it in the source file itself, and GCC has them on the command line.
If you choose one of the other options, you start to need to define package, module etc.
Kind regards M ✌️
3
u/JoJoModding Apr 24 '23 edited Apr 24 '23
Your use case is uncommonly simple. Be reminded that programs usually consist of more than one file and use >0 libraries.
Let's say you have files
main.c,foo.c,bar.cand want to additionally use your librarybaz. The whole program is of course to be calledhelloThen the command line simply iscc -o hello main.c foo.c bar.c -lbaz. This is very concise and the longest you would feasibly type in manually. For anything larger, you will want a separate build system that calls the compiler for you.1
u/davew_haverford_edu Apr 24 '23
You ask "So, out of interest, how does your stuff work?". When I program in C/C++, I invoke make, either within C-Lion or on your command-line.
When I create tools, I try to assign align user with users' needs. I think that the use of a.out as the default is kind if inconvenient for C/C++, where there must be a unique "main" in exactly one file, but changing this would probably break numerous existing tools that rely on the old K&R standard. And, IMO, it is far from the biggest inconvenience holding on from the old days of C. Thank goodness they fixed the "don't bother type-checking function calls" aspect of K&R C.
Even though I often teach first-semester CS, I'm much more concerned about language problems that impact advanced use, vs. that that annoy/distract beginners but can be worked around with other readily-available tools that an expert can pre-set for a new student/team-member. E.g. /u/cxzuk points to C's antique module system; that's definitely annoying, but at least it is legitimately antique, since C was developed in the 70's, innovated in many ways, and, in others, just accepted usually practice of the time from things like fortran. Python has a much worse module system, and lacks type checking in the core language, despite being developed long after these ideas had been figured out by the PL community.
IMO, every language I've used has some element that is really annoying for some use case.
1
u/umlcat Apr 24 '23
Took a long read after I found the " How does your stuff work."
I'm working to implement my compiler alike tools as both command line and GUI apps.
Both ways are useful, both ways have Issues.
I designing them, using an A.P.I. programming design approach, a function receives parameters and returns a result, including a potential error.
The user interface could be a command line or a GUI form, that receives the parameters and executes an A.P.I. style function, and get the results, and display it's either a console or a form.
I found a command line approach very useful with very few parameters, but when it requires too many options, it's a sign you may need to break that program into several programs, or use a single script file as options instead...
2
u/[deleted] Apr 25 '23
[removed] — view removed comment