Create an executable for a program in an interpreted language: Difference between revisions

then (assuming the I interpreter is invoked with the command "InterpretI" and a suitable file for the temporary source is /tmp/t) a suitable C source might be:

#include <errno.h>

static void w( char * line, FILE * tf )

remove( "/tmp/t" );

}

If your language has other ways of doing this e.g., the interpreter provides an API that would let you specify the code via a string instead of storing it in a file, demonstrate how this would be done.

<br>

There have been several implementations of Algol 68, both compiled and interpreted. A popular implementation currently available for Windows and Linux is ALGOL 68G which is an interpreter (though under Linux a hybrid part compilation, part interpreted mode is available). This example follows the suggestion in the task description and creates a C source that will write the Algol 68 source and run the interpreter.

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

# a C program is created that writes the source to a temporary file and #

# then calls a the Algol 68G interpreter to run it #

)

)

{{out}}

Assuming /tmp/t is a temporary file that could be written to by the generated C program and that the command to run ALGOL 68G is a68g, a sample run of the program might be:

If hw.a68 contains:

The generated _hw_a68.c would contain:

#include <errno.h>

static void w( char * line, FILE * tf )

system( "a68g /tmp/t" );

remove( "/tmp/t" );

=={{header|AWK}}==

{{Trans|ALGOL 68}}

# a C program is created that writes the source to a temporary file and

# then calls a the Awk interpreter to run it

return result;

{{out}}

Assuming /tmp/t is a temporary file that could be written to by the generated C program and that the command to run the awk interpregter is <code>awk -f</code>, a sample run of the program might be:

Assuming hw.awk contains:

{

printf( "Hello, World!\n" );

_hw_awk.c would contani:

#include <errno.h>

static void w( char * line, FILE * tf )

system( "awk -f /tmp/t" );

remove( "/tmp/t" );

=={{header|J}}==

I think this task is a duplicate of another task. But it's also about the host operating system.

echo 'hello world'

This is a basic example of how to implement a J shell script. This example assumes that J's jconsole was installed at /usr/local/bin/jconsole (note that java also has a jconsole which might be installed in /usr/bin/ -- so on debian and ubuntu which avoid such conflicts but which also do not install to /usr/local/bin the J implementation installs /usr/bin/ijconsole which is what would be needed in the hashbang line). Also, many J installs do not put j executables in a directory in $PATH. So the usual trick of using /usr/bin/env tends to not be useful both because the executable names and locations may vary. Conceptually this means that if you want to distribute a J program you probably need to also distribute a copy of J along with it. Fortunately, J is gpl'd and reasonably small, so that should not be too much of a burden. Also, unix executables must be made executable before they can run...

Meanwhile, we could do something similar with compiled C. Here's a minimal example which builds and runs under Linux:

/* link with -ldl */

#include <dlfcn.h>

jdo(jt, (C*)"('Hello, World!',10{a.) 1!:2<'/proc/self/fd/1'");

exit(0);

(The "j engine" is a shared object / dylib / dll / ... the details depend on the host operating system.)

So the following C program (countdown.c) is perhaps the nearest we can get to the spirit of this task.

#include "wren.h"

wrenFreeVM(vm);

return 0;

We can now compile this code (using GCC on Linux) and run it, obtaining the expected output as follows: