tinycc | My fork of Fabrice Bellard 's Tiny C Compiler

I've noticed that with gcc (but not clang), const (readonly) initialized data objects no longer show up as R data objects in nm and instead they become D (initialized section) objects.

That would suggest the data object will be placed in writable memory, however, when the same object file is linked with either gcc or clang (but not tcc), then it seems to be placed in readonly memory anyway.

clang doesn't seem to use these curious readonly-D symbols (instead the object remains R). Tinycc does make such objects into D symbols too, but those D symbols doesn't seem to have that curious property that causes linkers to put them in readonly memory.

Can you explain what's going on here?

The script below demonstrates the behavior with gcc, clang, and tinycc used in all combinations as compilers and linkers:

An example is something like Desmos (but as a desktop application). The function is given by the user as text, so it cannot be written at compile-time. Furthermore, the function may be reused thousands of times before it changes. However, a true example would be something where the function could change more frequently than desmos, and its values could be used more as well.

I see four methods for writing this code:

1. Parse the user-defined function with a grammar every single time the function is called. (Slow with many function calls)
2. Construct the syntax tree of the math expression so that the nodes contain function pointers to the appropriate math operations, allowing the program to skip parsing the text every single time the function is called. This should be faster than #1 for many function calls, but it still involves function pointers and a tree, which adds indirection and isn't as fast as if the functions were pre-compiled (and optimized).
3. Use something like The Tiny C Compiler as the backend for dynamic code generation with libtcc to quickly compile the user's function after translating it into C code, and then use it in the main program. Since this compiler can compile something like 10,000 very simple programs on my machine per second, there should be next to no delay with parsing new functions. Furthermore, this compiler generates machine code for the function, so there are no pointers or trees involved, and optimization is done by TinyCC. This method is more daunting for an intermediate programmer like me.
4. Write my own tiny compiler (not of C, but tailored specifically to my problem) to generate machine code almost instantly. This is probably 20x more work than #3, and doesn't do much in the way of future improvements (adding a summation operation generator would require me to write more assembly code for that).

Is there any easier, yet equally or more efficient method than #3, while staying in the realm of C++? I'm not experienced enough with lambdas and templates and the standard library to tell for sure if there isn't some abstract way to write this code easily and efficiently.

Even a method that is faster than #2 but slower than #3, and requires no dynamic code generation would be an improvement.

This is more of an intellectual curiosity than a real-world problem, which is why I am concerned so much with performance, and is why I wouldn't use someone else's math parsing library. It's also why I wouldn't consider using javascript or python interpreter which can interpret this kind of thing on-the-fly.

How set CMAKE_STATIC_LINKER_FLAGS in CMakeLists.txt immediately after the executable file?

for example: I need:

tcc.exe-arqc staticRun.lib CMakeFiles/staticRun.dir/utils/system.c.obj

but cmake after this settings:

set (CMAKE_AR C:/run/code/toolchains/c++/MinGW-tcc/bin/tcc.exe CACHE FILEPATH "" FORCE)

set (CMAKE_STATIC_LINKER_FLAGS -ar CACHE STRING "" FORCE)

add -ar key like this:

tcc.exe qc staticRun.lib CMakeFiles/staticRun.dir/utils/system.c.obj-ar

so, building the static library failed.

tcc.exe -ar - mean

Tools: create library : tcc -ar [rcsv] lib.a files

I wrote a simple win32 GUI application with buttons and other controls, in pure C, no MFC. I want to make it more accessible for those who can not use mouse.

1. First, my example code does not respond to Tab key to move focus from one button to another. I can press UI button using mouse, than it becomes focused and i can activate button using Space-bar, but i can't move focus to other buttons using Tab or Shift+Tab. How can i fix this?

2. I want to assign keyboard cues (little underscores) to buttons, so user can use keyboard shortcuts to activate buttons.

I have google it around, but answers are hard googleable, so i need someone to point me to some documentation. A little piece of code would be very helpful.

Here is the code i have. I compile and run it on Linux using WINE + TinyCC