Thread: Nested functions for a "new language"

I am currently trying to make a "new programming language" (the term used VERY loosely) based on C. To do this, I decided to use C to read strings and interpret their contents.

Code:

void Read()
{
    char* file = "int() mol { return 42; }";
    
    for (unsigned short i = 0; i < length_of(file); i++)
    {
        if (get_substring(file, i, *length*) == "int()")
        { int *name*(); }
    }
}

Basically, if the program reads "int() funcName;", it should execute "int funcName();".

Apparently, this can be accomplished by using a GCC extension for nested functions.

I assume there is a much better way to do this, but I can't figure out what. Would it be better to just export the custom file into a valid .c file and compile it afterwards? If so, how can I do that without forcing the user to compile it manually?

Best regards,
a guy on the Internet

I don't think nested functions will work the way you are hoping. It would still need to be recompiled if you change the code. Consider using a scripting language like Python. It has a good C/C++ integration library, and has good performance.

So you want to write a script-to-C translator, which then compiles the resultant C code , and loads it dynamically? This is definitely possible, but will require the compiler to be installed on the user's computer. As far as I know, there is no way to embed gcc in a program of your own, short of downloading the gcc source and hacking it to suit your needs. Again, this is possible, but probably too much work. Look at Ch

How complex is your "new programming language"?

Originally Posted by MeNeedsHelp

Could I do it if GCC is installed? (MinGW, in this case.) If so, how?

Refer to my previous post:

Originally Posted by Elkvis

...but will require the compiler to be installed on the user's computer.

GCC is a compiler, or rather, a collection of compilers. There may be an actual embedded C compiler available somewhere, but my preference would be to use a scripting engine, such as Ch or cint, if you insist on using C, or Python or another scripting language. You could even embed V8, and use javascript instead, and still have the performance of native code, with no need to recompile source between runs.

Originally Posted by MeNeedsHelp

is it possible to compile with GCC without having the user do it themselves - for example, to "open" (or whatever) GCC in the background

That is what IDEs generally do. You should look into the topics of launching processes in the background with console redirection. For example there is the popen and pclose calls in stdio.h.

> if (get_substring(file, i, *length*) == "int()")
Unless this is anything other than an absolute toy language, I would strongly suggest you first look at writing out a grammar for the language using BNF

And then implement a proper parser based on that grammar, who's output would be a syntax tree of some kind. At this stage, you could either execute the code by walking the tree (an interpreter), or generate machine code (for a real or a virtual machine) for later execution.

Without doing this, ad-hoc parsers like you suggest would instantly trip over "int ()" or "int( )"

The "Dragon Books" are a good source of information as well.

If you want to embed a compiler into an application, I'd suggest using LLVM instead of gcc. One of its design goals was to be useful as a software component and not just a standalone toolchain.

This sort of thing is done in assembly programming alot.
It can be confusing to follow a program like this, but save some code.

One way to do this with C is to use goto statements to make your program behave like a non-structured, assembly program.
Be warned though, it will get messy and VERY hard to follow.

Code:

/* Example */

int DoSomething(int intInput)
{
    intInput += 1;

    #SUB intInput2=intInput
    int DoSomethingGreat(int intInput2)
    {
        intInput *= intInput;

        return intInput;
    }
}

Becomes...
//Global variables
int intInput, intInput2;
....

DoSomething:

    intInput += 1;
    intInput2=intInput;

DoSomethingGreat:

    intInput *= intInput;

However, in assembly there are commands like RTS (Return from subroutine), which go at the end of any subroutine which makes this sort of programming easier.

One way to get around this is to have some sort of jump table - Another global variable which you store your position in the code to return to:

Code:

ReturnSubroutine:
  switch(ReturnToken)
  {
    case 0:
      goto Label0;

    case 1:
      goto Label1;

  }

Everything would have to be in your main function.

I'm sure that there are better ways of doing this, but it could be a bit of fun as a learning exersise.

I'm fairly sure that what you will learn is that the 'goto' statement makes things harder. (A good lesson to learn!)