Making an executable by running an executable - c++

Question

I wanted to write a brainfuck compiler, but when I went to write one I was stuck at this problem
I want to create an ELF executable (using C/C++) that reads a brainfuck code from a file and generates an executable. Just like GCC/clang
I can read and parse the code, but I don't know how to write an executable that can run on the same system (say x86)?
I want this behavior:
my_bf_compiler ./source.bf -o bin.out
./bin.out
EDIT: I do not want to know how to write a compiler. Read this, compiler part was just for context as to where I will use it
I want to create a binary executable (say maker.out) which when ran creates a executable file (say foo.out). For simplicity let's keep foo.out very simple, when executed it returns 7; So, this is what is expected:
./maker.out # Creates the foo.out executable
./foo.out && echo $ # Runs the executable and prints return value, in this case 7;
So how do I write maker.cpp?

Answer 1

Your initial message was about creating a an executable from a brainfuck code, so this is what this answer focuses on. Your current question is way too broad.
As you have linked in one of your previous posts there is already an implementation that does this here: https://github.com/skeeto/bf-x86/blob/master/bf-x86.c
It basically does 3 steps:
1) Parse the BF code into a intermediate representation (which is here https://github.com/skeeto/bf-x86/blob/master/bf-x86.c#L55)
2) Compile this intermediate representation into machine code (which can be found here https://github.com/skeeto/bf-x86/blob/master/bf-x86.c#L496)
3) Compose the ELF binary according to the specification. The example program does this here. https://github.com/skeeto/bf-x86/blob/master/bf-x86.c#L622 .
Steps 1 and 2 are up to you to find a good implementation, for step 3 the simplest way is to write the ELF header and program header in such a way, that it only has the programs machine code as content and point the entrypoint of the program to the machine code generated in step 2.
The full specification for the ELF format can be found here: https://refspecs.linuxfoundation.org/elf/elf.pdf

Answer 2

#Yanick's answer contains enough information about the ELF format and how to create an elf executable.
However, it seems to me that your question is about how to open/create an executable file. There is a function called chmod/fchmod which might help you.
The following text is taken from the man-page for chmod (run man 2 chmod to see this page):
#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
The new file mode is specified in mode, which is a bit mask created by ORing together zero or more of the
following:
S_ISUID (04000) set-user-ID (set process effective user ID on execve(2))
S_ISGID (02000) set-group-ID (set process effective group ID on execve(2); mandatory locking, as described
in fcntl(2); take a new file's group from parent directory, as described in chown(2) and
mkdir(2))
S_ISVTX (01000) sticky bit (restricted deletion flag, as described in unlink(2))
S_IRUSR (00400) read by owner
S_IWUSR (00200) write by owner
S_IXUSR (00100) execute/search by owner ("search" applies for directories, and means that entries within
the directory can be accessed)
S_IRGRP (00040) read by group
S_IWGRP (00020) write by group
S_IXGRP (00010) execute/search by group
S_IROTH (00004) read by others
S_IWOTH (00002) write by others
S_IXOTH (00001) execute/search by others
In your case, running chmod("foo.out", S_IRUSR | S_IXUSR) should give you(the owner) the permission to read and execute foo.out. Assuming that you have written foo.out to be a proper elf file, this will make it executable.