merging master with new-ponyrt

Makefile

@@ -3,10 +3,8 @@ ENCOREC=dist/build/encorec/encorec
 
 RUNTIME_DIR=$(SRC_DIR)/runtime
 
-CLOSURE_INC=$(RUNTIME_DIR)/closure/closure.h
-CLOSURE_LIB=$(RUNTIME_DIR)/pony/bin/debug/libclosure.a
-STREAM_INC=$(RUNTIME_DIR)/stream/stream.h
-STREAM_LIB=$(RUNTIME_DIR)/pony/bin/debug/libstream.a
+CONFIG=debug
+CONFIG=release
 
 RELEASE_DIR=release
 INC_DIR=$(RELEASE_DIR)/inc
@@ -27,6 +25,7 @@ test: encorec
 
 SET_DIR=$(RUNTIME_DIR)/set
 FUTURE_DIR=$(RUNTIME_DIR)/future
+ENCORE_DIR=$(RUNTIME_DIR)/encore
 doc: cabal-config
 	make -C doc/encore/
 	cabal haddock --all
@@ -39,24 +38,40 @@ $(INC_DIR):
 $(LIB_DIR):
 	mkdir -p $(LIB_DIR)
 
+PLATFORM_INC=$(RUNTIME_DIR)/pony/inc/platform
 PONY_INC=$(RUNTIME_DIR)/pony/inc/pony
-PONY_LIB=$(RUNTIME_DIR)/pony/bin/debug/libpony.a
+PONY_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libpony.a
 FUTURE_INC=$(FUTURE_DIR)/future.h
-FUTURE_LIB=$(RUNTIME_DIR)/pony/bin/debug/libfuture.a
+FUTURE_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libfuture.a
 SET_INC=$(SET_DIR)/set.h
-SET_LIB=$(RUNTIME_DIR)/pony/bin/debug/libset.a
+SET_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libset.a
+ENCORE_INC=$(ENCORE_DIR)/encore.h
+ENCORE_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libencore.a
+CLOSURE_INC=$(RUNTIME_DIR)/closure/closure.h
+CLOSURE_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libclosure.a
+STREAM_INC=$(RUNTIME_DIR)/stream/stream.h
+STREAM_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libstream.a
+ARRAY_INC=$(RUNTIME_DIR)/array/array.h
+ARRAY_LIB=$(RUNTIME_DIR)/pony/bin/$(CONFIG)/libarray.a
+
 pony: dirs $(PONY_INC)
 	make -C $(SRC_DIR) pony
+	cp -r $(PLATFORM_INC) $(INC_DIR)
 	cp -r $(PONY_INC) $(INC_DIR)
 	cp -r $(SET_INC) $(INC_DIR)
 	cp -r $(FUTURE_INC) $(INC_DIR)
 	cp -r $(CLOSURE_INC) $(INC_DIR)
 	cp -r $(STREAM_INC) $(INC_DIR)
+	cp -r $(ENCORE_INC) $(INC_DIR)
+	cp -r $(ARRAY_INC) $(INC_DIR)
 	cp -r $(PONY_LIB) $(LIB_DIR)
 	cp -r $(FUTURE_LIB) $(LIB_DIR)
 	cp -r $(CLOSURE_LIB) $(LIB_DIR)
+	cp -r $(ENCORE_LIB) $(LIB_DIR)
 	cp -r $(STREAM_LIB) $(LIB_DIR)
-	cp -r $(SET_LIB) $(LIB_DIR)
+
+	# cp -r $(SET_LIB) $(LIB_DIR)
+	cp -r $(ARRAY_LIB) $(LIB_DIR)
 
 clean:
 	cabal clean

doc/encore/index.scrbl

@@ -1,8 +1,8 @@
 #lang scribble/manual
 
-@title[#:version "0.1"]{Encore Programming Language}
+@title[#:version "0.45"]{Encore Programming Language Documentation}
 
-@author{The UpScale Team}
+@author["Stephan Brandauer"  "Elias Castegren"  "Dave Clarke"  "Kiko Fernandez" "Henrik Sommerland"  "Tobias Wrigstad" "Albert Yang"]
 
 @include-section["lang/getting-started/index.scrbl"]
 @include-section["lang/introduction/index.scrbl"]

doc/encore/lang/getting-started/index.scrbl

@@ -225,6 +225,7 @@ Running @code{encorec foo.enc} will typecheck the source and produce the executa
 @item{@code{-clang} -- Use clang to build the executable (default)}
 @item{@code{-AST} -- Output the parsed AST as text to foo.AST}
 @item{@code{-TypedAST} -- Output the typechecked AST as text to foo.TAST}
+@item{@code{-I path1:path2:...} -- Directories in which to look for modules. (Not needed for modules which are in the same folder as the file being compiled.)}
 ]
 
 For instance, we might want to keep the intermediate C-files:

doc/encore/lang/semantics/index.scrbl

@@ -380,6 +380,48 @@ repeat i <- 5
   print("i={}\n",i)
 }|
 
+@section{Arrays}
+For each type @code{T} there is a corresponding array type
+@code{[T]}. For example, @code{[int]} is the type of arrays of
+integers. You create a new array by writing @code{new [T](n)},
+where @code{n} is the length of the array. An array has a fixed
+size and can not be dynamically extended or shrunk.
+
+You access an array by using standard bracket notation
+@code{a[i]}. This is also how assignment into arrays is written.
+You get the size of an array by putting the array within bars
+@code{|a|}. You can also create array literals by writing a comma
+separated list of expressions within brackets @code{[1, 2, 1+2]}.
+This short example uses all features of arrays:
+
+@codeblock|{
+class Main
+  def bump(arr : [int]) : void
+      repeat i <- |arr|
+        arr[i] = arr[i] + 1
+
+  def main() : void{
+    let a = [1,2,3] in {
+      this.bump(a);
+      repeat i <- |a|
+        print a[i];
+      let b = new [int](3) in {
+        b[0] = 0;
+        b[1] = a[0];
+        b[2] = 42 - 19;
+      }
+    }
+  }
+}|
+
+The expected output is 
+
+@codeblock|{
+2
+3
+4
+}|
+
 @section{Classes}
 
 Classes in @tt{encore} have fields and methods. There is no

doc/encore/lang/syntax/grammar.scrbl

@@ -28,6 +28,9 @@ This section introduces the Encore grammar by using the BNF-grammar notation and
 @; Definition of my keywords
 @(encore/keyword open-paren "(")
 @(encore/keyword close-paren ")")
+@(encore/keyword open-bracket "[")
+@(encore/keyword close-bracket "]")
+@(encore/keyword bar "|")
 @(encore/keyword open-c "{")
 @(encore/keyword close-c "}")
 @(encore/keyword equal "=")
@@ -196,6 +199,9 @@ This section introduces the Encore grammar by using the BNF-grammar notation and
 	      @seq[get Expr]
 	      @seq[new Type open-paren Arguments close-paren]
 	      @seq[new Type]
+	      @seq[Expr open-bracket Expr close-bracket]
+	      @seq[open-bracket Expr @elem{, ...} close-bracket]
+	      @seq[bar Expr bar]
 	      null
 	      true
 	      false
@@ -229,7 +235,8 @@ This section introduces the Encore grammar by using the BNF-grammar notation and
 	      string int bool void RefType 
 	      @seq[Fut Type]
 	      @seq[Par Type]
-	      @seq[open-paren Type close-paren])
+	      @seq[open-paren Type close-paren]
+	      @seq[open-bracket Type close-bracket])
 
 	(list Types
 	      @alt[

doc/encore/lang/syntax/index.scrbl

@@ -8,6 +8,44 @@ Encore language.
 
 @include-section{grammar.scrbl}
 
+@section{Module system}
+As of now encore supports a rudimentary module system. The keywork used to import
+modules is @code{import}.
+
+Here follows a trivial example of usage of the module system.
+
+File  @code{Lib.enc}:
+@codeblock|{
+  class Foo:
+    def boo():void {
+		print "^-^"
+    }
+
+}|
+
+File  @code{Bar.enc}:
+@codeblock|{
+  import Lib
+
+  class Main:
+    def main():void {
+	  let
+		f = new Foo
+	  in{
+		f.boo();
+	  }
+    }
+
+}|
+
+Here the file @code{Bar.enc} imports @code{Lib.enc} and can thus access the class @code{Foo}.
+
+To import files from different directories one needs to use the @code{-I path} argument for the compiler.
+
+As of now the module system has no notion of namespaces so all imported objects needs to have unique names.
+There is also no support for cyclic imports and no "include guards" so it's up to the programmer 
+to ensure that each file is only imported once.
+
 @;@section{Keywords}
 @;Keywords are special words used by the Encore language and they have special meaning.
 @;In Encore, we have the following keywords:

experiments/mandelbrot/Erlang-Hipe/Makefile

@@ -0,0 +1,7 @@
+PLOT_SIZE = 16000
+TIME = /usr/bin/time -f '%C\nwall-time: %E\nuser-time: %U \nsystem-time: %S\nload: %P'  
+all:
+	erlc +native +"{hipe, [o3]}" mandelbrot.erl
+run:
+	erl -smp enable -noshell -run  mandelbrot main $(PLOT_SIZE)
+

experiments/mandelbrot/Erlang-Hipe/mandelbrot.erl

@@ -0,0 +1,48 @@
+% The Computer Language Benchmarks Game
+% http://benchmarksgame.alioth.debian.org/
+%% Contributed by Fredrik Svahn based on Per Gustafsson's mandelbrot program
+
+-module(mandelbrot).
+-export([main/1]).
+-define(LIM_SQR, 4.0).
+-define(ITER, 50).
+-define(SR, -1.5).
+-define(SI, -1).
+
+main([Arg]) ->
+    N = list_to_integer(Arg),
+    io:put_chars(["P4\n", Arg, " ", Arg, "\n"]),
+
+    %% Spawn one process per row
+    Row = fun(Y)-> spawn(fun()-> row(0, ?SI+Y*2/N, N, 0, [], 7) end) end,
+    Pids = lists:map(Row, lists:seq(0,N-1)),
+
+    %Pass token around to make sure printouts are in the right order
+    hd(Pids) ! tl(Pids) ++ [ self() ],
+    receive _Token -> halt(0) end.
+
+%Iterate over a row, collect bits, bytes and finally print the row
+row(X, _, N, Bits, Bytes, BitC) when X =:= N-1 ->
+    receive Pids ->
+	    put_chars(Bits, Bytes, BitC),
+	    hd(Pids) ! tl(Pids)
+    end;
+
+row(X, Y2, N, Bits, Bytes, 0) ->
+    row(X+1, Y2, N, 0, [Bits bsl 1 + m(?ITER, ?SR+X*2/N, Y2) | Bytes], 7);
+
+row(X, Y2, N, Bits, Bytes, BitC) ->
+    row(X+1, Y2, N, Bits bsl 1 + m(?ITER, ?SR+X*2/N, Y2), Bytes, BitC-1).
+
+%Mandelbrot algorithm
+m(Iter, CR,CI) -> m(Iter - 1, CR, CI, CR, CI).
+
+m(Iter, R, I, CR, CI) ->
+    case R*R+I*I > ?LIM_SQR of 
+	false when Iter > 0 -> m(Iter-1, R*R-I*I+CR, 2*R*I+CI, CR, CI);
+	false -> 1;
+	true -> 0
+    end.
+
+put_chars(_, Bytes, 7)-> io:put_chars(lists:reverse(Bytes));
+put_chars(Bits, Bytes, C) -> io:put_chars(lists:reverse([Bits bsl (C+1) | Bytes])).

experiments/mandelbrot/Makefile

@@ -0,0 +1,115 @@
+#
+#	This makefile should enable people to build and test all the versions  of the mandelbrot
+#	plot for which the appropriate compilers are installed. 
+#
+#	run 'make bench' to perform the benchmark tests for the languages available on your system.
+#	run 'make PLOT_SIZE=nnnnn bench' to run benchmarks with a specific plotsize.
+#	
+#	Note that the tree version of the encore program might not work for small values of PLOT_SIZE.
+#
+
+
+PLOT_SIZE = 1600
+TIME = /usr/bin/time -f 'wall-time: %E\nuser-time: %U \nsystem-time: %S\nload: %P' 
+ENC_TREE=mbr-tree
+ENC_ROW=mbr
+RACKET=Racket/mandelbrot.racket-4.racket
+JAVA=java/mandelbrot.class
+OCAML=OCaml/mandelbrot.ocaml_run
+GCC=gcc9/gcc9
+ERLANG=Erlang-Hipe/mandelbrot.beam
+
+HAS_RACKET := $(shell racket --version 2>/dev/null)
+
+all:
+	@cd Erlang-Hipe; which erlc && make; true
+	@cd gcc9; which erlc && make; true
+	@cd java; which javac && make; true
+	@cd OCaml; which ocamlopt && make; true
+	@encorec -c mbr-tree.enc
+	@encorec -c mbr.enc
+
+encore-tree: mbr-tree.enc
+	encorec -c mbr-tree.enc
+
+encore: mbr.enc
+	encorec -c mbr.enc
+
+bench:
+
+ifneq ("$(wildcard $(ENC_TREE))","")
+	@echo '--==Encore (Tree)==--'
+	@echo ' '
+	@$(TIME)  ./mbr-tree $(PLOT_SIZE) > out.pbm
+	@echo ' '
+	@$(TIME)  ./mbr-tree $(PLOT_SIZE) > out.pbm
+	@echo ' '
+	@$(TIME)  ./mbr-tree $(PLOT_SIZE) > out.pbm
+	@echo ''
+endif
+
+ifneq ("$(wildcard $(ENC_ROW))","")	
+	@echo '--==Encore (Row)==--'
+	@echo ' '
+	@$(TIME) ./mbr $(PLOT_SIZE) > out.pbm
+	@echo ' '
+	@$(TIME)  ./mbr $(PLOT_SIZE) > out.pbm
+	@echo ' '
+	@$(TIME)  ./mbr $(PLOT_SIZE) > out.pbm
+	@echo ' '
+endif
+
+ifdef HAS_RACKET
+	@echo '--==Racket==--'
+	@echo ' '
+	@cd Racket; $(TIME)  racket mandelbrot.racket-4.racket $(PLOT_SIZE) > out.pbm 
+	@echo ' '
+	@cd Racket; $(TIME)  racket mandelbrot.racket-4.racket $(PLOT_SIZE) > out.pbm
+	@echo ' '
+	@cd Racket; $(TIME)  racket mandelbrot.racket-4.racket $(PLOT_SIZE) > out.pbm
+	@echo ' '
+endif
+
+ifneq ("$(wildcard $(JAVA))","")
+	@echo '--==Java==--'
+	@echo ' '
+	@cd java; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd java; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd java; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+endif 
+
+ifneq ("$(wildcard $(OCAML))","")
+	@echo '--==OCaml==--'
+	@echo ' '
+	@cd OCaml; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd OCaml; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd OCaml; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+endif 
+
+ifneq ("$(wildcard $(GCC))","")
+	@echo '--==C (gcc)==--'
+	@echo ' '
+	@cd gcc9; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd gcc9; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd gcc9; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+endif
+
+ifneq ("$(wildcard $(ERLANG))","")
+	@echo '--==Erlang Hipe==--'
+	@echo ' '
+	@cd Erlang-Hipe; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd Erlang-Hipe; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+	@echo ' '
+	@cd Erlang-Hipe; $(TIME)  make PLOT_SIZE=$(PLOT_SIZE) run > out.pbm
+endif
+

experiments/mandelbrot/OCaml/Makefile

@@ -0,0 +1,6 @@
+PLOT_SIZE=1600
+
+all:
+	ocamlopt -noassert -unsafe -fno-PIC -nodynlink -inline 100 unix.cmxa mandelbrot.ml -o mandelbrot.ocaml_run
+run:
+	./mandelbrot.ocaml_run $(PLOT_SIZE)