void main() {}

main(_) -> ok

main = putStr ""

main.

main() { return 0; }

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

class smallest { static void Main() { } }

echo Hello World

puts "Hello World"

print "Hello World\n"

puts("Hello World");

print "Hello World"

Hello World

return "Hello World"

println("Hello World")

puts "Hello World"

. "Hello World";

BEGIN { print "Hello World" }

say "Hello World"

"Hello World".println

print_endline "Hello World"

println("Hello World")

(format t "Hello world~%")

print "Hello world"

(display "Hello World\n")

import std.stdio;
void main() { write("Hello World"); }

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

System.print("Hello World\n")

main = putStrLn "Hello World"

Wscript.echo "Hello World"

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

(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 hello_world {
   static void Main() {
      System.Console.WriteLine("Hello World");
   }
}

echo $1

puts ARGV[0]

print "$ARGV[0]\n"

echo $(_argv[1]);

import sys; print sys.argv[1]

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

return argv[0]

println(args(0))

puts [lindex $argv 0]

. $args[0];

BEGIN { print ARGV[1] }

say ARG(1)

Sys::args[0].println

print_endline Sys.argv.(1)

println(interp.getArgs()[0])

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

print(arg[1])

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

import std.stdio;
void main(string[] a) { if(a.length>1) writeln(a[1]); }

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

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

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.

(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) {
    if (args.length > 0) System.out.println(args[0]);
  }
}

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

echo $HOME

puts ENV["HOME"]

print "$ENV{HOME}\n"

echo $HOME

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

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

return env->HOME

println(System getenv "HOME")

puts $env(HOME)

. #home;

BEGIN { print ENVIRON["HOME"] }

say VALUE("HOME", , SYSTEM)

Sys::env{"HOME"}.println

print_endline(Sys.getenv "HOME")

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

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

print(getenv"HOME")

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

import std.stdio,std.process;
void main() { writeln(getenv("HOME")); }

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

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

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.

(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 !

public class env {
    public static void main(String[] args) {
	System.out.println(System.getenv("HOME"));
    }
}

using System;

class env {
    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")

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

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")

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

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

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

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

import std.file;
int main() { return !exists("/etc/mtab"); }

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

if (!new File("/etc/mtab").exists()) System.exit(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).

(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 ] !

public class exists {
  public static void main(String[] args) {
      if(!(new java.io.File("/etc/mtab")).exists()) System.exit(1);
  }
}

public class exists {
    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"))

if(!new java.io.File("/etc/mtab").canRead) exit(1)

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)

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

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

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

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

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

import std.stdio;
void main() { File("/etc/mtab"); }

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

if (!new File("/etc/mtab").open("r")) System.exit(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).

(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 ] !

public class readable {
  public static void main(String[] args) {
      if(!(new java.io.File("/etc/mtab")).canRead()) System.exit(1);
  }
}

public class readable {
    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}"

$a=1; $b=2; print "$a + $b = ", $a + $b, "\n"

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);

val (a, b) = (1, 2)
println(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

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

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

(let ((a 1) (b 2)) (format t "~a + ~a = ~a~%" 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)))

import std.stdio;
void main() {
    int a=1,b=2;
    writeln(a," + ",b," = ",a+b);
}

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

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

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]).

(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 formatting {
   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");
system("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");

def exec = Runtime.getRuntime.exec(_:String)

if (exec("false").waitFor > 0)
  error("false failed")

new io.BufferedSource(exec("echo done").getInputStream) foreach print

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")

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

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

(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*)

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")

import std.stdio,std.process;
void main() {
    if (system("false"))
        stderr.writeln("false failed");
    system("echo done");
}

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

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

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', _).

#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 system {
    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");
}

val i = io.Source.fromFile(args(0)).mkString
val w = new java.io.FileWriter(args(0))
w write i.replaceAll("#.*\n","")
w.close

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

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;;

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)

(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 std.file,std.regex;
void main(string[] a) {
    a[1].write(a[1].readText().replace(regex("#.*","g"),""));
}

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)).

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).

(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();
  }
}

for (s <- new java.io.File(args(0)).listFiles if ""+s endsWith ".c") {
  val o = new java.io.File((""+s dropRight 1)+"o")
  if (!o.exists || o.lastModified < s.lastModified) {
    println("compiling "+s+" to "+o)
    Runtime.getRuntime.exec("gcc -c " + s + " -o " + o)
  }
}

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

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(".")

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`)
             }
         }
     }
}

(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 std.stdio,std.file,std.process;
void main() {
    foreach (c; listdir("","*.c")) {
        auto o = c[0..$-1]~'o';
        if (lastModified(o,0) < lastModified(c)) {
            writeln("compiling "~c~" to "~o);
            system("gcc -c -o '"~c~"' '"~o~"'");
        }
    }
}

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 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).

(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):
    prefix = ""
    if len(files) > 1:
        prefix = fileinput.filename() + ":"
    if re.search(s):
        print prefix + 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; 

val options = "-([hiF]+)".r
val (optList, pattern :: files) = args.toList span
   (options.pattern matcher _ matches)
val opts = optList.map{ case options(x) => x }.mkString.toSet

if (args.isEmpty || opts('h')) {
    println("usage: grep [-F] [-i] regexp [files...]")
    exit(1)
}

val mods = Map('i' -> ("(?i)" + _),
               'F' -> (java.util.regex.Pattern.quote(_)))
               .filterKeys(opts)
               .withDefaultValue((x: String) => x)

val regex = mods('i')(mods('F')(pattern)).r

files foreach { file =>
    io.Source fromFile file getLines () foreach { line =>
        regex findFirstIn line foreach { _ =>
            if (files.size > 1) print(file+":")
            println(line)
        }
    }
}

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=)))

import std.stdio,std.regex,std.getopt;
int main(string[] a) {
    bool h,F,i;
    getopt(a,"h",&h,"F",&F,"i",&i);
    if (a.length<2 || h) {
        writeln("usage: grep [-F] [-i] regexp [files...]");
        return 1;
    }
    auto e = F ? a[1].replace(regex(r"\W","g"),r"\$&") : a[1];
    foreach (f; a[2..$])
        foreach (l; File(f).byLine())
            if (!l.match(regex(e, i ? "i" : "")).empty)
                writeln(a.length>3 ? f~':'~l : l);
    return 0;
}

(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 -

sbcl --noinform

lua

escript

runscheme

sh -c %s

ruby -e %s

perl -e %s

ch -c %s

python -c %s

php -r %s

pike -e %s

scala -e %s

awk %s

merd -e %s

rune -src %s

sbcl --noinform -eval %s

lua -e %s

guile -c %s

rdmd --eval='%s'

erl -eval %s

ngs-js -e %s

ghc -e %s

sh %s

ruby %s

perl %s

ch %s

python %s

php %s

pike %s

scala %s

tclsh %s

java judo %s

awk -f %s --

rexx %s

merd %s

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

rune %s

sbcl --noinform -load %s

lua -f %s

guile -s %s

dmd -run

escript %s

ngs-js %s

runghc %s

cscript //nologo %s

pl -q -t halt -g main -s %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

.scala

.tcl

.judo

.awk

.rex or .rexx

.me

.ml

.e

.lisp

.lua

.scm

.d

.erl

.js

.hs

.vbs

.pl or .pro

.scm

.c

.st

.java

.cs

sh

irb

perl -de 1

ch

python

php -a

pike

scala

tclsh

merd

ocaml

rune

sbcl

lua

umb-scheme

erl

ghci

cscript //X 1

pl

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

any jvm debugger

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

<builtin>

see http://www.prowiki.org/wiki4d/wiki.cgi?DebugEnvironments

several available

cscript //X

use debug/0

gdb (arguments must be passed separately)

gdb