how to define script interpreter with shebang

Question

It is clear that one can use the

#!/usr/bin/perl

shebang notation in the very first line of a script to define the interpreter. However, this presupposes an interpreter that ignores hashmark-starting lines as comments. How can one use an interpreter that does not have this feature?

Answer 1

I made it work. I especially thank holgero for his tail opion trick

tail -n +2 $1 | $REALINTERP

That, and finding this answer on Stack overflow made it possible:

How to compile a linux shell script to be a standalone executable *binary* (i.e. not just e.g. chmod 755)?

"The solution that fully meets my needs would be SHC - a free tool"

SHC is a shell to C translator, see here:

http://www.datsi.fi.upm.es/~frosal/

So I wrote polyscript.sh:

$ cat polyscript.sh
#!/bin/bash

tail -n +2 $1 | poly

I compiled this with shc and in turn with gcc:

$ shc-3.8.9/shc -f polyscript.sh
$ gcc -Wall polyscript.sh.x.c -o polyscript

Now, I was able to create a first script written in ML:

$ cat smlscript
#!/home/gergoe/projects/shebang/polyscript $0

print "Hello World!"

and, I was able to run it:

$ chmod u+x smlscript
$ ./smlscript
Poly/ML 5.4.1 Release
> > # Hello World!val it = (): unit

Poly does not have an option to suppress compiler output, but that's not an issue here. It might be interesting to write polyscript directly in C as fgm suggested, but probably that wouldn't make it faster.

So, this is how simple it is. I welcome any comments.

Answer 2

With a wrapper that removes the first line and calls the real interpreter with the remainder of the file. It could look like this:

#!/bin/sh

# set your "real" interpreter here, or use cat for debugging
REALINTERP="cat"

tail -n +2 $1 | $REALINTERP

Other than that: In some cases ignoring the error message about that first line could be an option.

Last resort: code support for the comment char of your interpreter into the kernel.

Answer 3

I think the first line is interpreted by the operating system. The interpreter will be started and the name of the script is handed down to the script as its first parameter. The following script 'first.myint' calls the interpreter 'myinterpreter' which is the executable from the C program below.

#!/usr/local/bin/myinterpreter
% 1 #########
2 xxxxxxxxxxx
333
444
% the last comment

The sketch of the personal interpreter:

#include <errno.h>
#include <stdio.h> 
#include <stdlib.h>
#include <string.h>

#define BUFFERSIZE  256                         /* input buffer size */

  int
main ( int argc, char *argv[] )
{
  char    comment_leader  = '%';                /* define the coment leader */
  char    *line = NULL;
  size_t  len   = 0;
  ssize_t read;
  //  char  buffer[BUFFERSIZE];

  // argv[0] : the name of this executable
  // argv[1] : the name the script calling this executable via shebang

  FILE  *input;                                 /* input-file pointer */
  char  *input_file_name = argv[1];             /* the script name    */

  input = fopen( input_file_name, "r" );
  if ( input == NULL ) {
    fprintf ( stderr, "couldn't open file '%s'; %s\n",
        input_file_name, strerror(errno) );
    exit (EXIT_FAILURE);
  }

  while ((read = getline(&line, &len, input)) != -1) {
    if ( line[0] != comment_leader ) {
      printf( "%s", line );                     /* print line as a test */
    }
    else {
      printf ( "Skipped a comment!\n" );
    }
  }

  free(line);

  if( fclose(input) == EOF ) {                  /* close input file   */
    fprintf ( stderr, "couldn't close file '%s'; %s\n",
        input_file_name, strerror(errno) );
    exit (EXIT_FAILURE);
  }

  return EXIT_SUCCESS;
}   /* ----------  end of function main  ---------- */

Now call the script (made executable before) and see the output:

...~> ./first.myint
#!/usr/local/bin/myinterpreter
Skipped a comment!
2 xxxxxxxxxxx
333
444
Skipped a comment!