def test() {
  string s;
  char c = getchar();
  {
    while (c != EOF) {
      s += c;
      c = getchar();
    };
    while (!s.is_empty()) {
      putchar(s.top());
      s.pop();
     };
  };
}

What I think is particularly cool is that the string class is exceedingly simple:

class string
{
  fields
  {
    stack[char] f_stack;
  }
  delegates
  {
    Stack[char] : f_stack;
  }
  public
  {
    def _init(cstring x) {
      while (x != NULL) {
        push(*x++);
      };
    }
    def _eq(self& x) : self& {
      clear();
      _plus_eq(x);
      return *this;
    }
    def _plus_eq(self& x) : self& {
      uint i=0;
      while (i < x.count()) {
        push(x[i]);
      };
      return *this;
    }
    def _plus(self& x) : self {
      return *this += x;
    }
  }
}

How's that for compact? What a difference delegations make. I guess to be fair I should include the Stack interface:

interface Stack[type T]
{
  inherits
  {
    Array[T];
  }
  requires
  {
    def push(T x) {
      uint old = count();
      inner;
      post(count() == old + 1);
    }
    def pop() {
      uint old = count();
      pre(!is_empty());
      inner;
      post(count() == old - 1);
    }
    def top() : T& {
      pre(!is_empty());
      inner;
    }
  }
  extension
  {
    def is_empty() : bool {
      return count() == 0;
    }
    def clear() {
      while (!is_empty()) {
        pop();
      };
    }
    def dup() {
      push(top());
    }
    def reverse() {
      if (count() < 1) return;
      int max = count() - 1;
      int n = (count() / 2) - 1;
      int i = 0;
      while (i < n) {
        swap_elements(i, max - i);
      };
    }
    def swap_elements(uint i, uint j) {
      T tmp = _subscript(i);
      _subscript(i) = _subscript(j);
      _subscript(j) = tmp;
    }
    def _plus_eq(T x) {
      push(x);
    }
  }
}

Now if you aren't impressed yet, then you probably aren't familiar with the C++ standard template library. Yes, I know you can do much of this in C#, but try comparing the execution speed and memory usage. That's right, Heron screams like a bat out of hell.

Whenever I reach a mile-stone with Heron, I usually tend to get overwhelmed and somewhat depressed by the list of things to do. It's not straightforward what the best next step is.

So the HeronFront compiler works more or less (at least for me, it'll probably bite your right arm off if you tried it). Obviously there are a lot of bugs, and no documentation. However I don't think now is the right time to start documenting the tool, and providing support to the masses. That would simply require more time and energy than I have. I think I should work on it a bit more, doing some field testing before I release it onto the public.

int c;
StringBuffer s = new StringBuffer();
 
while((c = System.in.read()) >= 0) {
    s.append((char) c);
}
 
System.out.print(s.reverse());

def reverse()
{
  if (count() < 2) return; //fixed from orig. code
  int max = count() - 1;
  int n   = (count()/2) - 1; //fixed from orig.
  int i   = 0;
  while(i < n)
  {
    _subscript(i) :=: _subscript(max - i); //uhg ... _subscript()?
  }
}

def _colon_eq_colon(T a,T b)
{
  T tmp = a;
  a     = b;
  b     = tmp;
}

    // Stuff missed out to keep post short - you will get the idea :)
 
    // Simple file reverser to show straight forward code - code from a previous post in this forum
    private static void simple() throws Exception {
        final FileReader reader = new FileReader( input );
        final FileWriter writer = new FileWriter( outputFile() );
        int c;
        final StringBuilder s = new StringBuilder();
        while( (c = reader.read()) >= 0 ) { s.append( (char)c ); }
        writer.write( s.reverse().toString() );
        reader.close();
        writer.close();
    }
    
    // More complex file reverser that demonstrates speed
    private static void fast() throws Exception {
        final FileInputStream fis = new FileInputStream( input );
	final FileChannel fic = fis.getChannel();
	final int sz = (int)fic.size();
	final MappedByteBuffer bbi = fic.map( READ_ONLY, 0, sz );
	final CharBuffer cbi = decoder.decode( bbi );
        final RandomAccessFile fos = new RandomAccessFile( outputFile(), "rw" );
	final FileChannel foc = fos.getChannel();
	final MappedByteBuffer bbo = foc.map( READ_WRITE, 0, sz );
	final CharBuffer cbo = decoder.decode( bbo );
        final StringBuilder s = new StringBuilder();
        s.append( cbi.array() );
        cbo.append( s.reverse().toString() );
        foc.close();
        fic.close();
    }
    
    public static void main( final String... fileName ) throws Exception {
        input = new File( fileName[ 0 ] );
        time( new Timable() {
            public void time() throws Exception { simple(); }
            public String toString() { return "simple"; }
        } );
        time( new Timable() {
            public void time() throws Exception { fast(); }
            public String toString() { return "fast"; }
        } );
    }
}

Run: 1 method: simple time: 2.7 s
Run: 2 method: simple time: 2.3 s
Run: 3 method: simple time: 2.5 s
Run: 1 method: fast time: 1.0 s
Run: 2 method: fast time: 0.9 s
Run: 3 method: fast time: 0.8 s
BUILD SUCCESSFUL (total time: 11 seconds)

> def reverse()
> {
>   if (count() < 2) return; //fixed from orig. code
>   int max = count() - 1;
>   int n   = (count()/2) - 1; //fixed from orig.
>   int i   = 0;
>   while(i < n)
>   {
> _subscript(i) :=: _subscript(max - i); //uhg ...
> ... _subscript()?
>   }

Only missing a semicolon here. This is because in later versions of Heron strange statements will be possible like: 

fu {} {} {}; 

Which need to be distinguished.


> }
> 
> def _colon_eq_colon(T a,T b)
> {
>   T tmp = a;
>   a     = b;
>   b     = tmp;
> }
>