main = putStr ""

main.

main(_) -> ok

main() { return 0; }

public class smallest { public static void main(String[] args) { } }

class z { static void Main() { } }

echo Hello World

puts "Hello World"

print "Hello World\n"

puts("Hello World");

print "Hello World"

Hello World

return "Hello World"

puts "Hello World"

. "Hello World";

BEGIN { print "Hello World" }

say "Hello World"

"Hello World".println

println("Hello World")

print_endline "Hello World"

print "Hello world"

(display "Hello World\n")

System.print("Hello World\n")

(format t "Hello world~%")

main = putStrLn "Hello World"

Wscript.echo "Hello World"

main :- write('Hello World'), nl.

main(_) -> io:fwrite("hello world\n").

(display "Hello World\n")

#include <stdio.h>
main() {
    puts("Hello World");
    return 0;
}

'Hello World' displayNl !

public class hello_world {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

class z {
   static void Main() {
      System.Console.WriteLine("Hello World");
   }
}

echo $1

puts ARGV[0]

% perl -le 'print $ARGV[0]'

echo $(_argv[1]);

import sys; print sys.argv[1]

<?= "{$_SERVER[argv][1]}\n";

return argv[0]

puts [lindex $argv 0]

. $args[0];

BEGIN { print ARGV[1] }

say ARG(1)

Sys::args[0].println

println(interp.getArgs()[0])

print_endline Sys.argv.(1)

print(arg[1])

(format #t "~A\n" (cadr command-line))

System.print(ARGS[1], "\n")

(write-line (second *posix-argv*))

import System
main = do l <- getArgs
          putStrLn (head l)

Wscript.echo Wscript.Arguments(0)

main :- current_prolog_flag(argv, CmdLine),
        append(_, [--, Arg1|_], CmdLine),
        write(Arg1), nl.

main([Arg|_]) -> io:format("~s~n", [Arg]).

(print ARGS)

#include <stdio.h>
main(int n, char **argv) {
    if (n > 1) puts(argv[1]);
    return 0;
}

(Smalltalk arguments) at: 1 displayNl !

public class argv {
  public static void main(String[] args) {
    System.out.println(args[0]);
  }
}

class z {
   static void Main(string[] args) {
      if (args.Length > 0) System.Console.WriteLine(args[0]);
   }
}

echo $HOME

puts ENV["HOME"]

% perl -le 'print $ENV{HOME}'

echo $HOME

import os; print os.environ["HOME"]

<?= "$_ENV[HOME]\n";

return env->HOME

puts $env(HOME)

. #home;

BEGIN { print ENVIRON["HOME"] }

say VALUE("HOME", , SYSTEM)

Sys::env{"HOME"}.println

# Only when run on Java1.5
println(<unsafe:java.lang.System>.getenv("HOME"))

print_endline(Sys.getenv "HOME")

print(getenv"HOME")

(format #t "~A\n" (getenv "HOME"))

System.print(System.getenv("HOME"), "\n")

(write-line (posix-getenv "HOME"))

import System
main = getEnv "HOME" >>= putStrLn

Set s = WScript.CreateObject("WScript.Shell")
Wscript.echo s.Environment("PROCESS")("HOME")

main :- getenv('HOME', Home), write(Home), nl.

main(_) -> io:format("~s~n", [os:getenv("HOME")]).

(load "using/run.scm")
(define getvar
  (let ((table (Properties.)))
    (for-each*
     (lambda (r) (let ((it (.split r "=")))
                   (.put table (vector-ref it 0) (vector-ref it 1))))
     (BufferedReader (inputReader 
          (if (.startsWith ( os.name") "Windows")
              (run (cmd cmd /c set))
              (run (cmd /bin/sh set))))))
    (lambda (name) (.get table name))))
(print (getvar "HOME"))

#include <stdlib.h>
main() {
    char *s = getenv("HOME");
    if (s) puts(s);
    return 0;
}

(Smalltalk getenv: 'HOME') displayNl !

import java.io.*;

public class env {
    public static void main(String[] args) {
	System.out.println(System.getenv("HOME"));
    }
    // NB: System.getenv was re-introduced in JDK 1.5, 
    //     and is not yet in gcj
}

using System;

class z {
    static void Main() {
	Console.WriteLine(Environment.GetEnvironmentVariable("HOME"));
    }
}

[ -e /etc/mtab ]

test ?e, "/etc/mtab" or exit 1

-e "/etc/mtab" or exit 1

access("/etc/mtab", 0);

import os, sys
sys.exit(not os.path.exists("/etc/mtab"))

<? file_exists("/etc/mtab") or exit(1);

return !file_stat("/etc/mtab")

exit [expr ![file exists /etc/mtab]]

exit(!"/etc/mtab".fileExists());

BEGIN { if (system("[ -e /etc/mtab ]")) exit 1 }

exit STREAM(ARG(1), 'C', 'QUERY EXISTS') == ""

Sys::exit(1) if not File::exists?("/etc/mtab")

require(<file:/etc/mtab>.exists())

if not(Sys.file_exists "/etc/mtab") then exit 1

(exit (access? "/etc/mtab" F_OK))

if (!new File("/etc/mtab").exists()) System.exit(1)

(unless (probe-file "/etc/mtab") (quit :unix-status 1))

import Directory
import System
main = catch (getPermissions "/etc/mtab") (\_ -> exitFailure)

Set f = CreateObject("Scripting.FileSystemObject")
if not f.FileExists("/etc/mtab") then wscript.quit(1)

main :- exists_file('/etc/mtab') -> halt(0) ; halt(1).

main(_) ->
    case filelib:is_file("/etc/mtab") of
        true -> ok;
	_ -> erlang:halt(1)
    end.

(if (not (.exists (java.io.File. "/etc/mtab"))) (System.exit 1))

#include <unistd.h>
main() {
    return access("/etc/mtab", F_OK);
}

(File exists: '/etc/mtab') ifFalse: [ ObjectMemory quit: 1 ] !

import java.io.*;

public class exists {
  public static void main(String[] args) {
      System.exit((new File("/etc/mtab")).exists() ? 0 : 1);
  }
}

public class z {
    static int Main() {
	return (new System.IO.FileInfo("/etc/mtab")).Exists ? 0 : 1;
    }
}

[ -r /etc/mtab ]

test ?r, "/etc/mtab" or exit 1

-r "/etc/mtab" or exit 1

access("/etc/mtab", 4);

import sys
try: open("/etc/mtab")
except: sys.exit(1)

<? is_readable("/etc/mtab") or exit(1);

return !!catch(Stdio.File("/etc/mtab"))

exit [expr ![file readable /etc/mtab]]

exit(!"/etc/mtab".fileReadable());

BEGIN { if (system("[ -r /etc/mtab ]")) exit 1 }

exit \STREAM(ARG(1), 'C', 'READABLE')

File::open("/etc/mtab") or Sys::exit(1)

require(<file:/etc/mtab>.canRead())

try open_in("/etc/mtab") with _ -> exit 1

if not openfile("/etc/mtab", "r") then exit(1) end

(exit (access? "/etc/mtab" R_OK))

if (!new File("/etc/mtab").open("r")) System.exit(1)

(require :sb-posix)
(unless (sb-posix:access "/etc/mtab" r-ok)
  (quit :unix-status 1))

import System
main = catch (readFile "/etc/mtab") (\_ -> exitFailure)

On Error Resume Next
Set f = CreateObject("Scripting.FileSystemObject")
if f.GetFile("file2.txt") = Nothing then wscript.quit(1)

main :- access_file('/etc/mtab', read) -> halt(0) ; halt(1).

main(_) ->
    case file:read_file("/etc/mtab") of
        {ok, _} -> ok;
	_ -> erlang:halt(1)
    end.

(if (not (.canWrite (java.io.File. "/etc/mtab"))) (System.exit 1))

#include <unistd.h>
main() {
    return access("/etc/mtab", R_OK);
}

(File isReadable: '/etc/mtab') ifFalse: [ ObjectMemory quit: 1 ] !

import java.io.*;

public class readable {
  public static void main(String[] args) {
      System.exit((new File("/etc/mtab")).canRead() ? 0 : 1);
  }
}

public class z {
    static int Main() {
	try {
	    (new System.IO.FileInfo("/etc/mtab")).OpenRead();
	    return 0;
	} catch(System.Exception ex) {
	    return 1;
	}
    }
}

a=1; b=2; echo "$a + $b = $[$a + $b]"

a=1; b=2; puts "#{a} + #{b} = #{a + b}"

% perl -le '$a=1; $b=2; print "$a + $b = ", $a + $b'

int a=1, b=2; 
echo $a + $b = $(a+b)

a=1; b=2; print a, '+', b ,'=', a + b

<? $a=1; $b=2; echo "$a + $b = " . ($a + $b) . "\n";

int a=1, b=2; write("%d + %d = %d", a, b, a + b);

set a 1; set b 2; puts "$a + $b = [expr $a + $b]"

. a=1," + ",b=2," = ",a+b;

BEGIN { a=1; b=2; print a " + " b " = " a + b }

a = 1 ; b = 2 ; say "a + b =" a + b

a=1; b=2; "{a} + {b} = {a + b}".println

def a := 1
def b := 2
println(`$a + $b = ${a + b}`)

let a, b = 1, 2 in
Printf.printf "%d + %d = %d\n" a b (a + b)

a=1; b=2; print(a .. " + " .. b .. " = " .. a + b)

(let ((a 1) (b 2))
  (format #t "~A + ~A = ~A\n" a b (+ a b)))

a=1; b=2; System.print(a, " + ", b, " = ", a + b, "\n")

(let ((a 1) (b 2)) (format t "~a + ~a = ~a~%" a b (+ a b)))

main = putStrLn $ show a ++ " + " ++ show b ++ " = " ++ show(a + b) 
    where a=1
          b=2

a=1 : b=2
WScript.echo a & " + " & b & " = " & a + b

main :- A is 1, B is 2, Result is A + B, 
        format('~d + ~d = ~d\n', [A, B, Result]).

main(_) -> A = 1, B = 2, io:fwrite("~p + ~p = ~p~n", [A, B, A+B]).

(let ((a 1)
      (b 2))
  (print {[a] + [b] = [(+ a b)]}))

#include <stdio.h>
main() {
    int a=1, b=2;
    printf("%d + %d = %d\n", a, b, a + b);
    return 0;
}

| a b |
a:=1.
b:=2.
(a printString, ' + ', b printString, ' = ', (a + b) printString)
   displayNl !

public class formatting {
  public static void main(String[] args) {
    int a=1, b=2;
    System.out.println("" + a + " + " + b + " = " + (a + b));
  }
}

class z {
   static void Main() {
      int a=1, b=2;
      System.Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
   }
}

false || echo "false failed" 1>&2; echo done

system "false" or $stderr.puts "false failed"; system "echo done"

system "false" and warn "false failed\n"; system "echo done"

if (system("false")) fprintf(stderr, "false failed\n");
echo done;

import os, sys
if os.system("false"):
    sys.stderr.write("false failed\n")
os.system("echo done")

<? system("false") or fwrite(STDERR, "false failed\n"); 
system("echo done");

Process.system("false") && werror("false failed\n");
Process.system("echo done");

if {[catch {exec false}]} {puts stderr "false failed"}
exec echo >@ stdout done

exec <r> 'false'; if (r) . "false failed"; exec 'echo done';

BEGIN { 
  if (system("false")) print "false failed" > "/dev/stderr" 
  system("echo done")
}

address SYSTEM "false"
if RC == 0 then ; call LINEOUT 'STDERR', "false failed"
address SYSTEM "echo done"

Sys::system("false") or warn("false failed"); Sys::system("echo done")

def runFalse := makeCommand("/bin/false")
def runEcho := makeCommand("/bin/true")
def ok := try {
     runFalse()
     true
} catch ex {
     stderr.println("false failed")
     false
}
if (ok) {
     println(runEcho("done")[0])
}

if Sys.command "false" != 0 then prerr_endline("false failed");
ignore(Sys.command "echo done")

if execute "false" ~= 0 then _ALERT "false failed\n" end
execute "echo done"

(if (not (= (system "false") 0)) 
  (display "false failed\n" (current-error-port)))
(system "echo done")

if (System.system("false") != 0) System.error("false failed\n")
System.system("echo done")

(unless 
  (zerop (process-exit-code (run-program "false" nil :search t)))
  (format *error-output* "false failed~%"))
(run-program "echo" '("done") :search t :output *standard-output*)

import System
import IO
import Monad
main = 
    do ret <- system "false"
       when (ret /= ExitSuccess) (hPutStrLn stderr "false failed")
       system "echo done"

Set s = CreateObject("WScript.Shell")
Set e = s.Exec("false")
If e.exitCode > 0 Then wscript.stderr.writeline "false failed"
s.Exec("echo done")

main :- shell('false', Status),
        (Status \= 0 ->
              current_stream(2, _, StdErr),
              format(StdErr, 'false failed~n', [])
           ;
              true),
        shell('echo done', _).

main(_) ->
    case os:cmd("false; echo $?") of
         [$0|_] -> ok;
         _ -> io:fwrite("false failed~n")
    end,
    io:fwrite(os:cmd("echo done")).

#include <stdio.h>
main() {
    if (system("false")) fprintf(stderr, "false failed\n");
    system("echo done");
    return 0;
}

(Smalltalk system: 'false') = 0
  ifFalse: [ stderr display: 'false failed' ; nl ].
Smalltalk system: 'echo done' !

import java.io.*;
public class system {
  public static void main(String[] args) throws Exception {
    if (Runtime.getRuntime().exec("false").waitFor() != 0)
      System.err.println("false failed");
  
    BufferedReader input = new BufferedReader(new InputStreamReader(
        Runtime.getRuntime().exec("echo done").getInputStream()
    ));
    String line;
    while ((line = input.readLine()) != null)
      System.out.println(line);
  }
}

using System;
using System.Diagnostics;

public class z {
    static void Main() {
	Process proc = new Process();
	proc.EnableRaisingEvents = false;

	proc.StartInfo.FileName = "false";
	proc.Start();
	proc.WaitForExit();
	if (proc.ExitCode != 0) Console.Error.WriteLine("false failed");

	proc.StartInfo.FileName = "echo";
	proc.StartInfo.Arguments = "done";
	proc.Start();
	proc.WaitForExit();
    }
}

sed -i -e "s/#.*//" $1

% ruby -pi -e '$_.sub!(/#.*/, "")'

% perl -pi -e "s/#.*//"

char *tmp=tmpnam(NULL);
sed 's/#.*//' < $(_argv[1]) > $tmp
cp -f $tmp $(_argv[1])
rm -f $tmp

import fileinput, re

for s in fileinput.input(inplace = 1):
    print re.sub("#.*", "", s),

<?
$f = $_SERVER[argv][1];
file_put_contents($f, 
    preg_replace("/#.*/", '', file_get_contents($f)));

int main(int n, array args) {
   array r = ({});
   foreach(Stdio.read_file(args[1]) / "\n", string x) {
     sscanf(x, "%s#", x);
     r += ({x});
   }
   Stdio.write_file(args[1], r*"\n");
}

set f [lindex $argv 0]
set fd [open $f r]
regsub -all {#[^\n]*\n} [read $fd] {} contents
close $fd
set fd [open $f w]
puts -nonewline $fd $contents
close $fd

getFileAsString(#args[0]).replaceAll('#.*', '').writeToFile(#args[0]);

BEGIN { 
  if (!("mktemp /tmp/sed.XXXXXX" | getline tmp)) exit 1
}
{ sub("#.*", ""); print >> tmp }
END {
  system("cp -f " tmp " " ARGV[1])
  system("rm -f " tmp)
}

call rxFuncAdd 'sysLoadFuncs', 'rexxUtil', 'sysLoadFuncs'
call sysLoadFuncs

fin = ARG(1) ; fout = RANDOM() || ".tmp"
do while LINES(fin) > 0
  call LINEOUT fout, CHANGESTR("#", LINEIN(fin), "")
end
call STREAM fin, 'C', 'CLOSE' ; call STREAM fout, 'C', 'CLOSE'

call sysFileDelete fin ; call sysMoveObject fout, fin
call sysDropFuncs

def f := <file: interp.getArgs()[0]>
var text := ""
for line in f {
     if (line =~ `@left#@right`) {
         text += left + "\n"
     } else {
         text += line
     }
}
f.setText(text)

let l = Std.input_list (open_in Sys.argv.(1)) in
let f = open_out Sys.argv.(0) in
List.iter (fun l -> output_string f 
 ((Str.replace_first (Str.regexp "#.*") "" l) ^"\n")) l;;

(defun remove-hash-comments (path)
  (let ((lines (with-open-file (inf path :direction :input)
                 (loop for line = (read-line inf nil nil)
                       while line
                       collect line))))
    (with-open-file (ouf path
                         :direction :output
                         :if-exists :supersede)
      (dolist (line lines)
        (write-line (subseq line 0 (position #\# line)) ouf)))))

import System
import System.IO
import Monad
import Control.Exception

c = unlines . map (takeWhile (/= '#')) . lines
fop f n = do l <- fmap f (readFile n)
             evaluate (length l)
             writeFile n l

main = getArgs >>= (fop c) . head

main :-
  getUserArg(1, File),
  atom_concat(File, '.tmp', TmpFile),
  strip_comments_from_file(File, TmpFile),
  delete_file(File),
  rename_file(TmpFile, File).

strip_comments_from_file(FileIn, FileOut) :-
  open(FileIn, read, In, [type(binary)]), 
  open(FileOut, write, Out, [type(binary)]),
  process_lines(In, Out),
  close(In), close(Out).

process_lines(In, _) :- at_end_of_stream(In), !.

process_lines(In, Out) :-
  read_line_to_codes(In, Line),
  partition(Line, 35, Prefix, _),
  format(Out, '~s~n', [Prefix]),
  !, process_lines(In, Out).

partition(ListIn, Element, Prefix, Suffix) :-
  (member(Element, ListIn) ->
    append(Prefix, [Element|Suffix], ListIn)
  ;
    Prefix = ListIn, Suffix = []).

getUserArg(N, Arg) :-
  current_prolog_flag(argv, Cmdline),
  append(_, [--|Args], Cmdline),
  nth1(N, Args, Arg).

main([F|_]) ->
     {ok, B} = file:read_file(F),
     Lines = string:tokens(erlang:binary_to_list(B), "\n"),
     Not_comment = fun ($#) -> false; (_) -> true end,
     New = lists:map(
         fun(Line) ->
               L = lists:takewhile(Not_comment, Line),
               L ++ "\n"
         end,
         Lines
     ),
     file:write_file(F, erlang:list_to_binary(New)).

(load "using/run.scm")
(import "java.io.File")
(let ((file (vector-ref ARGS 1)))
  (let ((out (File.createTempFile "foo" "bar")))
    (print out)
    (call-with-output-file out
      (lambda (s)
        (for-each* 
            (lambda (r) (.println s (.replaceFirst r "#.*" "")))
            (BufferedReader (File. file)))
        (.close s)))
    (.renameTo out (File. file))))

#include <stdio.h>
#include <unistd.h>
main (int argc, char **argv)
{
 FILE *f;
 int c=1, t=0, i=0;
 if (argc-c)
  {
   f=fopen(argv[c],"r+");
   while (c) switch (c=getc(f))
    {
    case '#' : if (!t) { t=1,i-=2; break; }
    case '\n' : if (t) { t=0; break; }
    default : if (t==1) { i--; break; }
         fseek(f,i-1,1);
         putc(c++,f);
         fseek(f,-i,1);
    }
   truncate(argv[1],ftell(f)+i);
  }
 return 0;
}

import java.io.*;

public class uncomment {
    public static void main(String[] args) {
	try {
	    FileReader fr = new FileReader(args[0]);
	    BufferedReader br = new BufferedReader(fr);

	    File f = new File(args[0] + ".tmp");
	    FileWriter fw = new FileWriter(f);

	    String line = "";
	    while ((line = br.readLine()) != null) {
		int pos = line.indexOf('#');
		if (pos > -1) line = line.substring(0,pos);
		fw.write(line + '\n');
	    }
	    fr.close();
	    fw.close();
	    f.renameTo(new File(args[0]));
	} catch(Exception ex) {
	    ex.printStackTrace();
	}
    }
}

for c in `find -name "*.c"`; do
  o=`echo $c | sed 's/.c$/.o/'`
  if [ "$c" -nt "$o" ]; then
    echo "compiling $c to $o"
    gcc -c -o "$o" "$c"
  fi
done

Dir['**/*.c'].each{|c|
  o = c.sub('.c$', '.o')
  if test ?>, c, o then
    puts "compiling #{c} to #{o}"
    system("gcc", "-c", "-o", o, c)
  end
}

use File::Find;

find({ no_chdir => 1, 
       wanted => sub {
           if (($o = $_) =~ s/\.c$/.o/ 
               && -M $_ <= -M $o) {
               print "compiling $_ to $o\n";
               system qw(gcc -c -o), $o, $_;
           }
} }, '.');

#include <sys/stat.h>

string_t c, o;
struct stat cstat, ostat;
foreach (c; `find / -name "*.c"`) {
          o=`echo $c | sed 's/.c$/.o/'`;
          stat(o, &ostat);
          stat(c, &cstat);
          if (ostat.st_mtime  > cstat.st_mtime) { 
            echo "compiling $c to $o";
            gcc -c -o "$o" "$c";
          }
}

from os import *
from fnmatch import *

for dir, _, files in walk('.'):
    for f in filter(files, '*.c'):
        c = path.join(dir, f)
        o = c[0:-2] + '.o'
        if not path.exists(o) or stat(c)[9] > stat(o)[9]:
            print 'compiling', c, 'to', o
            system("gcc -c -o '%s' '%s'" % (o, c))

<?
function doit($p) {
    foreach (glob($p . '/*', GLOB_ONLYDIR) as $d) doit($d);
    foreach (glob($p . '/*.c') as $c) {
        $o = substr($c, 0, -1) . 'o';
        if (filemtime($o) < filemtime($c)) {
            echo "compiling $c to $o\n";
            system("gcc -c -o $o $c");
        }
    }
}
doit('.');

int main() {
  object i = Filesystem.Traversion(".");
  foreach (i; string d; string c) {
     if (!has_suffix(c, ".c")) continue;
     c = d+c;
     string o = c;
     o[-1] = 'o';
     object s = file_stat(o);
     if (s && i->stat()->mtime < s->mtime) continue;
     write("compiling %s to %s\n", c, o);
     Process.Process(({"gcc", "-c", "-o", o, c}))->wait();
  }
}

proc doit {dir} {
    foreach f [glob -nocomplain $dir/*] {
        if [file isdir $f] {
            doit $f
        } elseif { 
            [regsub \\.c$ $f .o o] && !( 
               [file exists $o] && 
               [file mtime $o] > [file mtime $f]
            ) } {
                puts "compiling $f to $o"
                exec gcc -c -o $o $f
        }
    }
}

doit .

BEGIN { 
  while ("find -name '*.c'" | getline) {
    c = $0
    sub(/.c$/, ".o")
    if (system(sprintf("[ %s -nt %s ]", c, $0)) == 0) {
      print "compiling", c, "to", $0
      system(sprintf("gcc -c -o '%s' '%s'", $0, c))
    }
  }    
}

call rxFuncAdd 'sysLoadFuncs', 'rexxUtil', 'sysLoadFuncs'
call sysLoadFuncs

call sysFileTree '*.c', 'cfilelist.', 'sf'

do i = 1 for cfilelist.0
  cfilelist.i = WORD(cfilelist.i, 5)
  ofile = LEFT(cfilelist.i, LASTPOS(".c", cfilelist.i) - 1) || ".o"
  otime = STREAM(ofile, 'C', 'QUERY TIMESTAMP')
  if otime < STREAM(cfilelist.i, 'C', 'QUERY TIMESTAMP') then do
    say "compiling" cfilelist.i "to" ofile
    address SYSTEM "gcc -c -o" cfilelist.i ofile
  end
end

call sysDropFuncs

def runGcc := makeCommand("c:/cygwin/bin/gcc.exe")
def leaves := <import:org.erights.e.tools.files.leaves>

for c in leaves(<file:.>) {
     if (c.getPath() =~ `@base.c`) {
         def tmp := <file: `$base.o`>
         if (!tmp.exists() || tmp.lastModified() < c.lastModified()) {
             println(`compiling $base.c to $base.o`)
             try {
                 runGcc("-c", `$base.c`, "-o", `$base.o`)
             } catch ex {
                 stderr.println(`$base.c failed with $ex`)
             }
         }
     }
}

open Unix

let listdir dir =
  let rec listdir_ hdir =
    try
      let s = readdir hdir in
      if s = "." || s = ".." then
        listdir_ hdir
      else 
        s :: listdir_ hdir
    with End_of_file -> []
  in
  let hdir = opendir dir in
  let l = listdir_ hdir in
  closedir hdir ;
  l

let rec doit dir =
  List.iter (fun s ->
    let f = Filename.concat dir s in
    if (lstat f).st_kind = S_DIR then
      doit f
    else if Filename.check_suffix f ".c" then
      let o = Filename.chop_extension f ^ ".o" in
      if not (Sys.file_exists o && 
              (stat o).st_mtime > (stat f).st_mtime) then
        let cmd = Printf.sprintf "gcc -c -o '%s' '%s'" o f in
        print_endline ("compiling " ^ f ^ " to " ^ o) ;
        ignore (Sys.command cmd)
  ) (listdir dir)
;;
doit(".")

(defun find-files-by-type (dir type)
  (mapcan (lambda (path)
            (cond
              ((null (pathname-name path))
               (find-files-by-type path type))
              ((string= (pathname-type path) type)
               (list path))
              (t
               nil)))
          (directory (make-pathname :name :wild
                                    :type :wild
                                    :defaults (truename dir))))))

(defun compile-older-files (dir)
  (dolist (c-path (find-files-by-type dir "c"))
    (let* ((c-name (namestring c-path))
           (o-path (make-pathname :type "o" :defaults c-path))
           (o-name (namestring o-path)))
      (when (or (not (probe-file o-path))
                (< (file-write-date o-path) (file-write-date c-path)))
        (format t "Compiling ~a to ~a~%" c-name o-name)
        (run-program "gcc"
                     (list "-c" "-o" o-name c-name)
                     :output *standard-output*
                     :search t)))))

import System
import System.IO
import System.Directory
import Data.List
import Control.Monad

gmt = getModificationTime
op f = do catch (do ct <- gmt f; ot <- gmt o;
                    when (ct > ot) comp)
                (\_ -> comp)
 where o = take (length f - 2) f ++ ".o"
       comp = do putStrLn ("Compiling "++f++" to "++o)
                 system ("gcc -c -o "++o++" "++f)

main = do files <- getCurrentDirectory >>= getDirectoryContents
          mapM_ op $ filter (".c"`isSuffixOf`) files

main :-
  expand_file_name('*.c', CFiles),
  forall(member(CFile, CFiles),
	(sub_atom(CFile, 0, _, 2, BaseName),
	 atom_concat(BaseName, '.o', ObjFile),
	 (should_compile(CFile, ObjFile) 
            -> compile(CFile, ObjFile) ; true))).

should_compile(SrcFile, ObjFile) :-
  (exists_file(ObjFile) ->
    time_file(SrcFile, SrcTime), 
    time_file(ObjFile, ObjTime), 
    ObjTime < SrcTime
  ;
    true).

compile(SrcFile, ObjFile) :-
  concat_atom(['gcc -c "', SrcFile, '" -o "', ObjFile, '"'], '', Cmd),
  format('compiling ~w to ~w\n', [SrcFile, ObjFile]),
  trap(Cmd, _).

trap(Cmd, Output) :-
  open(pipe(Cmd), read, Input),
  read_line_to_codes(Input, Output),
  close(Input).

main(_) ->
      Fun = fun (Cfile, Acc) ->
		  [$c | File] = lists:reverse(Cfile),
		  Ofile = lists:reverse([$o | File]),
		  case is_compile_time(Cfile, Ofile) of
		      true ->
		          io:format("compiling ~s to ~s~n", [Cfile, Ofile]),
			  os:cmd(io_lib:format("gcc -c -o ~s ~s~n", [Ofile, Cfile])),
			  [Ofile | Acc];
		      false -> Acc
		  end
	  end,
     Regexp = regexp:sh_to_awk("*.c"),
     cc_recurse('.', Regexp, Fun).

is_compile_time(C, O) ->
     case filelib:is_file(O) of
	true -> filelib:last_modified(C) > filelib:last_modified(O);
	false -> true
     end.

cc_recurse(Directory, Regexp, CC_Fun) ->
     catch filelib:fold_files(Directory, Regexp, false, CC_Fun, []),
     {ok, Files} = file:list_dir(Directory),
     lists:foreach(
         fun (Subdir) -> cc_recurse(Subdir, Regexp, CC_Fun) end,
         lists:filter(fun (File) -> filelib:is_dir(File) end, Files)
     ).

(import "java.io.File")
(define (s->o srcDir classDir fromtype totype)
  ;; Source file to object file converter.
  (lambda (file)
    (let ((f (.toString (relativize srcDir file))))
      (File. classDir
        (string-append (.substring f 0
                          (- (.length f) (.length fromtype)))
                       totype)))))

(define (needsUpdate? s->o)
  (lambda (jf)
    ;; Does .java file jf need to be recompiled?
    (let ((cf (s->o jf)))
      (or (not (.exists cf)) 
          (<= (.lastModified cf) (.lastModified jf))))))

(let* ((dir (java.io.File. "."))
      (s->o (s->o dir dir ".c" ".o"))
      (update? (needsUpdate? s->o)))
  (for-each (lambda (c)
              (if (update? c)
                  (let ((o (s->o c)))
                    (display {compiling [c] to [o]\n})
                    (out (run (cmd gcc -c -o ,c ,o))))))
            (files* (java.io.File. ".") (isFile ".c"))))

import java.io.*;

public class compile {
  public static void main(String[] args) {
      filter ft = new filter();
      if (args.length > 0) {
          File f = new File(args[0]);
          File[] cs = f.listFiles(ft);
	  for (int i = 0; i < cs.length; i++) tryFile(cs[i]);
      }
  }

  static void tryFile(File c) {
      String o = c.toString().replaceAll(".c$", ".o");
      File tmp = new File(o);
      if (!tmp.exists() || 
          tmp.lastModified() < c.lastModified()) {
          System.out.println("compiling " + 
                             c.toString() + " to " + o);
          String cmd = "gcc -c " + c.toString() + " -o " + o;
	  try {
	      java.lang.Runtime.getRuntime().exec(cmd);
          } catch(Exception ex) { ex.printStackTrace(); }
      }
  }
}

class filter implements FileFilter
{
  public filter() { }
  public boolean accept(File f) {
      return f.toString().endsWith(".c");
  }
}

opts=''
while [ -n "$1" ]; do
    case $1 in
        -i) opts="-i $opts" ;;
        -F) opts="-F $opts" ;;
        -h) h=1 ;;
        *) break ;;
    esac
    shift
done

if [ $# = 0 ] || [ -n "$h" ]; then
    echo "usage: grep [-F] [-i] regexp [files...]"
    exit 1
fi

r=$1
shift

grep $opts $r "$@"

require 'getopts'
getopts('Fih')

ARGV.empty? || $OPT_h and 
  (puts "usage: grep [-F] [-i] regexp [files...]"; exit 1)

r = ARGV.shift
r = Regexp.quote(r) if $OPT_F
r = /#{r}/i if $OPT_i

prefix = ARGV.size > 1

while gets
  print prefix ? "#{ARGF}:" : '', $_ if $_ =~ /#{r}/
end

use Getopt::Std;
getopts('Fih', \%h);

!@ARGV || $h{h} and die "usage: grep [-F] [-i] regexp [files...]\n";

$r = ($h{i} && '(?i)') . shift;
$r = "\Q$r" if $h{F};
$prefix = @ARGV > 1;

while (<>) {
    print $prefix && "$ARGV:", $_ if /$r/o;
}

import getopt, sys, fileinput, re

opts, args = getopt.getopt(sys.argv[1:], 'hiF')
opts = [ x[0] for x in opts ]

if not args or '-h' in opts:
    print >> sys.stderr, "usage: grep [-F] [-i] regexp [files...]"
    sys.exit(1)

r, files = args[0], args[1:]

if '-F' in opts:
    r = re.sub("\W", lambda i: "\\" + i.group(0), r)

if '-i' in opts:
    re = re.compile(r, re.I)
else:
    re = re.compile(r)
  
for s in fileinput.input(files):
    if re.search(s):
        print s,

<?
$args = array_slice($_SERVER[argv], 1);

while ($o = array_shift($args)) {
    if (ereg('^-[ihF]$', $o)) $$o{1} = $o{1}; 
    else break;
}

if (!$o || @$h)
    die("usage: grep [-F] [-i] regexp [files...]\n");

if (empty($args))
    $args []= 'php://stdin';

$r = $F ? preg_quote($o, '/') : $o;

foreach ($args as $f) {
    foreach (preg_grep("/$r/$i", file($f)) as $l)
        echo count($args) > 1 ? "$f:$l" : $l; 

set i 0
set F 0
set ind 0
set usage 1
foreach s $argv {
    if { "$s" == "-i" } { 
        set i 1 
    } elseif { "$s" == "-F" } { 
        set F 1 
    } elseif { "$s" == "-h" } { 
        incr usage
    } {
        incr usage -1
        break
    }
    incr ind
}

if $usage {
    puts stderr {usage: grep [-F] [-i] regexp [files...]}
    exit 1
}

set re [lindex $argv $ind]
incr ind
set files [lrange $argv $ind end]

if $i { set re (?i)$re }
if $F { set re (?q)$re }

set nb [llength $files]

proc grep { prefix fd re } {
    while {[gets $fd s] >= 0} {
        if [regexp $re $s] { puts $prefix$s }
    }
}

if { $nb == 0 } {
    grep "" stdin $re
} {
    set prefix ""
    foreach f $files {
        if { $nb > 1 } { set prefix $f: }
        set fd [open $f]
        grep $prefix $fd $re
        close $fd
    }
}

function usage() {
  print "usage: grep [-F] [-i] regexp [files...]" > "/dev/stderr"
  exit 1
}

BEGIN {
  for (i = 1; i < ARGC; i++) {
    s = ARGV[i]
    ARGV[i] = ""
         if (s == "-h") usage()
    else if (s == "-i") IGNORECASE = 1
    else if (s == "-F") F = 1
    else break
  }
  if (i == ARGC) usage()
  re = s
  prefix = i + 2 < ARGC
}

{
  if (F ? index($0, re) : match($0, re))
    print (prefix ? (FILENAME ":") : "") $0
}

call rxFuncAdd 'reLoadFuncs', 'rexxRE', 'reLoadFuncs'
call reLoadFuncs

cmdline = ARG(1) ; opt = "" ; regexp = "" ; filelist = ""

do while cmdline <> ""
  parse var cmdline token cmdline
  if LEFT(token, 1) == "-" then
    if TRANSLATE(token) == "-H" | VERIFY(token, "-iF") \= 0 then
      call usage ; else ; opt = opt || CHANGESTR("-", token, "")
  else ; if regexp == "" then
    regexp = token
  else
    filelist = filelist token
end

/* 'F' not recognised by 'reComp'; just remove it */
opt = CHANGESTR("F", opt, "")
if POS("i", opt) > 0 then ; opt = "" ; else ; opt = "c"

cre = reComp(regexp, opt)

do while filelist <> ""
  parse var filelist file filelist
  do while LINES(file) > 0
    if reExec(cre, LINEIN(file), 'match.') then
      call LINEOUT , file || ":" || match.!match
  end
end

call reFree cre ; call reDropFuncs ; exit 0

usage :
  say "usage: grep [-h] | [-F|-i] regexp [files...]"
  call reDropFuncs ; exit 1

open List

let rec iter_lines f fd =
  try
    f (input_line fd) ; iter_lines f fd
  with End_of_file -> ()

let _ = 
  let i, fixed, usage = ref false, ref false, ref false in

  Arg.parse [ "-i", Arg.Set i, "" ; 
              "-F", Arg.Set fixed, "" ;
              "-h", Arg.Set usage, "" ;
            ] (fun _ -> ()) "" ;
  match filter (fun s -> s.[0] <> '-') (Array.to_list Sys.argv) with
  | _ :: r :: files when not !usage ->
      let r = if !fixed then Str.quote r else r in
      let re = (if !i then Str.regexp_case_fold else Str.regexp) r in
      let prefix = length files > 1 in

      iter (fun (name, fd) ->
        iter_lines (fun s ->
          try 
            let _ = Str.search_forward re s 0 in
            print_endline ((if prefix then name ^ ":" else "") ^ s)
          with Not_found -> ()
        ) fd
      ) (if files = [] then 
           ["", stdin] 
         else
           map (fun s -> s, open_in s) files)

  | _ ->
      prerr_endline "usage: grep [-F] [-i] regexp [files...]" ;
      exit 1

(require :asdf)
(require :cl-ppcre)

(defun grep (pattern files &key (no-case nil) (fixed-strings nil))
  (let ((scanner (cl-ppcre:create-scanner
                  (if fixed-strings
                      (cl-ppcre:quote-meta-chars pattern)
                      pattern)
                  :case-insensitive-mode no-case))
        (prefix-p (> (length files) 1)))
    (dolist (path files)
      (with-open-file (inf path :direction :input)
        (loop for line = (read-line inf nil nil)
              while line
              when (cl-ppcre:scan scanner line)
              do (format t "~@[~a:~]~a~%"
                         (when prefix-p
                           (pathname-name path))
                           line))))))
(defun parse-args (argv)
  (let ((flags nil)
        (args nil))
    (dolist (arg argv)
      (if (eql (char arg 0) #\-)
          (push arg flags)
          (push arg args)))
    (values (nreverse flags) (nreverse args))))
 
(multiple-value-bind (flags args)
    (parse-args (rest *posix-argv*))
  ;; Handle help flag
  (when (or (null args)
            (member "-h" flags :test #'string=))
    (format *error-output*
            "Usage: grep [-h] [-i] [-F] <pattern> <path> ...~%")
    (quit :unix-status 1))
  ;; Do grep
  (grep (first args) (rest args)
        :no-case (member "-i" flags :test #'string=)
        :fixed-strings (member "-F" flags :test #'string=)))

(load "using/run.scm")
(define (any p xs) 
    (and (pair? xs) (or (p (car xs)) (any p (cdr xs)))))

(define (forLines f files)
    (for-each 
        (lambda (file) (for-each* f (BufferedReader (File. file))))
        files))

(define (show x) (display x) (newline))

(define (grep-F -i re files)
  (let ((lines (vector->list (.split re "\n")))
        (f (if -i .equalsIgnoreCase .equals)))
    (forLines 
        (lambda (r) (if (any (lambda (p) (f p r)) lines) (show r)))
        files)))

(define (grep re files)
  (let ((p (Pattern.compile re)))
    (forLines (lambda (r) (if (.find (.matcher p r)) (show r)))
              files)))

(let* ((args (cdr (vector->list ARGS)))
       (-F (member "-F" args))
       (-i (member "-i" args))
       (-h (member "-h" args))
       (args (filter (lambda (a) (not (.startsWith a "-"))) args))
       (re (if -i {[(?i)][(car args)]} (car args)))
       (files (cdr args)))
  (cond ((or -h (null? args))
         (display {usage: grep [-F] [-i] regexp file ...\n}))
        (-F (grep-F -i re files))
        (else (grep re files))))

sh

ruby

perl

ch

python

php

tclsh

rexx

merd

rune -

lua

sbcl --noinform

escript

runscheme

sh -c %s

ruby -e %s

perl -e %s

ch -c %s

python -c %s

php -r %s

pike -e %s

awk %s

merd -e %s

rune -src %s

lua -e %s

guile -c %s

ngs-js -e %s

sbcl --noinform -eval %s

ghc -e %s

sh %s

ruby %s

perl %s

ch %s

python %s

php %s

pike %s

tclsh %s

java judo %s

awk -f %s --

rexx %s

merd %s

rune %s

ocaml -I `ocamlc -where`/extlib str.cma unix.cma extLib.cma %s

lua -f %s

guile -s %s

ngs-js %s

sbcl --noinform -load %s

runghc %s

cscript //nologo %s

pl -q -t halt -g main -s %s -- 

escript %s

tcc %s

gst -Q %s -a

gcj %s --main=%s && ./a.out

mcs %s && mint %s.exe

.sh

.rb

.pl

.ch

.py

.php

.pike

.tcl

.judo

.awk

.rex or .rexx

.me

.e

.ml

.lua

.scm

.js

.lisp

.hs

.vbs

.pl or .pro

.erl

.scm

.c

.st

.java

.cs

sh

irb

perl -de 1

ch

python

php -a

pike

tclsh

merd

rune

ocaml

lua

umb-scheme

sbcl

ghci

cscript //X 1

pl

erl

gst

sh -x

ruby -r tracer

perl -d:Trace

python -m trace -t

pike -t1

rexx -ti %s

sbcl --noinform -eval '(trace)'

ruby -r debug %s

perl -d %s

_debug =1
parse foo.ch
run

python -m pdb %s

ocamldebug %s (nice go-back-time feature)

<builtin>

cscript //X

use debug/0

gdb (arguments must be passed separately)

gdb