On 09/10/2021 09:39, Malcolm McLean wrote:
> On Friday, 8 October 2021 at 22:52:21 UTC+1, Bart wrote:
>>
>> It depends on what its for. It you're developing an application then you
>> will need to build it 100 times a day or more. You might the ability to
>> do incremental compilation.
>>
>> But for a one-off build of some downloaded project, it will have to
>> compile everything from scratch anyway. Then it can be done much more
>> simply.
>>
> We do an "integration build" whenever a unit of work is finished (we use JIRA
> and gitflow, a task is entered as a JIRA, a task branch is started, then it is merged
> into the develop branch when it is completed). Merging into the develop branch
> automatically triggers a complete re-build from scratch for all platforms.
>
> This caught a problem yesterday. I had entered some data as long string literals.
> The compiler I was using accepted the strings. But one of the Windows compilers
> rejected them as too long.
>

MSVC? That seems to have a 16K-char limit. You can get around it by
splitting the strings into multiple ones (I think on different lines
too), like "ABC" "DEF" instead of "ABCDEF".

Another way is to split with line continuation:

"ABC\
DEF"

The "\" can be inserted anywhere, even inside an escape sequence.

On 09/10/2021 05:51, Keith Thompson wrote:
> Thiago Adams <thiago.adams@gmail.com> writes:
>> On Friday, October 8, 2021 at 7:30:24 PM UTC-3, Thiago Adams wrote:
>> ...
>>> For Linux it is using default but I guess it could auto select as well, or show
>>> some options..
>>
>> This is what I found how to change default gcc (because build script has hardcoded gcc)
>>
>> "
>> 1. Open the terminal window in LINUX and execute the command:
>> $ which gcc
>> This will provide the symbolic link (softlink) to the default version of GCC.
>> 2. Navigate to the directory which has this softlink.
>> Change the softlink to point to the version of GCC that you want to use.
>> For example, for a standard GCC version 4.7 installed (where the compiler command is put at /usr/bin/gcc-4.7),
>> this can be done using the following command:
>> $ sudo ln -f -s /usr/bin/gcc-4.7 gcc
>> "
>> from
>> https://www.mathworks.com/matlabcentral/answers/454659-how-can-i-change-my-current-gcc-g-version-to-a-supported-one
>>
>>
>> also added
>> system(""gcc --version") inside the build script to know
>> what version is being used.
>>
>> this is an extra step , however I guess all linux programmers
>> must know about this.
>
> That's bad advice. Telling users to mess around with system-owned
> directories like /usr/bin is dangerous. I know Linux pretty well, and I
> don't do that myself.
>
> On my system, for example, /usr/bin/gcc is a symbolic link to "gcc-9",
> which is provided by the "gcc-9" package. That package provides 55
> files; the compiler executable is just one of them. If I manually
> change just the /usr/bin/gcc symlink, I'm likely to leave my system in
> an inconsistent state.
>
> And g++ (the C++ compiler) is provided by another package "g++9", which
> should normally be kept in synch with the gcc package.
>
> On Ubuntu, the "update-alternatives" command can be used to safely
> change the default version of a command. Other systems are likely to
> have something similar.
>

Ubuntu gets that from Debian, and so the same method is usable for other
Debian-based distributions.

As a general point, if you want to be sure you are using gcc version 9,
I'd much rather write "gcc-9" than change the system default. For my
embedded work, I have the exact compiler (indeed full toolchain,
including library and headers) specified in the project makefile.

You can also happily put symbolic links in ~/bin, or /usr/local/bin,
giving your own choice of names and linking to whatever versions of
programs you want. That too is far better than messing with /usr/bin.

On Saturday, October 9, 2021 at 7:54:18 AM UTC-3, David Brown wrote:
> On 09/10/2021 05:51, Keith Thompson wrote:
> > Thiago Adams <thiago...@gmail.com> writes:
> >> On Friday, October 8, 2021 at 7:30:24 PM UTC-3, Thiago Adams wrote:
> >> ...
> >>> For Linux it is using default but I guess it could auto select as well, or show
> >>> some options..
> >>
> >> This is what I found how to change default gcc (because build script has hardcoded gcc)
> >>
> >> "
> >> 1. Open the terminal window in LINUX and execute the command:
> >> $ which gcc
> >> This will provide the symbolic link (softlink) to the default version of GCC.
> >> 2. Navigate to the directory which has this softlink.
> >> Change the softlink to point to the version of GCC that you want to use.
> >> For example, for a standard GCC version 4.7 installed (where the compiler command is put at /usr/bin/gcc-4.7),
> >> this can be done using the following command:
> >> $ sudo ln -f -s /usr/bin/gcc-4.7 gcc
> >> "
> >> from
> >> https://www.mathworks.com/matlabcentral/answers/454659-how-can-i-change-my-current-gcc-g-version-to-a-supported-one
> >>
> >>
> >> also added
> >> system(""gcc --version") inside the build script to know
> >> what version is being used.
> >>
> >> this is an extra step , however I guess all linux programmers
> >> must know about this.
> >
> > That's bad advice. Telling users to mess around with system-owned
> > directories like /usr/bin is dangerous. I know Linux pretty well, and I
> > don't do that myself.
> >
> > On my system, for example, /usr/bin/gcc is a symbolic link to "gcc-9",
> > which is provided by the "gcc-9" package. That package provides 55
> > files; the compiler executable is just one of them. If I manually
> > change just the /usr/bin/gcc symlink, I'm likely to leave my system in
> > an inconsistent state.
> >
> > And g++ (the C++ compiler) is provided by another package "g++9", which
> > should normally be kept in synch with the gcc package.
> >
> > On Ubuntu, the "update-alternatives" command can be used to safely
> > change the default version of a command. Other systems are likely to
> > have something similar.
> >
> Ubuntu gets that from Debian, and so the same method is usable for other
> Debian-based distributions.
>
> As a general point, if you want to be sure you are using gcc version 9,
> I'd much rather write "gcc-9" than change the system default. For my
> embedded work, I have the exact compiler (indeed full toolchain,
> including library and headers) specified in the project makefile.
>
> You can also happily put symbolic links in ~/bin, or /usr/local/bin,
> giving your own choice of names and linking to whatever versions of
> programs you want. That too is far better than messing with /usr/bin.

If the name of gcc is fixed like gcc-10 gcc-11 etc..
I can create the following macro:

#define STR(a) #a
#define F(a) STR(a)
#define GCC F(gcc-__GNUC__)

GCC

This macro expand to "gcc-11" "gcc-10" etc..

Then
gcc-11 build.c && ./build

would use gcc-11 to create the "build script" and the build script would
use "gcc-11" to compile the target.

It is very nice we can use the preprocessor. For instance
if the code does not support gcc < 7 I can show an error

#if __GNUC__ < 7
#error "this build requires gcc > 7"
#endif

On 09/10/2021 15:30, Thiago Adams wrote:
> On Saturday, October 9, 2021 at 7:54:18 AM UTC-3, David Brown wrote:
>> On 09/10/2021 05:51, Keith Thompson wrote:
>>> Thiago Adams <thiago...@gmail.com> writes:
>>>> On Friday, October 8, 2021 at 7:30:24 PM UTC-3, Thiago Adams wrote:
>>>> ...
>>>>> For Linux it is using default but I guess it could auto select as well, or show
>>>>> some options..
>>>>
>>>> This is what I found how to change default gcc (because build script has hardcoded gcc)
>>>>
>>>> "
>>>> 1. Open the terminal window in LINUX and execute the command:
>>>> $ which gcc
>>>> This will provide the symbolic link (softlink) to the default version of GCC.
>>>> 2. Navigate to the directory which has this softlink.
>>>> Change the softlink to point to the version of GCC that you want to use.
>>>> For example, for a standard GCC version 4.7 installed (where the compiler command is put at /usr/bin/gcc-4.7),
>>>> this can be done using the following command:
>>>> $ sudo ln -f -s /usr/bin/gcc-4.7 gcc
>>>> "
>>>> from
>>>> https://www.mathworks.com/matlabcentral/answers/454659-how-can-i-change-my-current-gcc-g-version-to-a-supported-one
>>>>
>>>>
>>>> also added
>>>> system(""gcc --version") inside the build script to know
>>>> what version is being used.
>>>>
>>>> this is an extra step , however I guess all linux programmers
>>>> must know about this.
>>>
>>> That's bad advice. Telling users to mess around with system-owned
>>> directories like /usr/bin is dangerous. I know Linux pretty well, and I
>>> don't do that myself.
>>>
>>> On my system, for example, /usr/bin/gcc is a symbolic link to "gcc-9",
>>> which is provided by the "gcc-9" package. That package provides 55
>>> files; the compiler executable is just one of them. If I manually
>>> change just the /usr/bin/gcc symlink, I'm likely to leave my system in
>>> an inconsistent state.
>>>
>>> And g++ (the C++ compiler) is provided by another package "g++9", which
>>> should normally be kept in synch with the gcc package.
>>>
>>> On Ubuntu, the "update-alternatives" command can be used to safely
>>> change the default version of a command. Other systems are likely to
>>> have something similar.
>>>
>> Ubuntu gets that from Debian, and so the same method is usable for other
>> Debian-based distributions.
>>
>> As a general point, if you want to be sure you are using gcc version 9,
>> I'd much rather write "gcc-9" than change the system default. For my
>> embedded work, I have the exact compiler (indeed full toolchain,
>> including library and headers) specified in the project makefile.
>>
>> You can also happily put symbolic links in ~/bin, or /usr/local/bin,
>> giving your own choice of names and linking to whatever versions of
>> programs you want. That too is far better than messing with /usr/bin.
>
> If the name of gcc is fixed like gcc-10 gcc-11 etc..

This may vary by distribution or installation. If the user puts there
own links in ~/bin, they can decide the names themselves.

> I can create the following macro:
>
> #define STR(a) #a
> #define F(a) STR(a)
> #define GCC F(gcc-__GNUC__)
>
> GCC
>
> This macro expand to "gcc-11" "gcc-10" etc..
>
> Then
> gcc-11 build.c && ./build
>
> would use gcc-11 to create the "build script" and the build script would
> use "gcc-11" to compile the target.
>
> It is very nice we can use the preprocessor. For instance
> if the code does not support gcc < 7 I can show an error
>
> #if __GNUC__ < 7
> #error "this build requires gcc > 7"
> #endif
>

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>Thiago Adams <thiago.adams@gmail.com> writes:
>> On Thursday, October 7, 2021 at 11:41:30 AM UTC-3, Keith Thompson wrote:

>>
>> I found this "Here is the code in C which will delete the executable after execution."
>> https://unix.stackexchange.com/questions/280067/have-rm-not-report-when-a-file-is-missing
>
>Deleting the executable after running it once is certainly valid, but
>not something you'd usually want to do.

This paradigm was quite common in the early days of computing;
compile and go where the data deck immediately followed the program
deck (particularly on systems without disk or with small disk(s)).

The HP-3000 supported compile and go (from cards or from the interactive
command interpreter) using 'PASS' files. The logical name $OLDPASS
referred to an unnamed input temporary file and $NEWPASS to an unamed output temporary
file - the compiler would write to $NEWPASS, the segmenter (linker) would read from
$OLDPASS and write to $NEWPASS and $NEWPASS would be executed.

The paradigm fit educational computer science programs quite well in the
days before disk storage became routinely affordable.

scott@slp53.sl.home (Scott Lurndal) writes:
>Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>>Thiago Adams <thiago.adams@gmail.com> writes:
>>> On Thursday, October 7, 2021 at 11:41:30 AM UTC-3, Keith Thompson wrote:
>
>>>
>>> I found this "Here is the code in C which will delete the executable after execution."
>>> https://unix.stackexchange.com/questions/280067/have-rm-not-report-when-a-file-is-missing
>>
>>Deleting the executable after running it once is certainly valid, but
>>not something you'd usually want to do.
>
>This paradigm was quite common in the early days of computing;
>compile and go where the data deck immediately followed the program
>deck (particularly on systems without disk or with small disk(s)).
>
>The HP-3000 supported compile and go (from cards or from the interactive
>command interpreter) using 'PASS' files. The logical name $OLDPASS
>referred to an unnamed input temporary file and $NEWPASS to an unamed output temporary
>file - the compiler would write to $NEWPASS, the segmenter (linker) would read from
>$OLDPASS and write to $NEWPASS and $NEWPASS would be executed.
>
>The paradigm fit educational computer science programs quite well in the
>days before disk storage became routinely affordable.

Following up on topic from a few months ago, relative to 8-bit ASCII
character evolution at ANSI, I found the spec I had referred to then:

ANSI X3.41-1974 (AKA FIPS-35)
American National Standard code extension techniques for use with the 7-bit coded character
set of american national standard code for information interchange.

https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub35.pdf

On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:

[...]
"
if (system("cl "
SOURCE_FILES
" -o output_file.exe") != 0)
{
exit(1);
}
"

I little update:
When I wrote the script using "system" I didn't know that system on linux
does not return the exit code of the application it executes.
So instead of system I am using a "cmd" function that is:

//ON WINDOWS
int cmd(const char* command) {
return system(command);
}

//ON LINUX
#include <sys/wait.h>
int cmd(const char* command) {
int test_result = system(command);
int stat = 0;
wait(&stat);
if (WIFEXITED(stat)) {
test_result = WEXITSTATUS(stat);
}
else if (WIFSIGNALED(stat)) {
test_result = WTERMSIG(stat);
}
return test_result;
}

Thiago Adams <thiago.adams@gmail.com> writes:

> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>
> [...]
> "
> if (system("cl "
> SOURCE_FILES
> " -o output_file.exe") != 0)
> {
> exit(1);
> }
> "
>
>
> I little update:
> When I wrote the script using "system" I didn't know that system on linux
> does not return the exit code of the application it executes.

This is not really a C question. What system will report is very much
determined by the implementation.

If all goes well (there is a non-null argument and a shell that can be
executed) then it returns the exit status of the shell. That's the exit
status of the last comment the shell ran.

Why is this not good enough?

> So instead of system I am using a "cmd" function that is:
>
> //ON WINDOWS
> int cmd(const char* command) {
> return system(command);
> }

I would be surprised if Windows implementations of system did not have
the some very similar issues. Surely system can fail for all sorts of
reasons.

> //ON LINUX
> #include <sys/wait.h>
> int cmd(const char* command) {
> int test_result = system(command);
> int stat = 0;
> wait(&stat);
> if (WIFEXITED(stat)) {
> test_result = WEXITSTATUS(stat);
> }
> else if (WIFSIGNALED(stat)) {
> test_result = WTERMSIG(stat);
> }
> return test_result;
> }

I don't know what you are trying to do here, but this looks wrong. The
code in 'system' should have already "waited" for it's child pid, so
that wait should fail. You don't look at the return value so you can't
tell that it fails.

I think you should consider posting in comp.unix.programmer if you want
to unravel all the details of what system might return.

--
Ben.

Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
> Thiago Adams <thiago.adams@gmail.com> writes:
>
>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>>
>> [...]
>> "
>> if (system("cl "
>> SOURCE_FILES
>> " -o output_file.exe") != 0)
>> {
>> exit(1);
>> }
>> "
>>
>>
>> I little update:
>> When I wrote the script using "system" I didn't know that system on linux
>> does not return the exit code of the application it executes.
>
> This is not really a C question. What system will report is very much
> determined by the implementation.
>
> If all goes well (there is a non-null argument and a shell that can be
> executed) then it returns the exit status of the shell. That's the exit
> status of the last comment the shell ran.
>
> Why is this not good enough?

On POSIX systems, system() returns an int value from which the shell's
exit status can be extracted. For example, /bin/false does the
equivalent of exit(1), but system("/bin/false") will (very probably)
return 256, not 1.

[...]

> I think you should consider posting in comp.unix.programmer if you want
> to unravel all the details of what system might return.

Agreed.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 22/11/2021 21:18, Keith Thompson wrote:
> Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>> Thiago Adams <thiago.adams@gmail.com> writes:
>>
>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>>>
>>> [...]
>>> "
>>> if (system("cl "
>>> SOURCE_FILES
>>> " -o output_file.exe") != 0)
>>> {
>>> exit(1);
>>> }
>>> "
>>>
>>>
>>> I little update:
>>> When I wrote the script using "system" I didn't know that system on linux
>>> does not return the exit code of the application it executes.
>>
>> This is not really a C question. What system will report is very much
>> determined by the implementation.
>>
>> If all goes well (there is a non-null argument and a shell that can be
>> executed) then it returns the exit status of the shell. That's the exit
>> status of the last comment the shell ran.
>>
>> Why is this not good enough?
>
> On POSIX systems, system() returns an int value from which the shell's
> exit status can be extracted. For example, /bin/false does the
> equivalent of exit(1), but system("/bin/false") will (very probably)
> return 256, not 1.

My tests show that system() on Linux returns the last byte of the return
code, left shifted by 8 bits.

So a program returning 0x12345678 will yield 0x7800 when run from
system(). Maybe a simpler wrapper function for the OP then.

On Monday, November 22, 2021 at 5:39:47 PM UTC-3, Ben Bacarisse wrote:
> Thiago Adams <thiago...@gmail.com> writes:
>
> > On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
> >
> > [...]
> > "
> > if (system("cl "
> > SOURCE_FILES
> > " -o output_file.exe") != 0)
> > {
> > exit(1);
> > }
> > "
> >
> >
> > I little update:
> > When I wrote the script using "system" I didn't know that system on linux
> > does not return the exit code of the application it executes.
> This is not really a C question. What system will report is very much
> determined by the implementation.
>
> If all goes well (there is a non-null argument and a shell that can be
> executed) then it returns the exit status of the shell. That's the exit
> status of the last comment the shell ran.
>
> Why is this not good enough?

The objective is to know if the compilation failed or not. I am not sure
if gcc reports fails. ( I am checking )

I also have custom tools called using system("tool") that reports errors using the
exit code and I also need to check the result on windows and Linux.

Thiago Adams <thiago.adams@gmail.com> writes:

> On Monday, November 22, 2021 at 5:39:47 PM UTC-3, Ben Bacarisse wrote:
>> Thiago Adams <thiago...@gmail.com> writes:
>>
>> > On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>> >
>> > [...]
>> > "
>> > if (system("cl "
>> > SOURCE_FILES
>> > " -o output_file.exe") != 0)
>> > {
>> > exit(1);
>> > }
>> > "
>> >
>> >
>> > I little update:
>> > When I wrote the script using "system" I didn't know that system on linux
>> > does not return the exit code of the application it executes.
>> This is not really a C question. What system will report is very much
>> determined by the implementation.
>>
>> If all goes well (there is a non-null argument and a shell that can be
>> executed) then it returns the exit status of the shell. That's the exit
>> status of the last comment the shell ran.
>>
>> Why is this not good enough?
>
> The objective is to know if the compilation failed or not. I am not sure
> if gcc reports fails. ( I am checking )

Yes it does. I think you'll find that if you get 0 from system, the
compile worked.

--
Ben.

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:
>Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>> Thiago Adams <thiago.adams@gmail.com> writes:
>>
>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>>>
>>> [...]
>>> "
>>> if (system("cl "
>>> SOURCE_FILES
>>> " -o output_file.exe") != 0)
>>> {
>>> exit(1);
>>> }
>>> "
>>>
>>>
>>> I little update:
>>> When I wrote the script using "system" I didn't know that system on linux
>>> does not return the exit code of the application it executes.
>>
>> This is not really a C question. What system will report is very much
>> determined by the implementation.
>>
>> If all goes well (there is a non-null argument and a shell that can be
>> executed) then it returns the exit status of the shell. That's the exit
>> status of the last comment the shell ran.
>>
>> Why is this not good enough?
>
>On POSIX systems, system() returns an int value from which the shell's
>exit status can be extracted. For example, /bin/false does the
>equivalent of exit(1), but system("/bin/false") will (very probably)
>return 256, not 1.

Which is why the manual page recommends using the WEXITSTATUS macro.

It's always handy to RTFM.

Bart <bc@freeuk.com> writes:
>On 22/11/2021 21:18, Keith Thompson wrote:
>> Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>>> Thiago Adams <thiago.adams@gmail.com> writes:
>>>
>>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>>>>
>>>> [...]
>>>> "
>>>> if (system("cl "
>>>> SOURCE_FILES
>>>> " -o output_file.exe") != 0)
>>>> {
>>>> exit(1);
>>>> }
>>>> "
>>>>
>>>>
>>>> I little update:
>>>> When I wrote the script using "system" I didn't know that system on linux
>>>> does not return the exit code of the application it executes.
>>>
>>> This is not really a C question. What system will report is very much
>>> determined by the implementation.
>>>
>>> If all goes well (there is a non-null argument and a shell that can be
>>> executed) then it returns the exit status of the shell. That's the exit
>>> status of the last comment the shell ran.
>>>
>>> Why is this not good enough?
>>
>> On POSIX systems, system() returns an int value from which the shell's
>> exit status can be extracted. For example, /bin/false does the
>> equivalent of exit(1), but system("/bin/false") will (very probably)
>> return 256, not 1.
>
>My tests show that system() on Linux returns the last byte of the return
>code, left shifted by 8 bits.

$ man 3 system

Will describe the exact format of the return value and document
the macros used to extract the exit status.

On 23/11/2021 14:45, Scott Lurndal wrote:
> Bart <bc@freeuk.com> writes:
>> On 22/11/2021 21:18, Keith Thompson wrote:
>>> Ben Bacarisse <ben.usenet@bsb.me.uk> writes:
>>>> Thiago Adams <thiago.adams@gmail.com> writes:
>>>>
>>>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
>>>>>
>>>>> [...]
>>>>> "
>>>>> if (system("cl "
>>>>> SOURCE_FILES
>>>>> " -o output_file.exe") != 0)
>>>>> {
>>>>> exit(1);
>>>>> }
>>>>> "
>>>>>
>>>>>
>>>>> I little update:
>>>>> When I wrote the script using "system" I didn't know that system on linux
>>>>> does not return the exit code of the application it executes.
>>>>
>>>> This is not really a C question. What system will report is very much
>>>> determined by the implementation.
>>>>
>>>> If all goes well (there is a non-null argument and a shell that can be
>>>> executed) then it returns the exit status of the shell. That's the exit
>>>> status of the last comment the shell ran.
>>>>
>>>> Why is this not good enough?
>>>
>>> On POSIX systems, system() returns an int value from which the shell's
>>> exit status can be extracted. For example, /bin/false does the
>>> equivalent of exit(1), but system("/bin/false") will (very probably)
>>> return 256, not 1.
>>
>> My tests show that system() on Linux returns the last byte of the return
>> code, left shifted by 8 bits.
>
> $ man 3 system
>
> Will describe the exact format of the return value and document
> the macros used to extract the exit status.
>

I'd looked at this:

https://man7.org/linux/man-pages/man3/system.3.html

(first google hit for 'man system'), and couldn't make head or tail of
the return value.

If now further look at the waitpid(2) link, it's just a rabbit hole that
makes even less sense.

Doing my brief experiment was much more productive.

(In any case, I'd be using system() from a number of languages not just
C, where C macros are not meaningful.)

On Tuesday, November 23, 2021 at 1:03:54 PM UTC-3, Bart wrote:
> On 23/11/2021 14:45, Scott Lurndal wrote:
> > Bart <b...@freeuk.com> writes:
> >> On 22/11/2021 21:18, Keith Thompson wrote:
> >>> Ben Bacarisse <ben.u...@bsb.me.uk> writes:
> >>>> Thiago Adams <thiago...@gmail.com> writes:
> >>>>
> >>>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
> >>>>>
> >>>>> [...]
> >>>>> "
> >>>>> if (system("cl "
> >>>>> SOURCE_FILES
> >>>>> " -o output_file.exe") != 0)
> >>>>> {
> >>>>> exit(1);
> >>>>> }
> >>>>> "
> >>>>>
> >>>>>
> >>>>> I little update:
> >>>>> When I wrote the script using "system" I didn't know that system on linux
> >>>>> does not return the exit code of the application it executes.
> >>>>
> >>>> This is not really a C question. What system will report is very much
> >>>> determined by the implementation.
> >>>>
> >>>> If all goes well (there is a non-null argument and a shell that can be
> >>>> executed) then it returns the exit status of the shell. That's the exit
> >>>> status of the last comment the shell ran.
> >>>>
> >>>> Why is this not good enough?
> >>>
> >>> On POSIX systems, system() returns an int value from which the shell's
> >>> exit status can be extracted. For example, /bin/false does the
> >>> equivalent of exit(1), but system("/bin/false") will (very probably)
> >>> return 256, not 1.
> >>
> >> My tests show that system() on Linux returns the last byte of the return
> >> code, left shifted by 8 bits.
> >
> > $ man 3 system
> >
> > Will describe the exact format of the return value and document
> > the macros used to extract the exit status.
> >
> I'd looked at this:
>
> https://man7.org/linux/man-pages/man3/system.3.html
>
> (first google hit for 'man system'), and couldn't make head or tail of
> the return value.
>
> If now further look at the waitpid(2) link, it's just a rabbit hole that
> makes even less sense.
>
> Doing my brief experiment was much more productive.
>
> (In any case, I'd be using system() from a number of languages not just
> C, where C macros are not meaningful.)

Update: "Packages" (experimental idea)

Let's say we want to use some lib3. (lib is a collection of source files in a folder)
This library depends on lib2 that depends on lib1.

I want to include lib3 in my project and lib1 is already used.

What I want to show is that using preprocessor and the ideas already presented
here in the past we can "merge" the source files required by each lib.

Basically:

Each library has a "package.h" that includes other "package.h" required
and also includes its own source files.

For instance: (lib3/package.h)

#ifndef LIB3_INCLUDED
#define LIB3_INCLUDED
#include "../Lib1/package.h"
#include "../Lib2/package.h"
" lib2/lib3.c "
#endif

We could have similar file for Lib2 including lib1

Then to compile the files required I just include the packages and the
correct source files will be included just once.

if (system("gcc"
#include "lib3/package.h"
" main.c "
" -o out) != 0)
{
exit(1);
}

In case I already have lib1 included

if (system("gcc"
#include "lib1/package.h"
#include "lib3/package.h"
" main.c "
" -o out) != 0)
{
exit(1);
}

no problem.
Removing lib3 does not remove lib1.

On Mon, 18 Apr 2022 14:39:28 -0700, Thiago Adams wrote:
[snip]
> Update: "Packages" (experimental idea)
>
> Let's say we want to use some lib3. (lib is a collection of source files in a folder)
> This library depends on lib2 that depends on lib1.
>
> I want to include lib3 in my project and lib1 is already used.
>
> What I want to show is that using preprocessor and the ideas already presented
> here in the past we can "merge" the source files required by each lib.
>
> Basically:
>
> Each library has a "package.h" that includes other "package.h" required
> and also includes its own source files.
[snip]

.-'---`-.
,' `.
| \
| \
\ _ \
,\ _ ,'-,/-)\
( * \ \,' ,' ,'-)
`._,) -',-')
\/ ''/
) / /
/ ,'-'

--
Lew Pitcher
"In Skills, We Trust"

On Monday, April 18, 2022 at 6:39:35 PM UTC-3, Thiago Adams wrote:
> On Tuesday, November 23, 2021 at 1:03:54 PM UTC-3, Bart wrote:
> > On 23/11/2021 14:45, Scott Lurndal wrote:
> > > Bart <b...@freeuk.com> writes:
> > >> On 22/11/2021 21:18, Keith Thompson wrote:
> > >>> Ben Bacarisse <ben.u...@bsb.me.uk> writes:
> > >>>> Thiago Adams <thiago...@gmail.com> writes:
> > >>>>
> > >>>>> On Monday, October 4, 2021 at 9:34:03 AM UTC-3, Thiago Adams wrote:
> > >>>>>
> > >>>>> [...]
> > >>>>> "
> > >>>>> if (system("cl "
> > >>>>> SOURCE_FILES
> > >>>>> " -o output_file.exe") != 0)
> > >>>>> {
> > >>>>> exit(1);
> > >>>>> }
> > >>>>> "
> > >>>>>
> > >>>>>
> > >>>>> I little update:
> > >>>>> When I wrote the script using "system" I didn't know that system on linux
> > >>>>> does not return the exit code of the application it executes.
> > >>>>
> > >>>> This is not really a C question. What system will report is very much
> > >>>> determined by the implementation.
> > >>>>
> > >>>> If all goes well (there is a non-null argument and a shell that can be
> > >>>> executed) then it returns the exit status of the shell. That's the exit
> > >>>> status of the last comment the shell ran.
> > >>>>
> > >>>> Why is this not good enough?
> > >>>
> > >>> On POSIX systems, system() returns an int value from which the shell's
> > >>> exit status can be extracted. For example, /bin/false does the
> > >>> equivalent of exit(1), but system("/bin/false") will (very probably)
> > >>> return 256, not 1.
> > >>
> > >> My tests show that system() on Linux returns the last byte of the return
> > >> code, left shifted by 8 bits.
> > >
> > > $ man 3 system
> > >
> > > Will describe the exact format of the return value and document
> > > the macros used to extract the exit status.
> > >
> > I'd looked at this:
> >
> > https://man7.org/linux/man-pages/man3/system.3.html
> >
> > (first google hit for 'man system'), and couldn't make head or tail of
> > the return value.
> >
> > If now further look at the waitpid(2) link, it's just a rabbit hole that
> > makes even less sense.
> >
> > Doing my brief experiment was much more productive.
> >
> > (In any case, I'd be using system() from a number of languages not just
> > C, where C macros are not meaningful.)
> Update: "Packages" (experimental idea)
>
> Let's say we want to use some lib3. (lib is a collection of source files in a folder)
> This library depends on lib2 that depends on lib1.
>
> I want to include lib3 in my project and lib1 is already used.
>
> What I want to show is that using preprocessor and the ideas already presented
> here in the past we can "merge" the source files required by each lib.
>
> Basically:
>
> Each library has a "package.h" that includes other "package.h" required
> and also includes its own source files.
>
> For instance: (lib3/package.h)
>
> #ifndef LIB3_INCLUDED
> #define LIB3_INCLUDED
> #include "../Lib1/package.h"
> #include "../Lib2/package.h"
> " lib2/lib3.c "
> #endif
>
> We could have similar file for Lib2 including lib1
>
> Then to compile the files required I just include the packages and the
> correct source files will be included just once.
>
> if (system("gcc"
> #include "lib3/package.h"
> " main.c "
> " -o out) != 0)
> {
> exit(1);
> }
>
> In case I already have lib1 included
>
> if (system("gcc"
> #include "lib1/package.h"
> #include "lib3/package.h"
> " main.c "
> " -o out) != 0)
> {
> exit(1);
> }
>
> no problem.
> Removing lib3 does not remove lib1.

Just to add a little more context.. One alternative solution used today is
amalgamated files. Like sqlite amalgamated version.

The problem with amalgamated files is that if you want to
create a lib that depends on sqlite and you want your lib
to be amalgamated as well you cannot merge both.

A second lib from another programmer could do the same
creating linking problems because the sqlite was added twice
with external linkage.

Another solution is to think that each lib has just one source file.
But having just one source file can be hard to maintaining during the
development of your lib/program.

In article <t3ko29$rk0$2@dont-email.me>,
Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
....
>
> .-'---`-.
>,' `.
>| \
>| \
>\ _ \
>,\ _ ,'-,/-)\
>( * \ \,' ,' ,'-)
> `._,) -',-')
> \/ ''/
> ) / /
> / ,'-'

What's that supposed to be?

I axsume it is intended to be insulting to Thiago, but it just looks like
gibberish.

--
Kenny, I'll ask you to stop using quotes of mine as taglines.

- Rick C Hodgin -

On 2023-05-12, Kenny McCormack <gazelle@shell.xmission.com> wrote:
> In article <t3ko29$rk0$2@dont-email.me>,
> Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
> ...
>>
>> .-'---`-.
>>,' `.
>>| \
>>| \
>>\ _ \
>>,\ _ ,'-,/-)\
>>( * \ \,' ,' ,'-)
>> `._,) -',-')
>> \/ ''/
>> ) / /
>> / ,'-'
>
> What's that supposed to be?

It is someone covering their face with their palm.

.-'---`-.
,' `.
| \
| thumb \
\ v _ \
,\ _ ,'-,/-)\
( * \ \,' ,' ,'-)
ear`._,) -',-')
\/ ''/
) / /
/ wrist ,'-' chin

On 5/12/2023 11:43 PM, Kaz Kylheku wrote:
> On 2023-05-12, Kenny McCormack <gazelle@shell.xmission.com> wrote:
>> In article <t3ko29$rk0$2@dont-email.me>,
>> Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
>> ...
>>>
>>> .-'---`-.
>>> ,' `.
>>> | \
>>> | \
>>> \ _ \
>>> ,\ _ ,'-,/-)\
>>> ( * \ \,' ,' ,'-)
>>> `._,) -',-')
>>> \/ ''/
>>> ) / /
>>> / ,'-'
>>
>> What's that supposed to be?
>
> It is someone covering their face with their palm.
>
>
> .-'---`-.
> ,' `.
> | \
> | thumb \
> \ v _ \
> ,\ _ ,'-,/-)\
> ( * \ \,' ,' ,'-)
> ear`._,) -',-')
> \/ ''/
> ) / /
> / wrist ,'-' chin

Send that as a text to image to an ai! lol.

On Fri, 12 May 2023 20:52:11 +0000, Kenny McCormack wrote:

> In article <t3ko29$rk0$2@dont-email.me>,
> Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
> ...
>>
>> .-'---`-.
>>,' `.
>>| \
>>| \
>>\ _ \
>>,\ _ ,'-,/-)\
>>( * \ \,' ,' ,'-)
>> `._,) -',-')
>> \/ ''/
>> ) / /
>> / ,'-'
>
> What's that supposed to be?
>
> I axsume it is intended to be insulting to Thiago, but it just looks like
> gibberish.

Get yourself a proper newsreader that displays plain text in a fixed-width
font, and you will see that the "gibberish" is ASCII art for a "head-palm".

Now, get off my lawn!
--
Lew Pitcher
"In Skills We Trust"

On 13/05/2023 07:43, Kaz Kylheku wrote:
> On 2023-05-12, Kenny McCormack <gazelle@shell.xmission.com> wrote:
>> In article <t3ko29$rk0$2@dont-email.me>,
>> Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
>> ...
>>>
>>> .-'---`-.
>>> ,' `.
>>> | \
>>> | \
>>> \ _ \
>>> ,\ _ ,'-,/-)\
>>> ( * \ \,' ,' ,'-)
>>> `._,) -',-')
>>> \/ ''/
>>> ) / /
>>> / ,'-'
>>
>> What's that supposed to be?
>
> It is someone covering their face with their palm.
>
>
> .-'---`-.
> ,' `.
> | \
> | thumb \
> \ v _ \
> ,\ _ ,'-,/-)\
> ( * \ \,' ,' ,'-)
> ear`._,) -',-')
> \/ ''/
> ) / /
> / wrist ,'-' chin

That must be Homer Simpson then!

In article <u3o68b$24d3n$1@dont-email.me>,
Lew Pitcher <lew.pitcher@digitalfreehold.ca> wrote:
....
>Get yourself a proper newsreader that displays plain text in a fixed-width
>font, and you will see that the "gibberish" is ASCII art for a "head-palm".

Just which newsreader (and OS) do you think I am using?

--
Hindsight is (supposed to be) 2020.

Trumpers, don't make the same mistake twice.
Don't shoot yourself in the feet - and everywhere else - again!.

On 5/13/2023 9:29 AM, Bart wrote:
> On 13/05/2023 07:43, Kaz Kylheku wrote:
>> On 2023-05-12, Kenny McCormack <gazelle@shell.xmission.com> wrote:
>>> In article <t3ko29$rk0$2@dont-email.me>,
>>> Lew Pitcher  <lew.pitcher@digitalfreehold.ca> wrote:
>>> ...
>>>>
>>>>   .-'---`-.
>>>> ,'          `.
>>>> |             \
>>>> |              \
>>>> \           _  \
>>>> ,\  _    ,'-,/-)\
>>>> ( * \ \,' ,' ,'-)
>>>> `._,)     -',-')
>>>>    \/         ''/
>>>>     )        / /
>>>>    /       ,'-'
>>>
>>> What's that supposed to be?
>>
>> It is someone covering their face with their palm.
>>
>>
>>      .-'---`-.
>>    ,'          `.
>>    |             \
>>    |   thumb      \
>>    \   v       _  \
>>    ,\  _    ,'-,/-)\
>>    ( * \ \,' ,' ,'-)
>> ear`._,)     -',-')
>>       \/         ''/
>>        )        / /
>>       / wrist ,'-' chin
>
> That must be Homer Simpson then!

;^D