Re: C23 thoughts and opinions

On 01/06/2024 11:53, bart wrote:

On 01/06/2024 01:53, Malcolm McLean wrote:

On 31/05/2024 13:55, bart wrote:

On 30/05/2024 16:03, Michael S wrote:

On Thu, 30 May 2024 15:48:39 +0100
bart <bc@freeuk.com> wrote:
>

>
Where do the _binary_logo_bmp_start and ...-size symbols come from?
That is, how do they get into the object file.
>

>
objcopy generates names of the symbols from the name of input binary
file. I would think that it is possible to change these symbols to
something else, but I am not sure that it is possible withing the same
invocation of objcopy. It certainly is possible with a second pass.
Lawrence probably can give more authoritative answer.
Or as a last resort you can RTFM.
>

I gave myself the simple task of incorporating the source text of hello.c into a program, and printing it out.
>
Here's how builtin embedding worked using a feature of my older C compiler:
>
   #include <stdio.h>
   #include <string.h>
>
   char hello[] = strinclude("hello.c");
>
   int main(void) {
       printf("hello =\n%s\n", hello);
       printf("strlen(hello) = %zu\n", strlen(hello));
       printf("sizeof(hello) = %zu\n", sizeof(hello));
   }
>
>
I build it and run it like this:
>
   C:\c>bcc c
   Compiling c.c to c.exe
>
   C:\c>c
   hello =
   #include "stdio.h"
>
   int main(void) {
       printf("Hello, World!\n");
   }
>
   strlen(hello) = 70
   sizeof(hello) = 71
>
   C:\c>dir hello.c
   31/05/2024  13:48                70 hello.c
>
>
It just works; no messing about with objcopy parameters; no long unwieldy names; no link errors due to unsupported file formats; no problems with missing terminators for embedded text files imported as strings; no funny ways of getting size info.
>

Here's my solution. It's a bit more complicated.
>
>
int bbx_write_source (const char *source_xml, char *path, const char *source_xml_file, const char *source_xml_name)
{
     XMLDOC *doc = 0;
     char error[1024];
     char buff[1024];
     XMLNODE *root;
     XMLNODE *node;
     const char *name;
     FILE *fpout;
     FILE *fpin;
     int ch;
>
     doc = xmldocfromstring(source_xml, error, 1024);
     if (!doc)
     {
         fprintf(stderr, "%s\n", error);
         return -1;
     }
     root = xml_getroot(doc);
     if (strcmp(xml_gettag(root), "FileSystem"))
         return -1;
>
     if (!root->child)
         return -1;
     if (strcmp(xml_gettag(root->child), "directory"))
         return -1;
>
     for (node = root->child->child; node != NULL; node = node->next)
     {
         if (!strcmp(xml_gettag(node), "file"))
         {
             name = xml_getattribute(node, "name");
             snprintf(buff, 1024, "%s%s", path, name);
             fpout = fopen(buff, "w");
             if (!fpout)
                 break;
             fpin = file_fopen(node);
             if (!fpin)
                 break;
             if (!strcmp(name, source_xml_file))
             {
                 char *escaped = texttostring(source_xml);
                 if (!escaped)
                     break;
                 fprintf(fpout, "char %s[] = %s;\n", source_xml_name, escaped);
                 free(escaped);
             }
             else
             {
                while ((ch = fgetc(fpin)) != EOF)
                    fputc(ch, fpout);
             }
             fclose(fpout);
             fclose(fpin);
             fpout = 0;
             fpin = 0;
         }
     }
     if (fpin || fpout)
     {
         fclose(fpin);
         fclose(fpout);
         return -1;
     }
>
     return 0;
>
}
>
It's leveraging the Baby X resource compiler, the xmparser, and my filesystem programs. You can't include the source of a program in the program as a C string, because then the source changes to include that string. So what you do is this.
>
You first place a placeholder C source file containing a short dummy string.
The you convert the source to an XML file, and turn it into a string with the Baby X Resource compiler. Then you drop the source into the
file, removing the placeholder.
>
Then the program walks the file list, detects that file, and replaces it with the xml string it has been passed.
>
And this system works, and it's an easy way of adding source output to
ptograms. Of course the function now needs to be modified to walk the entire tree recursively and I will need a makedirectory function. I've got it to work for flat source directories.

 Sorry, I don't understand what that does; what is the input and what is the output?
 In the case of a very simple requirement of incorporating a text file into a C program as data, usually string data (which I have to say is much more common for me than doing anything with XML), how would a BBX solution work?
 This doesn't work:
 char strdata[] = {
   #include "file.txt"
}
 Because the contents of file.txt, which let's say are:
   one
  two
  three
 are interpreted as C source code ('one' is a syntax error, or it might be the name of some identifier).
 Some process is needed to either turn that file into:
    "one\ntwo\nthree\n"
 or into a bunch of numbers: '100, 110, 101, ...'. I think this is what 'xxd' does.
 In the case of binary files, the process of embedding is usually blind to the actual format, or meaning, of the file. It is just a blob of data.
 So here, I understand that the BBXRC solution goes much further. If I wanted to include a JPG file, then either #embed or my strinclude() would just incorporate the raw bytes. I would still need a JPEG decoder to use that data.
 Whereas BBXRC, AIUI, does the decoding for you, and incorporates the data as a raw table of pixel values that can be directly used.
 So it is at a different level from what is being discussed. But sometimes there is also a need for that cruder form of embedding: maybe that JPG just needs to be written out again; no need to get inside it.
 

The Baby X resource compiler can of course do the trivial job of loading binary data and writing it out as a C array of unsigned char. If that was all it did, it would hardly be worth having. But is is an essential facility for the program that it is.
But I've now got a much better solution for the problem of incorporating entire directories, and I urge you to check it out.
And one directory you might want to include is your own source directory. But thre is a problem. That image becomes part of the source, and so there's a recursive self containment problem. But is is easily solved.
You just put the source image in a file called source.c. Then you replace source.c with a small placeholder, and convert the directory to xml, then convert the xml to a string, which you put in a file called source.c. Then you replace the placeholder with the real source.c, and compile. Then when you process the XML, you look out for a file called "source.c", which you know is a placeholder, and so you replace with the contents of the string in source.c. And thus you have recreated your own source directory.
And that's how I do it. And it works. And now I've just got to package it up so it is as easy as possible, and every open source developer can easily include a little flag in his binary to write out the source.
And can the Microsoft resource compiler compete with the Baby X resource compiler on that? Let's see.
--
Check out Basic Algorithms and my other books:
https://www.lulu.com/spotlight/bgy1mm