merge master; regen samples data

samples/ATS/CoYonedaLemma.dats

@@ -0,0 +1,110 @@
+(* ****** ****** *)
+//
+// HX-2014-01
+// CoYoneda Lemma:
+//
+(* ****** ****** *)
+//
+#include
+"share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+staload
+"libats/ML/SATS/basis.sats"
+staload
+"libats/ML/SATS/list0.sats"
+
+(* ****** ****** *)
+
+staload _ = "libats/ML/DATS/list0.dats"
+
+(* ****** ****** *)
+
+sortdef ftype = type -> type
+
+(* ****** ****** *)
+
+infixr (->) ->>
+typedef ->> (a:type, b:type) = a -<cloref1> b
+
+(* ****** ****** *)
+
+typedef
+functor(F:ftype) =
+  {a,b:type} (a ->> b) ->> F(a) ->> F(b)
+
+(* ****** ****** *)
+
+typedef
+list0 (a:type) = list0 (a)
+extern
+val functor_list0 : functor (list0)
+
+(* ****** ****** *)
+
+implement
+functor_list0{a,b}
+  (f) = lam xs => list0_map<a><b> (xs, f)
+
+(* ****** ****** *)
+
+datatype
+CoYoneda
+ (F:ftype, r:type) = {a:type} CoYoneda of (a ->> r, F(a))
+// end of [CoYoneda]
+
+(* ****** ****** *)
+//
+extern
+fun CoYoneda_phi
+  : {F:ftype}functor(F) -> {r:type} (F (r) ->> CoYoneda (F, r))
+extern
+fun CoYoneda_psi
+  : {F:ftype}functor(F) -> {r:type} (CoYoneda (F, r) ->> F (r))
+//
+(* ****** ****** *)
+
+implement
+CoYoneda_phi(ftor) = lam (fx) => CoYoneda (lam x => x, fx)
+implement
+CoYoneda_psi(ftor) = lam (CoYoneda(f, fx)) => ftor (f) (fx)
+
+(* ****** ****** *)
+
+datatype int0 = I of (int)
+datatype bool = True | False // boxed boolean
+
+(* ****** ****** *)
+//
+fun bool2string
+  (x:bool): string =
+(
+  case+ x of True() => "True" | False() => "False"
+)
+//
+implement
+fprint_val<bool> (out, x) = fprint (out, bool2string(x))
+//
+(* ****** ****** *)
+
+fun int2bool (i: int0): bool =
+  let val+I(i) = i in if i > 0 then True else False end
+
+(* ****** ****** *)
+
+val myintlist0 = g0ofg1($list{int0}((I)1, (I)0, (I)1, (I)0, (I)0))
+val myboolist0 = CoYoneda{list0,bool}{int0}(lam (i) => int2bool(i), myintlist0)
+val myboolist0 = CoYoneda_psi{list0}(functor_list0){bool}(myboolist0)
+
+(* ****** ****** *)
+
+val ((*void*)) = fprintln! (stdout_ref, "myboolist0 = ", myboolist0)
+
+(* ****** ****** *)
+
+implement main0 () = ()
+
+(* ****** ****** *)
+
+(* end of [CoYonedaLemma.dats] *)

samples/ATS/DiningPhil2.dats

@@ -0,0 +1,178 @@
+(* ****** ****** *)
+//
+// HX-2013-11
+//
+// Implementing a variant of
+// the problem of Dining Philosophers
+//
+(* ****** ****** *)
+//
+#include
+"share/atspre_define.hats"
+#include
+"share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+staload
+UN = "prelude/SATS/unsafe.sats"
+
+(* ****** ****** *)
+
+staload "libc/SATS/stdlib.sats"
+staload "libc/SATS/unistd.sats"
+
+(* ****** ****** *)
+
+staload "{$LIBATSHWXI}/teaching/mythread/SATS/channel.sats"
+
+(* ****** ****** *)
+
+staload _ = "libats/DATS/deqarray.dats"
+staload _ = "{$LIBATSHWXI}/teaching/mythread/DATS/channel.dats"
+
+(* ****** ****** *)
+
+staload "./DiningPhil2.sats"
+
+(* ****** ****** *)
+
+implement phil_left (n) = n
+implement phil_right (n) = (n+1) \nmod NPHIL
+
+(* ****** ****** *)
+//
+extern
+fun randsleep (n: intGte(1)): void
+//
+implement
+randsleep (n) =
+  ignoret (sleep($UN.cast{uInt}(rand() mod n + 1)))
+// end of [randsleep]
+//
+(* ****** ****** *)
+
+implement
+phil_think (n) =
+{
+val () = println! ("phil_think(", n, ") starts")
+val () = randsleep (6)
+val () = println! ("phil_think(", n, ") finishes")
+}
+
+(* ****** ****** *)
+
+implement
+phil_dine (n, lf, rf) =
+{
+val () = println! ("phil_dine(", n, ") starts")
+val () = randsleep (3)
+val () = println! ("phil_dine(", n, ") finishes")
+}
+
+(* ****** ****** *)
+
+implement
+phil_loop (n) = let
+//
+val () = phil_think (n)
+//
+val nl = phil_left (n)
+val nr = phil_right (n)
+//
+val ch_lfork = fork_changet (nl)
+val ch_rfork = fork_changet (nr)
+//
+val lf = channel_takeout (ch_lfork)
+val () = println! ("phil_loop(", n, ") picks left fork")
+//
+val () = randsleep (2) // HX: try to actively induce deadlock
+//
+val rf = channel_takeout (ch_rfork)
+val () = println! ("phil_loop(", n, ") picks right fork")
+//
+val () = phil_dine (n, lf, rf)
+//
+val ch_forktray = forktray_changet ()
+val () = channel_insert (ch_forktray, lf)
+val () = channel_insert (ch_forktray, rf)
+//
+in
+  phil_loop (n)
+end // end of [phil_loop]
+
+(* ****** ****** *)
+
+implement
+cleaner_wash (f) =
+{
+val f = fork_get_num (f)
+val () = println! ("cleaner_wash(", f, ") starts")
+val () = randsleep (1)
+val () = println! ("cleaner_wash(", f, ") finishes")
+}
+
+(* ****** ****** *)
+
+implement
+cleaner_return (f) =
+{
+  val n = fork_get_num (f)
+  val ch = fork_changet (n)
+  val () = channel_insert (ch, f)
+}
+
+(* ****** ****** *)
+
+implement
+cleaner_loop () = let
+//
+val ch = forktray_changet ()
+val f0 = channel_takeout (ch)
+//
+val () = cleaner_wash (f0)
+val () = cleaner_return (f0)
+//
+in
+  cleaner_loop ()
+end // end of [cleaner_loop]
+
+(* ****** ****** *)
+
+dynload "DiningPhil2.sats"
+dynload "DiningPhil2_fork.dats"
+dynload "DiningPhil2_thread.dats"
+
+(* ****** ****** *)
+
+local
+//
+staload
+"{$LIBATSHWXI}/teaching/mythread/SATS/mythread.sats"
+//
+in (* in of [local] *)
+//
+val () = mythread_create_cloptr (llam () => phil_loop (0))
+val () = mythread_create_cloptr (llam () => phil_loop (1))
+val () = mythread_create_cloptr (llam () => phil_loop (2))
+val () = mythread_create_cloptr (llam () => phil_loop (3))
+val () = mythread_create_cloptr (llam () => phil_loop (4))
+//
+val () = mythread_create_cloptr (llam () => cleaner_loop ())
+//
+end // end of [local]
+
+(* ****** ****** *)
+
+implement
+main0 () =
+{
+//
+val () = println! ("DiningPhil2: starting")
+val ((*void*)) = while (true) ignoret (sleep(1))
+//
+} (* end of [main0] *)
+
+(* ****** ****** *)
+
+(* end of [DiningPhil2.dats] *)

samples/ATS/DiningPhil2.sats

@@ -0,0 +1,71 @@
+(* ****** ****** *)
+//
+// HX-2013-11
+//
+// Implementing a variant of
+// the problem of Dining Philosophers
+//
+(* ****** ****** *)
+
+#include
+"share/atspre_define.hats"
+
+(* ****** ****** *)
+
+staload "{$LIBATSHWXI}/teaching/mythread/SATS/channel.sats"
+
+(* ****** ****** *)
+
+%{#
+#define NPHIL 5
+%} // end of [%{#]
+#define NPHIL 5
+
+(* ****** ****** *)
+
+typedef nphil = natLt(NPHIL)
+
+(* ****** ****** *)
+
+fun phil_left (n: nphil): nphil
+fun phil_right (n: nphil): nphil
+
+(* ****** ****** *)
+//
+fun phil_loop (n: nphil): void
+//
+(* ****** ****** *)
+
+fun cleaner_loop ((*void*)): void
+
+(* ****** ****** *)
+
+absvtype fork_vtype = ptr
+vtypedef fork = fork_vtype
+
+(* ****** ****** *)
+
+fun fork_get_num (!fork): nphil
+
+(* ****** ****** *)
+
+fun phil_dine
+  (n: nphil, lf: !fork, rf: !fork): void
+// end of [phil_dine]
+
+fun phil_think (n: nphil): void
+
+(* ****** ****** *)
+
+fun cleaner_wash (f: !fork): void
+fun cleaner_return (f: fork): void
+
+(* ****** ****** *)
+//
+fun fork_changet (n: nphil): channel(fork)
+//
+fun forktray_changet ((*void*)): channel(fork)
+//
+(* ****** ****** *)
+
+(* end of [DiningPhil2.sats] *)

samples/ATS/DiningPhil2_fork.dats

@@ -0,0 +1,89 @@
+(* ****** ****** *)
+//
+// HX-2013-11
+//
+// Implementing a variant of
+// the problem of Dining Philosophers
+//
+(* ****** ****** *)
+//
+#include
+"share/atspre_define.hats"
+#include
+"share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+staload
+UN = "prelude/SATS/unsafe.sats"
+
+(* ****** ****** *)
+
+staload "{$LIBATSHWXI}/teaching/mythread/SATS/channel.sats"
+
+(* ****** ****** *)
+
+staload _ = "libats/DATS/deqarray.dats"
+staload _ = "{$LIBATSHWXI}/teaching/mythread/DATS/channel.dats"
+
+(* ****** ****** *)
+
+staload "./DiningPhil2.sats"
+
+(* ****** ****** *)
+
+datavtype fork = FORK of (nphil)
+
+(* ****** ****** *)
+
+assume fork_vtype = fork
+
+(* ****** ****** *)
+
+implement
+fork_get_num (f) = let val FORK(n) = f in n end
+
+(* ****** ****** *)
+
+local
+
+val
+the_forkarray = let
+//
+typedef t = channel(fork)
+//
+implement
+array_tabulate$fopr<t>
+  (n) = ch where
+{
+  val n = $UN.cast{nphil}(n)
+  val ch = channel_create_exn<fork> (i2sz(2))
+  val () = channel_insert (ch, FORK (n))
+}
+//
+in
+  arrayref_tabulate<t> (i2sz(NPHIL))
+end // end of [val]
+
+in (* in of [local] *)
+
+implement fork_changet (n) = the_forkarray[n]
+
+end // end of [local]
+
+(* ****** ****** *)
+
+local
+
+val the_forktray =
+  channel_create_exn<fork> (i2sz(NPHIL+1))
+
+in (* in of [local] *)
+
+implement forktray_changet () = the_forktray
+
+end // end of [local]
+
+(* ****** ****** *)
+
+(* end of [DiningPhil2_fork.dats] *)

samples/ATS/DiningPhil2_thread.dats

@@ -0,0 +1,43 @@
+(* ****** ****** *)
+//
+// HX-2013-11
+//
+// Implementing a variant of
+// the problem of Dining Philosophers
+//
+(* ****** ****** *)
+//
+#include "share/atspre_define.hats"
+#include "share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+staload "{$LIBATSHWXI}/teaching/mythread/SATS/mythread.sats"
+
+(* ****** ****** *)
+
+local
+//
+#include "{$LIBATSHWXI}/teaching/mythread/DATS/mythread.dats"
+//
+in (* in of [local] *)
+//
+// HX: it is intentionally left to be empty
+//
+end // end of [local]
+
+(* ****** ****** *)
+
+local
+//
+#include "{$LIBATSHWXI}/teaching/mythread/DATS/mythread_posix.dats"
+//
+in (* in of [local] *)
+//
+// HX: it is intentionally left to be empty
+//
+end // end of [local]
+
+(* ****** ****** *)
+
+(* end of [DiningPhil2_thread.dats] *)

samples/ATS/YonedaLemma.dats

@@ -0,0 +1,178 @@
+(* ****** ****** *)
+//
+// HX-2014-01
+// Yoneda Lemma:
+// The hardest "trivial" theorem :)
+//
+(* ****** ****** *)
+//
+#include
+"share/atspre_staload.hats"
+//
+(* ****** ****** *)
+
+staload
+"libats/ML/SATS/basis.sats"
+staload
+"libats/ML/SATS/list0.sats"
+staload
+"libats/ML/SATS/option0.sats"
+
+(* ****** ****** *)
+
+staload _ = "libats/ML/DATS/list0.dats"
+staload _ = "libats/ML/DATS/option0.dats"
+
+(* ****** ****** *)
+
+sortdef ftype = type -> type
+
+(* ****** ****** *)
+
+infixr (->) ->>
+typedef ->> (a:type, b:type) = a -<cloref1> b
+
+(* ****** ****** *)
+
+typedef
+functor(F:ftype) =
+  {a,b:type} (a ->> b) ->> F(a) ->> F(b)
+
+(* ****** ****** *)
+
+typedef
+list0 (a:type) = list0 (a)
+extern
+val functor_list0 : functor (list0)
+
+(* ****** ****** *)
+
+implement
+functor_list0{a,b}
+  (f) = lam xs => list0_map<a><b> (xs, f)
+
+(* ****** ****** *)
+
+typedef
+option0 (a:type) = option0 (a)  
+extern
+val functor_option0 : functor (option0)
+  
+(* ****** ****** *)
+
+implement
+functor_option0{a,b}
+  (f) = lam opt => option0_map<a><b> (opt, f)
+
+(* ****** ****** *)
+
+extern
+val functor_homres
+  : {c:type} functor (lam(r:type) => c ->> r)
+
+(* ****** ****** *)
+
+implement
+functor_homres{c}{a,b} (f) = lam (r) => lam (x) => f (r(x))
+
+(* ****** ****** *)
+//
+extern
+fun Yoneda_phi : {F:ftype}functor(F) ->
+  {a:type}F(a) ->> ({r:type}(a ->> r) ->> F(r))
+extern
+fun Yoneda_psi : {F:ftype}functor(F) ->
+  {a:type}({r:type}(a ->> r) ->> F(r)) ->> F(a)
+//
+(* ****** ****** *)
+//
+implement
+Yoneda_phi
+  (ftor) = lam(fx) => lam (m) => ftor(m)(fx)
+//
+implement
+Yoneda_psi (ftor) = lam(mf) => mf(lam x => x)
+//
+(* ****** ****** *)
+
+(*
+
+(* ****** ****** *)
+//
+// HX-2014-01-05:
+// Another version based on Natural Transformation
+//
+(* ****** ****** *)
+
+typedef
+natrans(F:ftype, G:ftype) = {x:type} (F(x) ->> G(x))
+
+(* ****** ****** *)
+//
+extern
+fun Yoneda_phi_nat : {F:ftype}functor(F) ->
+  {a:type} F(a) ->> natrans(lam (r:type) => (a ->> r), F)
+extern
+fun Yoneda_psi_nat : {F:ftype}functor(F) ->
+  {a:type} natrans(lam (r:type) => (a ->> r), F) ->> F(a)
+//
+(* ****** ****** *)
+//
+implement
+Yoneda_phi_nat
+  (ftor) = lam(fx) => lam (m) => ftor(m)(fx)
+//
+implement
+Yoneda_psi_nat (ftor) = lam(mf) => mf(lam x => x)
+//
+(* ****** ****** *)
+
+*)
+
+(* ****** ****** *)
+
+datatype bool = True | False // boxed boolean
+
+(* ****** ****** *)
+//
+fun bool2string
+  (x:bool): string =
+(
+  case+ x of True() => "True" | False() => "False"
+)
+//
+implement
+fprint_val<bool> (out, x) = fprint (out, bool2string(x))
+//
+(* ****** ****** *)
+//
+val myboolist0 =
+  $list_t{bool}(True, False, True, False, False)
+val myboolist0 = g0ofg1_list (myboolist0)
+//
+(* ****** ****** *)
+//
+extern
+val Yoneda_bool_list0 : {r:type} (bool ->> r) ->> list0(r)
+//
+implement
+Yoneda_bool_list0 =
+  Yoneda_phi(functor_list0){bool}(myboolist0)
+//
+(* ****** ****** *)
+//
+val myboolist1 =
+  Yoneda_psi(functor_list0){bool}(Yoneda_bool_list0)
+//
+(* ****** ****** *)
+
+val () = fprintln! (stdout_ref, "myboolist0 = ", myboolist0)
+val () = fprintln! (stdout_ref, "myboolist1 = ", myboolist1)
+
+(* ****** ****** *)
+
+implement main0 () = ()
+
+(* ****** ****** *)
+
+(* end of [YonedaLemma.dats] *)

samples/ATS/linset.hats

@@ -0,0 +1,187 @@
+(***********************************************************************)
+(*                                                                     *)
+(*                         Applied Type System                         *)
+(*                                                                     *)
+(***********************************************************************)
+
+(*
+** ATS/Postiats - Unleashing the Potential of Types!
+** Copyright (C) 2011-2013 Hongwei Xi, ATS Trustful Software, Inc.
+** All rights reserved
+**
+** ATS is free software;  you can  redistribute it and/or modify it under
+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the
+** Free Software Foundation; either version 3, or (at  your  option)  any
+** later version.
+** 
+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY
+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or
+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
+** for more details.
+** 
+** You  should  have  received  a  copy of the GNU General Public License
+** along  with  ATS;  see the  file COPYING.  If not, please write to the
+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA
+** 02110-1301, USA.
+*)
+
+(* ****** ****** *)
+
+(* Author: Hongwei Xi *)
+(* Authoremail: hwxi AT cs DOT bu DOT edu *)
+(* Start time: December, 2012 *)
+
+(* ****** ****** *)
+//
+// HX: shared by linset_listord (* ordered list *)
+// HX: shared by linset_avltree (* AVL-tree-based *)
+//
+(* ****** ****** *)
+//
+// HX-2013-02:
+// for sets of nonlinear elements
+//
+absvtype set_vtype (a:t@ype+) = ptr
+//
+(* ****** ****** *)
+
+vtypedef set (a:t0p) = set_vtype (a)
+
+(* ****** ****** *)
+
+fun{a:t0p}
+compare_elt_elt (x1: a, x2: a):<> int
+
+(* ****** ****** *)
+
+fun{} linset_nil{a:t0p} ():<> set(a)
+fun{} linset_make_nil{a:t0p} ():<> set(a)
+
+(* ****** ****** *)
+
+fun{a:t0p} linset_sing (x: a):<!wrt> set(a)
+fun{a:t0p} linset_make_sing (x: a):<!wrt> set(a)
+
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_make_list (xs: List(INV(a))):<!wrt> set(a)
+
+(* ****** ****** *)
+
+fun{}
+linset_is_nil {a:t0p} (xs: !set(INV(a))):<> bool
+fun{}
+linset_isnot_nil {a:t0p} (xs: !set(INV(a))):<> bool
+
+(* ****** ****** *)
+
+fun{a:t0p} linset_size (!set(INV(a))): size_t
+
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_is_member (xs: !set(INV(a)), x0: a):<> bool
+fun{a:t0p}
+linset_isnot_member (xs: !set(INV(a)), x0: a):<> bool
+
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_copy (!set(INV(a))):<!wrt> set(a)
+fun{a:t0p}
+linset_free (xs: set(INV(a))):<!wrt> void
+
+(* ****** ****** *)
+//
+fun{a:t0p}
+linset_insert
+  (xs: &set(INV(a)) >> _, x0: a):<!wrt> bool
+//
+(* ****** ****** *)
+//
+fun{a:t0p}
+linset_takeout
+(
+  &set(INV(a)) >> _, a, res: &(a?) >> opt(a, b)
+) :<!wrt> #[b:bool] bool(b) // endfun
+fun{a:t0p}
+linset_takeout_opt (&set(INV(a)) >> _, a):<!wrt> Option_vt(a)
+//
+(* ****** ****** *)
+//
+fun{a:t0p}
+linset_remove
+  (xs: &set(INV(a)) >> _, x0: a):<!wrt> bool
+//
+(* ****** ****** *)
+//
+// HX: choosing an element in an unspecified manner
+//
+fun{a:t0p}
+linset_choose
+(
+  xs: !set(INV(a)), x: &a? >> opt (a, b)
+) :<!wrt> #[b:bool] bool(b)
+//
+fun{a:t0p}
+linset_choose_opt (xs: !set(INV(a))):<!wrt> Option_vt(a)
+//
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_takeoutmax
+(
+  xs: &set(INV(a)) >> _, res: &a? >> opt(a, b)
+) :<!wrt> #[b:bool] bool (b)
+fun{a:t0p}
+linset_takeoutmax_opt (xs: &set(INV(a)) >> _):<!wrt> Option_vt(a)
+
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_takeoutmin
+(
+  xs: &set(INV(a)) >> _, res: &a? >> opt(a, b)
+) :<!wrt> #[b:bool] bool (b)
+fun{a:t0p}
+linset_takeoutmin_opt (xs: &set(INV(a)) >> _):<!wrt> Option_vt(a)
+
+(* ****** ****** *)
+//
+fun{}
+fprint_linset$sep (FILEref): void // ", "
+//
+fun{a:t0p}
+fprint_linset (out: FILEref, xs: !set(INV(a))): void
+//
+overload fprint with fprint_linset
+//
+(* ****** ****** *)
+//
+fun{
+a:t0p}{env:vt0p
+} linset_foreach$fwork
+  (x: a, env: &(env) >> _): void
+//
+fun{a:t0p}
+linset_foreach (set: !set(INV(a))): void
+fun{
+a:t0p}{env:vt0p
+} linset_foreach_env
+  (set: !set(INV(a)), env: &(env) >> _): void
+// end of [linset_foreach_env]
+//
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_listize (xs: set(INV(a))): List0_vt (a)
+
+(* ****** ****** *)
+
+fun{a:t0p}
+linset_listize1 (xs: !set(INV(a))): List0_vt (a)
+
+(* ****** ****** *)
+
+(* end of [linset.hats] *)

samples/ATS/linset_listord.dats

@@ -0,0 +1,504 @@
+(***********************************************************************)
+(*                                                                     *)
+(*                         Applied Type System                         *)
+(*                                                                     *)
+(***********************************************************************)
+
+(*
+** ATS/Postiats - Unleashing the Potential of Types!
+** Copyright (C) 2011-2013 Hongwei Xi, ATS Trustful Software, Inc.
+** All rights reserved
+**
+** ATS is free software;  you can  redistribute it and/or modify it under
+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the
+** Free Software Foundation; either version 3, or (at  your  option)  any
+** later version.
+** 
+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY
+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or
+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
+** for more details.
+** 
+** You  should  have  received  a  copy of the GNU General Public License
+** along  with  ATS;  see the  file COPYING.  If not, please write to the
+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA
+** 02110-1301, USA.
+*)
+
+(* ****** ****** *)
+
+(* Author: Hongwei Xi *)
+(* Authoremail: hwxi AT cs DOT bu DOT edu *)
+(* Start time: February, 2013 *)
+
+(* ****** ****** *)
+//
+// HX-2013-08:
+// a set is represented as a sorted list in descending order;
+// note that descending order is chosen to faciliate set comparison
+//
+(* ****** ****** *)
+
+staload
+UN = "prelude/SATS/unsafe.sats"
+
+(* ****** ****** *)
+
+staload "libats/SATS/linset_listord.sats"
+
+(* ****** ****** *)
+
+#include "./SHARE/linset.hats" // code reuse
+#include "./SHARE/linset_node.hats" // code reuse
+
+(* ****** ****** *)
+
+assume
+set_vtype (elt:t@ype) = List0_vt (elt)
+
+(* ****** ****** *)
+
+implement{}
+linset_nil () = list_vt_nil ()
+implement{}
+linset_make_nil () = list_vt_nil ()
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+linset_sing
+  (x) = list_vt_cons{a}(x, list_vt_nil)
+// end of [linset_sing]
+implement{a}
+linset_make_sing
+  (x) = list_vt_cons{a}(x, list_vt_nil)
+// end of [linset_make_sing]
+
+(* ****** ****** *)
+
+implement{}
+linset_is_nil (xs) = list_vt_is_nil (xs)
+implement{}
+linset_isnot_nil (xs) = list_vt_is_cons (xs)
+
+(* ****** ****** *)
+
+implement{a}
+linset_size (xs) =
+  let val n = list_vt_length(xs) in i2sz(n) end
+// end of [linset_size]
+
+(* ****** ****** *)
+
+implement{a}
+linset_is_member
+  (xs, x0) = let
+//
+fun aux
+  {n:nat} .<n>.
+(
+  xs: !list_vt (a, n)
+) :<> bool = let
+in
+//
+case+ xs of
+| list_vt_cons (x, xs) => let
+    val sgn = compare_elt_elt<a> (x0, x) in
+    if sgn > 0 then false else (if sgn < 0 then aux (xs) else true)
+  end // end of [list_vt_cons]
+| list_vt_nil ((*void*)) => false
+//
+end // end of [aux]
+//
+in
+  aux (xs)
+end // end of [linset_is_member]
+
+(* ****** ****** *)
+
+implement{a}
+linset_copy (xs) = list_vt_copy<a> (xs)
+implement{a}
+linset_free (xs) = list_vt_free<a> (xs)
+
+(* ****** ****** *)
+
+implement{a}
+linset_insert
+  (xs, x0) = let
+//
+fun
+mynode_cons
+  {n:nat} .<>.
+(
+  nx: mynode1 (a), xs: list_vt (a, n)
+) : list_vt (a, n+1) = let
+//
+val xs1 =
+$UN.castvwtp0{List1_vt(a)}(nx)
+val+@list_vt_cons (_, xs2) = xs1
+prval () = $UN.cast2void (xs2); val () = (xs2 := xs)
+//
+in
+  fold@ (xs1); xs1
+end // end of [mynode_cons]
+//
+fun ins
+  {n:nat} .<n>. // tail-recursive
+(
+  xs: &list_vt (a, n) >> list_vt (a, n1)
+) : #[n1:nat | n <= n1; n1 <= n+1] bool =
+(
+case+ xs of
+| @list_vt_cons
+    (x, xs1) => let
+    val sgn =
+      compare_elt_elt<a> (x0, x)
+    // end of [val]
+  in
+    if sgn > 0 then let
+      prval () = fold@ (xs)
+      val nx = mynode_make_elt<a> (x0)
+      val ((*void*)) = xs := mynode_cons (nx, xs)
+    in
+      false
+    end else if sgn < 0 then let
+      val ans = ins (xs1)
+      prval () = fold@ (xs)
+    in
+      ans
+    end else let // [x0] is found
+      prval () = fold@ (xs)
+    in
+      true (* [x0] in [xs] *)
+    end (* end of [if] *)
+  end // end of [list_vt_cons]
+| list_vt_nil () => let
+    val nx = mynode_make_elt<a> (x0)
+    val ((*void*)) = xs := mynode_cons (nx, xs)
+  in
+    false
+  end // end of [list_vt_nil]
+) (* end of [ins] *)
+//
+in
+  $effmask_all (ins (xs))
+end // end of [linset_insert]
+
+(* ****** ****** *)
+
+(*
+//
+HX-2013-08:
+[linset_remove] moved up
+//
+implement{a}
+linset_remove
+  (xs, x0) = let
+//
+fun rem
+  {n:nat} .<n>. // tail-recursive
+(
+  xs: &list_vt (a, n) >> list_vt (a, n1)
+) : #[n1:nat | n1 <= n; n <= n1+1] bool =
+(
+case+ xs of
+| @list_vt_cons
+    (x, xs1) => let
+    val sgn =
+      compare_elt_elt<a> (x0, x)
+    // end of [val]
+  in
+    if sgn > 0 then let
+      prval () = fold@ (xs)
+    in
+      false
+    end else if sgn < 0 then let
+      val ans = rem (xs1)
+      prval () = fold@ (xs)
+    in
+      ans
+    end else let // x0 = x
+      val xs1_ = xs1
+      val ((*void*)) = free@{a}{0}(xs)
+      val () = xs := xs1_
+    in
+      true // [x0] in [xs]
+    end (* end of [if] *)
+  end // end of [list_vt_cons]
+| list_vt_nil () => false
+) (* end of [rem] *)
+//
+in
+  $effmask_all (rem (xs))
+end // end of [linset_remove]
+*)
+
+(* ****** ****** *)
+(*
+** By Brandon Barker
+*)
+implement
+{a}(*tmp*)
+linset_choose
+  (xs, x0) = let
+in
+//
+case+ xs of
+| list_vt_cons
+    (x, xs1) => let
+    val () = x0 := x
+    prval () = opt_some{a}(x0)
+  in
+    true
+  end // end of [list_vt_cons]
+| list_vt_nil () => let
+    prval () = opt_none{a}(x0)
+  in
+    false
+  end // end of [list_vt_nil]
+//
+end // end of [linset_choose]
+
+(* ****** ****** *)
+
+implement
+{a}{env}
+linset_foreach_env (xs, env) = let
+//
+implement
+list_vt_foreach$fwork<a><env>
+  (x, env) = linset_foreach$fwork<a><env> (x, env)
+//
+in
+  list_vt_foreach_env<a><env> (xs, env)
+end // end of [linset_foreach_env]
+
+(* ****** ****** *)
+
+implement{a}
+linset_listize (xs) = xs
+
+(* ****** ****** *)
+
+implement{a}
+linset_listize1 (xs) = list_vt_copy (xs)
+
+(* ****** ****** *)
+//
+// HX: functions for processing mynodes
+//
+(* ****** ****** *)
+
+implement{
+} mynode_null{a} () =
+  $UN.castvwtp0{mynode(a,null)}(the_null_ptr)
+// end of [mynode_null]
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+mynode_make_elt
+  (x) = let
+//
+val nx = list_vt_cons{a}{0}(x, _ )
+//
+in
+  $UN.castvwtp0{mynode1(a)}(nx)
+end // end of [mynode_make_elt]
+
+(* ****** ****** *)
+
+implement{
+} mynode_free
+  {a}(nx) = () where {
+val nx =
+  $UN.castvwtp0{List1_vt(a)}(nx)
+//
+val+~list_vt_cons (_, nx2) = nx
+//
+prval ((*void*)) = $UN.cast2void (nx2)
+//
+} (* end of [mynode_free] *)
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+mynode_get_elt
+  (nx) = (x) where {
+//
+val nx1 =
+  $UN.castvwtp1{List1_vt(a)}(nx)
+//
+val+list_vt_cons (x, _) = nx1
+//
+prval ((*void*)) = $UN.cast2void (nx1)
+//
+} (* end of [mynode_get_elt] *)
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+mynode_set_elt
+  {l} (nx, x0) =
+{
+//
+val nx1 =
+  $UN.castvwtp1{List1_vt(a)}(nx)
+//
+val+@list_vt_cons (x, _) = nx1
+//
+val () = x := x0
+//
+prval () = fold@ (nx1)
+prval () = $UN.cast2void (nx1)
+//
+prval () = __assert (nx) where
+{
+  extern praxi __assert (nx: !mynode(a?, l) >> mynode (a, l)): void
+} (* end of [prval] *)
+//
+} (* end of [mynode_set_elt] *)
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+mynode_getfree_elt
+  (nx) = (x) where {
+//
+val nx =
+  $UN.castvwtp0{List1_vt(a)}(nx)
+//
+val+~list_vt_cons (x, nx2) = nx
+//
+prval ((*void*)) = $UN.cast2void (nx2)
+//
+} (* end of [mynode_getfree_elt] *)
+
+(* ****** ****** *)
+
+(*
+fun{a:t0p}
+linset_takeout_ngc
+  (set: &set(INV(a)) >> _, x0: a):<!wrt> mynode0 (a)
+// end of [linset_takeout_ngc]
+*)
+implement
+{a}(*tmp*)
+linset_takeout_ngc
+  (set, x0) = let
+//
+fun takeout
+(
+  xs: &List0_vt (a) >> _
+) : mynode0(a) = let
+in
+//
+case+ xs of
+| @list_vt_cons
+    (x, xs1) => let
+    prval pf_x = view@x
+    prval pf_xs1 = view@xs1
+    val sgn =
+      compare_elt_elt<a> (x0, x)
+    // end of [val]
+  in
+    if sgn > 0 then let
+      prval () = fold@ (xs)
+    in
+      mynode_null{a}((*void*))
+    end else if sgn < 0 then let
+      val res = takeout (xs1)
+      prval ((*void*)) = fold@ (xs)
+    in
+      res
+    end else let // x0 = x
+      val xs1_ = xs1
+      val res = $UN.castvwtp0{mynode1(a)}((pf_x, pf_xs1 | xs))
+      val () = xs := xs1_
+    in
+      res // [x0] in [xs]
+    end (* end of [if] *)
+  end // end of [list_vt_cons]
+| list_vt_nil () => mynode_null{a}((*void*))
+//
+end (* end of [takeout] *)
+//
+in
+  $effmask_all (takeout (set))
+end // end of [linset_takeout_ngc]
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+linset_takeoutmax_ngc
+  (xs) = let
+in
+//
+case+ xs of
+| @list_vt_cons
+    (x, xs1) => let
+    prval pf_x = view@x
+    prval pf_xs1 = view@xs1
+    val xs_ = xs
+    val () = xs := xs1
+  in
+    $UN.castvwtp0{mynode1(a)}((pf_x, pf_xs1 | xs_))
+  end // end of [list_vt_cons]
+| @list_vt_nil () => let
+    prval () = fold@ (xs)
+  in
+    mynode_null{a}((*void*))
+  end // end of [list_vt_nil]
+//
+end // end of [linset_takeoutmax_ngc]
+
+(* ****** ****** *)
+
+implement
+{a}(*tmp*)
+linset_takeoutmin_ngc
+  (xs) = let
+//
+fun unsnoc
+  {n:pos} .<n>.
+(
+  xs: &list_vt (a, n) >> list_vt (a, n-1)
+) :<!wrt> mynode1 (a) = let
+//
+val+@list_vt_cons (x, xs1) = xs
+//
+prval pf_x = view@x and pf_xs1 = view@xs1
+//
+in
+//
+case+ xs1 of
+| list_vt_cons _ =>
+    let val res = unsnoc(xs1) in fold@xs; res end
+  // end of [list_vt_cons]
+| list_vt_nil () => let
+    val xs_ = xs
+    val () = xs := list_vt_nil{a}()
+  in
+    $UN.castvwtp0{mynode1(a)}((pf_x, pf_xs1 | xs_))
+  end // end of [list_vt_nil]
+//
+end // end of [unsnoc]
+//
+in
+//
+case+ xs of
+| list_vt_cons _ => unsnoc (xs)
+| list_vt_nil () => mynode_null{a}((*void*))
+//
+end // end of [linset_takeoutmin_ngc]
+
+(* ****** ****** *)
+
+(* end of [linset_listord.dats] *)

samples/ATS/linset_listord.sats

@@ -0,0 +1,51 @@
+(***********************************************************************)
+(*                                                                     *)
+(*                         Applied Type System                         *)
+(*                                                                     *)
+(***********************************************************************)
+
+(*
+** ATS/Postiats - Unleashing the Potential of Types!
+** Copyright (C) 2011-2013 Hongwei Xi, ATS Trustful Software, Inc.
+** All rights reserved
+**
+** ATS is free software;  you can  redistribute it and/or modify it under
+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the
+** Free Software Foundation; either version 3, or (at  your  option)  any
+** later version.
+** 
+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY
+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or
+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
+** for more details.
+** 
+** You  should  have  received  a  copy of the GNU General Public License
+** along  with  ATS;  see the  file COPYING.  If not, please write to the
+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA
+** 02110-1301, USA.
+*)
+
+(* ****** ****** *)
+//
+// Author: Hongwei Xi
+// Authoremail: hwxiATcsDOTbuDOTedu
+// Time: October, 2010
+//
+(* ****** ****** *)
+
+#define ATS_PACKNAME "ATSLIB.libats.linset_listord"
+#define ATS_STALOADFLAG 0 // no static loading at run-time
+
+(* ****** ****** *)
+
+#include "./SHARE/linset.hats"
+#include "./SHARE/linset_node.hats"
+
+(* ****** ****** *)
+
+castfn
+linset2list {a:t0p} (xs: set (INV(a))):<> List0_vt (a)
+
+(* ****** ****** *)
+
+(* end of [linset_listord.sats] *)

samples/ATS/main.atxt

@@ -0,0 +1,215 @@
+%{
+#include "./../ATEXT/atextfun.hats"
+%}
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+   "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<title>EFFECTIVATS-DiningPhil2</title>
+#patscode_style()
+</head>
+
+<body>
+
+<h1>
+Effective ATS: Dining Philosophers
+</h1>
+
+In this article, I present an implementation of a slight variant of the
+famous problem of 5-Dining-Philosophers by Dijkstra that makes simple but
+convincing use of linear types.
+
+<h2>
+The Original Problem 
+</h2>
+
+There are five philosophers sitting around a table and there are also 5
+forks placed on the table such that each fork is located between the left
+hand of a philosopher and the right hand of another philosopher. Each
+philosopher does the following routine repeatedly: thinking and dining.  In
+order to dine, a philosopher needs to first acquire two forks: one located
+on his left-hand side and the other on his right-hand side. After
+finishing dining, a philosopher puts the two acquired forks onto the table:
+one on his left-hand side and the other on his right-hand side.
+
+<h2>
+A Variant of the Original Problem 
+</h2>
+
+The following twist is added to the original version:
+
+<p>
+
+After a fork is used, it becomes a "dirty" fork and needs to be put in a
+tray for dirty forks. There is a cleaner who cleans dirty forks and then
+puts them back on the table.
+
+<h2>
+Channels for Communication
+</h2>
+
+A channel is just a shared queue of fixed capacity. The following two
+functions are for inserting an element into and taking an element out of a
+given channel:
+
+<pre
+class="patsyntax">
+#pats2xhtml_sats("\
+fun{a:vt0p} channel_insert (channel (a), a): void
+fun{a:vt0p} channel_takeout (chan: channel (a)): (a) 
+")</pre>
+
+If [channel_insert] is called on a channel that is full, then the caller is
+blocked until an element is taken out of the channel.  If [channel_takeout]
+is called on a channel that is empty, then the caller is blocked until an
+element is inserted into the channel.
+
+<h2>
+A Channel for Each Fork
+</h2>
+
+Forks are resources given a linear type. Each fork is initially stored in a
+channel, which can be obtained by calling the following function:
+
+<pre
+class="patsyntax">
+#pats2xhtml_sats("\
+fun fork_changet (n: nphil): channel(fork)
+")</pre>
+
+where the type [nphil] is defined to be [natLt(5)] (for natural numbers
+less than 5). The channels for storing forks are chosen to be of capacity
+2. The reason that channels of capacity 2 are chosen to store at most one
+element (in each of them) is to guarantee that these channels can never be
+full (so that there is no attempt made to send signals to awake callers
+supposedly being blocked due to channels being full).
+
+
+<h2>
+A Channel for the Fork Tray
+</h2>
+
+A tray for storing "dirty" forks is also a channel, which can be obtained
+by calling the following function:
+
+<pre
+class="patsyntax">
+#pats2xhtml_sats("\
+fun forktray_changet ((*void*)): channel(fork)
+")</pre>
+
+The capacity chosen for the channel is 6 (instead of 5) so that it can
+never become full (as there are only 5 forks in total).
+
+<h2>
+Philosopher Loop
+</h2>
+
+Each philosopher is implemented as a loop:
+
+<pre
+class="patsyntax">
+#pats2xhtml_dats('\
+implement
+phil_loop (n) = let
+//
+val () = phil_think (n)
+//
+val nl = phil_left (n) // = n
+val nr = phil_right (n) // = (n+1) % 5
+//
+val ch_lfork = fork_changet (nl)
+val ch_rfork = fork_changet (nr)
+//
+val lf = channel_takeout (ch_lfork)
+val () = println! ("phil_loop(", n, ") picks left fork")
+//
+val () = randsleep (2) // sleep up to 2 seconds
+//
+val rf = channel_takeout (ch_rfork)
+val () = println! ("phil_loop(", n, ") picks right fork")
+//
+val () = phil_dine (n, lf, rf)
+//
+val ch_forktray = forktray_changet ()
+val () = channel_insert (ch_forktray, lf) // left fork to dirty tray
+val () = channel_insert (ch_forktray, rf) // right fork to dirty tray
+//
+in
+  phil_loop (n)
+end // end of [phil_loop]
+')</pre>
+
+It should be straighforward to follow the code for [phil_loop].
+
+<h2>
+Fork Cleaner Loop
+</h2>
+
+A cleaner is implemented as a loop:
+
+<pre
+class="patsyntax">
+#pats2xhtml_dats('\
+implement
+cleaner_loop () = let
+//
+val ch = forktray_changet ()
+val f0 = channel_takeout (ch) // [f0] is dirty
+//
+val () = cleaner_wash (f0) // washes dirty [f0]
+val () = cleaner_return (f0) // puts back cleaned [f0]
+//
+in
+  cleaner_loop ()
+end // end of [cleaner_loop]
+')</pre>
+
+The function [cleaner_return] first finds out the number of a given fork
+and then uses the number to locate the channel for storing the fork. Its
+actual implementation is given as follows:
+
+<pre
+class="patsyntax">
+#pats2xhtml_dats('\
+implement
+cleaner_return (f) =
+{
+  val n = fork_get_num (f)
+  val ch = fork_changet (n)
+  val () = channel_insert (ch, f)
+}
+')</pre>
+
+It should now be straighforward to follow the code for [cleaner_loop].
+
+<h2>
+Testing
+</h2>
+
+The entire code of this implementation is stored in the following files:
+
+<pre>
+DiningPhil2.sats
+DiningPhil2.dats
+DiningPhil2_fork.dats
+DiningPhil2_thread.dats
+</pre>
+
+There is also a Makefile available for compiling the ATS source code into
+an excutable for testing. One should be able to encounter a deadlock after
+running the simulation for a while.
+
+<hr size="2">
+
+This article is written by <a href="http://www.cs.bu.edu/~hwxi/">Hongwei Xi</a>.
+
+</body>
+</html>
+
+%{
+implement main () = fprint_filsub (stdout_ref, "main_atxt.txt")
+%}

samples/AspectJ/CacheAspect.aj

@@ -0,0 +1,41 @@
+package com.blogspot.miguelinlas3.aspectj.cache;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.aspectj.lang.JoinPoint;
+
+import com.blogspot.miguelinlas3.aspectj.cache.marker.Cachable;
+
+/**
+ * This simple aspect simulates the behaviour of a very simple cache
+ *  
+ * @author migue
+ *
+ */
+public aspect CacheAspect {
+
+	public pointcut cache(Cachable cachable): execution(@Cachable * * (..)) && @annotation(cachable);
+	
+	Object around(Cachable cachable): cache(cachable){
+	
+		String evaluatedKey = this.evaluateKey(cachable.scriptKey(), thisJoinPoint);
+		
+		if(cache.containsKey(evaluatedKey)){
+			System.out.println("Cache hit for key " + evaluatedKey);
+			return this.cache.get(evaluatedKey);
+		}
+		
+		System.out.println("Cache miss for key " + evaluatedKey);
+		Object value = proceed(cachable);
+		cache.put(evaluatedKey, value);
+		return value;
+	}
+	
+	protected String evaluateKey(String key, JoinPoint joinPoint) {
+		// TODO add some smart staff to allow simple scripting in @Cachable annotation
+		return key;
+	}
+	
+	protected Map<String, Object> cache = new WeakHashMap<String, Object>();
+}

samples/AspectJ/OptimizeRecursionCache.aj

@@ -0,0 +1,50 @@
+package aspects.caching;
+
+import java.util.Map;
+
+/**
+ * Cache aspect for optimize recursive functions.
+ * 
+ * @author Migueli
+ * @date 05/11/2013
+ * @version 1.0
+ *
+ */
+public abstract aspect OptimizeRecursionCache {
+		
+	@SuppressWarnings("rawtypes")
+	private Map _cache;
+	
+	public OptimizeRecursionCache() {
+		_cache = getCache();
+	}
+	
+	@SuppressWarnings("rawtypes")
+	abstract public Map getCache();
+	
+	abstract public pointcut operation(Object o);
+
+	pointcut topLevelOperation(Object o): operation(o) && !cflowbelow(operation(Object));
+
+	before(Object o) : topLevelOperation(o) {
+		System.out.println("Seeking value for " + o);
+	}
+
+	Object around(Object o) : operation(o) {
+		Object cachedValue = _cache.get(o);
+		if (cachedValue != null) {
+			System.out.println("Found cached value for " + o + ": " + cachedValue);
+			return cachedValue;
+		}
+		return proceed(o);
+	}
+
+	@SuppressWarnings("unchecked")
+	after(Object o) returning(Object result) : topLevelOperation(o) {
+		_cache.put(o, result);
+	}
+	
+	after(Object o) returning(Object result) : topLevelOperation(o) {
+		System.out.println("cache size: " + _cache.size());
+	}
+}

samples/C#/Index.cshtml

@@ -0,0 +1,45 @@
+@{
+    ViewBag.Title = "Home Page";
+}
+@section featured {
+    <section class="featured">
+        <div class="content-wrapper">
+            <hgroup class="title">
+                <h1>@ViewBag.Title.</h1>
+                <h2>@ViewBag.Message</h2>
+            </hgroup>
+            <p>
+                To learn more about ASP.NET MVC visit
+                <a href="http://asp.net/mvc" title="ASP.NET MVC Website">http://asp.net/mvc</a>.
+                The page features <mark>videos, tutorials, and samples</mark> to help you get the most from ASP.NET MVC.
+                If you have any questions about ASP.NET MVC visit
+                <a href="http://forums.asp.net/1146.aspx/1?MVC" title="ASP.NET MVC Forum">our forums</a>.
+            </p>
+        </div>
+    </section>
+}
+<h3>We suggest the following:</h3>
+<ol class="round">
+    <li class="one">
+        <h5>Getting Started</h5>
+        ASP.NET MVC gives you a powerful, patterns-based way to build dynamic websites that
+        enables a clean separation of concerns and that gives you full control over markup
+        for enjoyable, agile development. ASP.NET MVC includes many features that enable
+        fast, TDD-friendly development for creating sophisticated applications that use
+        the latest web standards.
+        <a href="http://go.microsoft.com/fwlink/?LinkId=245151">Learn more…</a>
+    </li>
+
+    <li class="two">
+        <h5>Add NuGet packages and jump-start your coding</h5>
+        NuGet makes it easy to install and update free libraries and tools.
+        <a href="http://go.microsoft.com/fwlink/?LinkId=245153">Learn more…</a>
+    </li>
+
+    <li class="three">
+        <h5>Find Web Hosting</h5>
+        You can easily find a web hosting company that offers the right mix of features
+        and price for your applications.
+        <a href="http://go.microsoft.com/fwlink/?LinkId=245157">Learn more…</a>
+    </li>
+</ol>

samples/C#/Program.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LittleSampleApp
+{
+  /// <summary>
+  /// Just what it says on the tin. A little sample application for Linguist to try out.
+  /// 
+  /// </summary>
+  class Program
+  {
+    static void Main(string[] args)
+    {
+      Console.WriteLine("Hello, I am a little sample application to test GitHub's Linguist module.");
+      Console.WriteLine("I also include a Razor MVC file just to prove it handles cshtml files now.");
+    }
+  }
+}

samples/C++/CsvStreamer.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <fstream>
+#include "util.h"
+
+using namespace std;
+
+
+#define DEFAULT_DELIMITER	','
+
+
+class CsvStreamer
+{
+	private:
+		ofstream file;				// File output stream
+		vector<string> row_buffer;	// Buffer which stores a row's data before being flushed/written
+		int fields;					// Number of fields (columns)
+		long rows;					// Number of rows (records) including header row
+		char delimiter;				// Delimiter character; comma by default
+		string sanitize(string);	// Returns a string ready for output into the file
+		
+	public:
+		CsvStreamer();				// Empty CSV streamer... be sure to open the file before writing!
+		CsvStreamer(string, char);	// Same as open(string, char)...
+		CsvStreamer(string);		// Opens an output CSV file given a file path/name
+		~CsvStreamer();				// Ensures the output file is closed and saved
+		void open(string);			// Opens an output CSV file given a file path/name (default delimiter)
+		void open(string, char);	// Opens an output CSV file given a file path/name and a delimiting character (default comma)
+		void add_field(string);		// If still on first line, adds a new field to the header row
+		void save_fields();			// Call this to save the header row; all new writes should be through append()
+		void append(string);		// Appends the current row with this data for the next field; quoted only if needed (leading/trailing spaces are trimmed)
+		void append(string, bool);	// Like append(string) but can specify whether to trim spaces at either end of the data (false to keep spaces)
+		void append(float);			// Appends the current row with this number
+		void append(double);		// Appends the current row with this number
+		void append(long);			// Appends the current row with this number
+		void append(int);			// Appends the current row with this number
+		void writeln();				// Flushes what was in the row buffer into the file (writes the row)
+		void close();				// Saves and closes the file
+		int field_count();			// Gets the number of fields (columns)
+		long row_count();			// Gets the number of records (rows) -- NOT including the header row
+};

samples/C++/Field.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+* Dwarf Mine - The 13-11 Benchmark
+*
+* Copyright (c) 2013 Bünger, Thomas; Kieschnick, Christian; Kusber,
+* Michael; Lohse, Henning; Wuttke, Nikolai; Xylander, Oliver; Yao, Gary;
+* Zimmermann, Florian
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*****************************************************************************/
+
+#pragma once
+
+enum Field { Free, Black, White, Illegal };
+
+typedef Field Player;

samples/C++/Types.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+* Dwarf Mine - The 13-11 Benchmark
+*
+* Copyright (c) 2013 Bünger, Thomas; Kieschnick, Christian; Kusber,
+* Michael; Lohse, Henning; Wuttke, Nikolai; Xylander, Oliver; Yao, Gary;
+* Zimmermann, Florian
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*****************************************************************************/
+
+#pragma once
+
+#include <cstdint>
+
+typedef uint32_t smallPrime_t;

samples/C++/libcanister.h

@@ -0,0 +1,138 @@
+#ifndef LIBCANIH
+#define LIBCANIH
+#include <iostream>
+#include <fstream>
+#include <stdlib.h>
+#include <cstring>
+
+#define int64 unsigned long long
+//#define DEBUG
+
+#ifdef DEBUG
+#define dout cout
+#else
+#define dout if (0) cerr
+#endif
+
+using namespace std;
+
+namespace libcanister
+{
+
+    //the canmem object is a generic memory container used commonly
+    //throughout the canister framework to hold memory of uncertain
+    //length which may or may not contain null bytes. 
+    class canmem
+    {
+    public:
+        char* data; //the raw memory block
+        int size; //the absolute length of the block
+        canmem(); //creates an unallocated canmem
+        canmem(int allocsize); //creates an allocated, blank canmem of size
+        canmem(char* strdata); //automates the creation of zero-limited canmems
+        ~canmem(); //cleans up the canmem
+        void zeromem(); //overwrites this canmem
+        void fragmem(); //overwrites this canmem with fragment notation
+        void countlen(); //counts length of zero-limited strings and stores it in size
+        void trim(); //removes any nulls from the end of the string
+        static canmem null(); //returns a singleton null canmem
+        
+    };
+    
+    //contains information about the canister
+    class caninfo
+    {
+    public:
+        canmem path; //physical path
+        canmem internalname; //a name for the canister
+        int numfiles; //the number of files in the canister
+    };
+    
+    //necessary for the use of this class as a type in canfile
+    class canister;
+    
+    //this object holds the definition of a 'file' within the
+    //canister 'filesystem.'
+    class canfile
+    {
+    public:
+        libcanister::canister* parent; //the canister that holds this file
+        canmem path; //internal path ('filename')
+        canmem data; //the file's decompressed contents
+        int isfrag; //0 = probably not fragment, 1 = definitely a fragment (ignore)
+        int cfid; //'canfile id' -- a unique ID for this file
+        int64 dsize; //ondisk size (compressed form size)
+        int cachestate; //0 = not in memory, 1 = in memory, 2 = in memory and needs flush
+                        //-1 = error, check the data for the message
+        void cache(); //pull the file from disk and cache it in memory
+        void cachedump(); //deletes the contents of this file from the memory cache after assuring the on disk copy is up to date
+        void cachedumpfinal(fstream& infile); //same as cachedump, but more efficient during closing procedures
+        void flush(); //updates the on disk copy, but retains the memory cache
+    };
+
+    //the primary class
+    //this defines and controls a single canister
+    class canister
+    {
+        //table of contents
+        //absolutely worthless to the control code in the canister
+        //but quite useful to programs using the API, as they may
+        //desire to enumerate the files in a canister for a user's
+        //use or for their own.
+        //contains a newline-delimited list of files in the container.
+        canfile TOC;
+    public:
+        caninfo info; //the general info about this canister
+
+        //the raw canfiles -- recommended that programs do not modify
+        //these files directly, but not enforced.
+        canfile* files;
+        bool readonly; //if true then no write routines will do anything
+        
+        //maximum number of files to have in memory at any given
+        //time, change this to whatever suits your application.
+        int cachemax;
+        int cachecnt; //number of files in the cache (should not be modified)
+
+        //both initialize the canister from a physical location
+        canister (canmem fspath);
+        canister (char* fspath);
+
+        //destroys the canister (after flushing the modded buffers, of course)
+        ~canister();
+        
+        //open the fspath
+        //does it exist?
+        // | --- yes --- opening it (return 1)
+        // | --- yes --- file is corrupted, halting (return -1)
+        // | --- no  --- making a new one (return 0)
+        int open();
+        
+        //close the canister, flush all buffers, clean up
+        int close();
+        
+        //deletes the file at path inside this canister
+        int delFile(canmem path);
+        
+        //pulls the contents of the file from disk or memory and returns it as a file
+        canfile getFile(canmem path);
+        
+        //creates a file if it does not exist, otherwise overwrites
+        //returns whether operation succeeded
+        bool writeFile(canmem path, canmem data);
+        bool writeFile(canfile file);
+        
+        //get the 'table of contents', a file containing a newline delimited
+        //list of the file paths in the container which have contents
+        canfile getTOC();
+ 
+        //brings the cache back within the cachemax limit
+        //important: sCFID is the safe CFID
+        //(the CFID of the file we want to avoid uncaching)
+        //really just used internally, but it can't do any harm.
+        void cacheclean(int sCFID, bool dFlush = false);
+    };
+
+}
+
+#endif

samples/C++/metrics.h

@@ -0,0 +1,92 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef NINJA_METRICS_H_
+#define NINJA_METRICS_H_
+
+#include <string>
+#include <vector>
+using namespace std;
+
+#include "util.h"  // For int64_t.
+
+/// The Metrics module is used for the debug mode that dumps timing stats of
+/// various actions.  To use, see METRIC_RECORD below.
+
+/// A single metrics we're tracking, like "depfile load time".
+struct Metric {
+  string name;
+  /// Number of times we've hit the code path.
+  int count;
+  /// Total time (in micros) we've spent on the code path.
+  int64_t sum;
+};
+
+
+/// A scoped object for recording a metric across the body of a function.
+/// Used by the METRIC_RECORD macro.
+struct ScopedMetric {
+  explicit ScopedMetric(Metric* metric);
+  ~ScopedMetric();
+
+private:
+  Metric* metric_;
+  /// Timestamp when the measurement started.
+  /// Value is platform-dependent.
+  int64_t start_;
+};
+
+/// The singleton that stores metrics and prints the report.
+struct Metrics {
+  Metric* NewMetric(const string& name);
+
+  /// Print a summary report to stdout.
+  void Report();
+
+private:
+  vector<Metric*> metrics_;
+};
+
+/// Get the current time as relative to some epoch.
+/// Epoch varies between platforms; only useful for measuring elapsed time.
+int64_t GetTimeMillis();
+
+/// A simple stopwatch which returns the time
+/// in seconds since Restart() was called.
+struct Stopwatch {
+ public:
+  Stopwatch() : started_(0) {}
+
+  /// Seconds since Restart() call.
+  double Elapsed() const {
+    return 1e-6 * static_cast<double>(Now() - started_);
+  }
+
+  void Restart() { started_ = Now(); }
+
+ private:
+  uint64_t started_;
+  uint64_t Now() const;
+};
+
+/// The primary interface to metrics.  Use METRIC_RECORD("foobar") at the top
+/// of a function to get timing stats recorded for each call of the function.
+#define METRIC_RECORD(name)                                             \
+  static Metric* metrics_h_metric =                                     \
+      g_metrics ? g_metrics->NewMetric(name) : NULL;                    \
+  ScopedMetric metrics_h_scoped(metrics_h_metric);
+
+extern Metrics* g_metrics;
+
+#endif // NINJA_METRICS_H_

samples/C++/render_adapter.cpp

@@ -0,0 +1,6 @@
+#include <cstdint>
+
+namespace Gui
+{
+
+}

samples/C++/rpc.h

@@ -0,0 +1,26 @@
+// Copyright (C) 2013 Simon Que
+//
+// This file is part of DuinoCube.
+//
+// DuinoCube is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// DuinoCube is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with DuinoCube.  If not, see <http://www.gnu.org/licenses/>.
+
+// DuinoCube remote procedure call functions.
+
+#include <stdint.h>
+
+// Initializes RPC system.
+void rpc_init();
+
+// Runs the RPC server loop forever.
+void rpc_server_loop();

samples/C/bootstrap.h

@@ -0,0 +1,102 @@
+#ifndef BOOTSTRAP_H
+#define BOOTSTRAP_H
+
+#include <stdio.h>
+#include "cxrs.h"
+
+/* If we're not using GNU C, elide __attribute__ */
+#ifndef __GNUC__
+#  define  __attribute__(x)  /*NOTHING*/
+#endif
+
+typedef struct object object;
+
+object *true;
+object *false;
+object *eof;
+object *empty_list;
+object *global_enviroment;
+
+enum obj_type {
+        scm_bool,
+        scm_empty_list,
+        scm_eof,
+        scm_char,
+        scm_int,
+        scm_pair,
+        scm_symbol,
+        scm_prim_fun,
+        scm_lambda,
+        scm_str,
+        scm_file
+};
+
+typedef object *(*prim_proc)(object *args);
+
+object *read(FILE *in);
+object *eval(object *code, object *env);
+void print(FILE *out, object *obj, int display);
+
+int check_type(enum obj_type type, object *obj, int err_on_false);
+
+static inline int is_true(object *obj)
+{
+        return obj != false;
+}
+
+object *make_int(int value);
+int obj2int(object *i);
+
+object *make_bool(int value);
+int obj2bool(object *b);
+
+object *make_char(char c);
+char obj2char(object *ch);
+
+object *make_str(char *str);
+char *obj2str(object *str);
+
+object *cons(object *car, object *cdr);
+object *car(object *pair);
+object *cdr(object *pair);
+void set_car(object *pair, object *new);
+void set_cdr(object *pair, object *new);
+
+object *make_symbol(char *name);
+char *sym2str(object *sym);
+object *get_symbol(char *name) __attribute__((pure));
+
+object *make_prim_fun(prim_proc fun);
+prim_proc obj2prim_proc(object *proc);
+
+object *make_lambda(object *args, object *code, object *env);
+object *lambda_code(object *lambda);
+object *lambda_args(object *lambda);
+
+object *make_port(FILE *handle, int direction);
+int port_direction(object *port);
+FILE *port_handle(object *port);
+void set_port_handle_to_null(object *port);
+
+/*both of these should never be called*/
+object *apply_proc(object *);
+object *eval_proc(object *);
+
+
+object *maybe_add_begin(object *code);
+
+void init_enviroment(object *env);
+
+
+void eval_err(char *msg, object *code) __attribute__((noreturn));
+
+void define_var(object *var, object *val, object *env);
+void set_var(object *var, object *val, object *env);
+object *get_var(object *var, object *env);
+
+object *cond2nested_if(object *cond);
+object *let2lambda(object *let);
+object *and2nested_if(object *and);
+object *or2nested_if(object *or);
+
+#endif /*include guard*/

samples/C/dynarray.cats

@@ -0,0 +1,56 @@
+/* ******************************************************************* */
+/*                                                                     */
+/*                         Applied Type System                         */
+/*                                                                     */
+/* ******************************************************************* */
+
+/*
+** ATS/Postiats - Unleashing the Potential of Types!
+** Copyright (C) 2011-20?? Hongwei Xi, ATS Trustful Software, Inc.
+** All rights reserved
+**
+** ATS is free software;  you can  redistribute it and/or modify it under
+** the terms of  the GNU GENERAL PUBLIC LICENSE (GPL) as published by the
+** Free Software Foundation; either version 3, or (at  your  option)  any
+** later version.
+** 
+** ATS is distributed in the hope that it will be useful, but WITHOUT ANY
+** WARRANTY; without  even  the  implied  warranty  of MERCHANTABILITY or
+** FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
+** for more details.
+** 
+** You  should  have  received  a  copy of the GNU General Public License
+** along  with  ATS;  see the  file COPYING.  If not, please write to the
+** Free Software Foundation,  51 Franklin Street, Fifth Floor, Boston, MA
+** 02110-1301, USA.
+*/
+
+/* ****** ****** */
+
+/*
+(* Author: Hongwei Xi *)
+(* Authoremail: hwxi AT cs DOT bu DOT edu *)
+(* Start time: March, 2013 *)
+*/
+
+/* ****** ****** */
+
+#ifndef ATSHOME_LIBATS_DYNARRAY_CATS
+#define ATSHOME_LIBATS_DYNARRAY_CATS
+
+/* ****** ****** */
+
+#include <string.h>
+
+/* ****** ****** */
+
+#define atslib_dynarray_memcpy memcpy
+#define atslib_dynarray_memmove memmove
+
+/* ****** ****** */
+
+#endif // ifndef ATSHOME_LIBATS_DYNARRAY_CATS
+
+/* ****** ****** */
+
+/* end of [dynarray.cats] */

samples/C/readline.cats

@@ -0,0 +1,47 @@
+/*
+** API in ATS for GNU-readline
+*/
+
+/* ****** ****** */
+
+/*
+** Permission to use, copy, modify, and distribute this software for any
+** purpose with or without fee is hereby granted, provided that the above
+** copyright notice and this permission notice appear in all copies.
+** 
+** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+** WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+** MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+** ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+** WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+** ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+** OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/* ****** ****** */
+
+#ifndef READLINE_READLINE_CATS
+#define READLINE_READLINE_CATS
+
+/* ****** ****** */
+
+#include <readline/readline.h>
+
+/* ****** ****** */
+//
+#define \
+atscntrb_readline_rl_library_version() ((char*)rl_library_version)
+//
+#define atscntrb_readline_rl_readline_version() (rl_readline_version)
+//
+/* ****** ****** */
+
+#define atscntrb_readline_readline readline
+
+/* ****** ****** */
+
+#endif // ifndef READLINE_READLINE_CATS
+
+/* ****** ****** */
+
+/* end of [readline.cats] */

samples/Cirru/array.cirru

@@ -0,0 +1,12 @@
+
+print $ array
+  int 1
+  string 2
+
+print $ array
+  int 1
+  array
+    int 2
+    string 3
+    array
+      string 4

samples/Cirru/block.cirru

@@ -0,0 +1,7 @@
+
+set f $ block (a b c)
+  print a b c
+
+call f (int 1) (int 2) (int 3)
+
+f (int 1) (int 2) (int 3)

samples/Cirru/bool.cirru

@@ -0,0 +1,7 @@
+
+print $ bool true
+print $ bool false
+print $ bool yes
+print $ bool no
+print $ bool 1
+print $ bool 0

samples/Cirru/map.cirru

@@ -0,0 +1,14 @@
+
+print $ map
+  a $ int 5
+  b $ array (int 1) (int 2)
+  c $ map
+    int 1
+    array (int 4)
+
+set m $ map
+  a $ int 1
+
+set m b $ int 2
+
+print m

samples/Cirru/number.cirru

@@ -0,0 +1,3 @@
+
+print $ int 1
+print $ float 1.2

samples/Cirru/require.cirru

@@ -0,0 +1,2 @@
+
+require ./stdio.cr

samples/Cirru/scope.cirru

@@ -0,0 +1,23 @@
+
+set a (int 2)
+
+print (self)
+
+set c (child)
+
+under c
+  under parent
+    print a
+
+print $ get c a
+
+set c x (int 3)
+print $ get c x
+
+set just-print $ code
+  print a
+
+print just-print
+
+eval (self) just-print
+eval just-print

samples/Cirru/stdio.cirru

@@ -0,0 +1,55 @@
+
+set a $ string 1
+print a
+
+print (string 1)
+
+print nothing
+
+print
+  map
+    a (int 4)
+    b $ map
+      a $ int 5
+      b $ int 6
+      c $ map
+        int 7
+
+print
+  array
+    int 1
+    int 2
+    array
+      int 3
+      int 4
+
+print
+  array
+    int 1
+    map
+      a $ int 2
+      b $ array
+        int 3
+
+print
+  int 1
+  int 2
+
+print $ code
+  set a 1
+  print (get a)
+  print $ array
+    int a
+    array
+      int a
+
+set container (map)
+set container code $ code
+  set a 1
+  print (get a)
+  print $ array
+    int a
+    array
+      int a
+
+print container

samples/Cirru/string.cirru

@@ -0,0 +1,3 @@
+
+print $ string a
+print $ string "a b"

samples/Dart/point.dart

@@ -1,15 +1,19 @@
+import 'dart:math' as math;
+
 class Point {
+  num x, y;
+
   Point(this.x, this.y);
-  distanceTo(Point other) {
+
+  num distanceTo(Point other) {
     var dx = x - other.x;
     var dy = y - other.y;
-    return Math.sqrt(dx * dx + dy * dy);
+    return math.sqrt(dx * dx + dy * dy);
   }
-  var x, y;
 }
 
-main() {
-  Point p = new Point(2, 3);
-  Point q = new Point(3, 4);
+void main() {
+  var p = new Point(2, 3);
+  var q = new Point(3, 4);
   print('distance from p to q = ${p.distanceTo(q)}');
 }

samples/Game Maker Language/ClientBeginStep.gml

@@ -0,0 +1,642 @@
+/*
+    Originally from /Source/gg2/Scripts/Client/ClientBeginStep.gml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+// receive and interpret the server's message(s)
+var i, playerObject, playerID, player, otherPlayerID, otherPlayer, sameVersion, buffer, plugins, pluginsRequired, usePlugins;
+
+if(tcp_eof(global.serverSocket)) {
+    if(gotServerHello)
+        show_message("You have been disconnected from the server.");
+    else
+        show_message("Unable to connect to the server.");
+    instance_destroy();
+    exit;
+}
+
+if(room == DownloadRoom and keyboard_check(vk_escape))
+{
+    instance_destroy();
+    exit;
+}
+
+if(downloadingMap)
+{
+    while(tcp_receive(global.serverSocket, min(1024, downloadMapBytes-buffer_size(downloadMapBuffer))))
+    {
+        write_buffer(downloadMapBuffer, global.serverSocket);
+        if(buffer_size(downloadMapBuffer) == downloadMapBytes)
+        {
+            write_buffer_to_file(downloadMapBuffer, "Maps/" + downloadMapName + ".png");
+            downloadingMap = false;
+            buffer_destroy(downloadMapBuffer);
+            downloadMapBuffer = -1;
+            exit;
+        }
+    }
+    exit;
+}
+
+roomchange = false;
+do {
+    if(tcp_receive(global.serverSocket,1)) {
+        switch(read_ubyte(global.serverSocket)) {
+        case HELLO:
+            gotServerHello = true;
+            global.joinedServerName = receivestring(global.serverSocket, 1);
+            downloadMapName = receivestring(global.serverSocket, 1);
+            advertisedMapMd5 = receivestring(global.serverSocket, 1);
+            receiveCompleteMessage(global.serverSocket, 1, global.tempBuffer);
+            pluginsRequired = read_ubyte(global.tempBuffer);
+            plugins = receivestring(global.serverSocket, 1);
+            if(string_pos("/", downloadMapName) != 0 or string_pos("\", downloadMapName) != 0)
+            {
+                show_message("Server sent illegal map name: "+downloadMapName);
+                instance_destroy();
+                exit;
+            }
+
+            if (!noReloadPlugins && string_length(plugins))
+            {
+                usePlugins = pluginsRequired || !global.serverPluginsPrompt;
+                if (global.serverPluginsPrompt)
+                {
+                    var prompt;
+                    if (pluginsRequired)
+                    {
+                        prompt = show_question(
+                            "This server requires the following plugins to play on it: "
+                            + string_replace_all(plugins, ",", "#")
+                            + '#They are downloaded from the source: "'
+                            + PLUGIN_SOURCE
+                            + '"#The source states: "'
+                            + PLUGIN_SOURCE_NOTICE
+                            + '"#Do you wish to download them and continue connecting?'
+                        );
+                        if (!prompt)
+                        {
+                            instance_destroy();
+                            exit;
+                        }
+                    }
+                    else
+                    {
+                        prompt = show_question(
+                            "This server suggests the following optional plugins to play on it: "
+                            + string_replace_all(plugins, ",", "#")
+                            + '#They are downloaded from the source: "'
+                            + PLUGIN_SOURCE
+                            + '"#The source states: "'
+                            + PLUGIN_SOURCE_NOTICE
+                            + '"#Do you wish to download them and use them?'
+                        );
+                        if (prompt)
+                        {
+                            usePlugins = true;
+                        }
+                    }
+                }
+                if (usePlugins)
+                {
+                    if (!loadserverplugins(plugins))
+                    {
+                        show_message("Error ocurred loading server-sent plugins.");
+                        instance_destroy();
+                        exit;
+                    }
+                    global.serverPluginsInUse = true;
+                }
+            }
+            noReloadPlugins = false;
+            
+            if(advertisedMapMd5 != "")
+            {
+                var download;
+                download = not file_exists("Maps/" + downloadMapName + ".png");
+                if(!download and CustomMapGetMapMD5(downloadMapName) != advertisedMapMd5)
+                {
+                    if(show_question("The server's copy of the map (" + downloadMapName + ") differs from ours.#Would you like to download this server's version of the map?"))
+                        download = true;
+                    else
+                    {
+                        instance_destroy();
+                        exit;
+                    }
+                }
+                
+                if(download)
+                {
+                    write_ubyte(global.serverSocket, DOWNLOAD_MAP);
+                    socket_send(global.serverSocket);
+                    receiveCompleteMessage(global.serverSocket,4,global.tempBuffer);
+                    downloadMapBytes = read_uint(global.tempBuffer);
+                    downloadMapBuffer = buffer_create();
+                    downloadingMap = true;
+                    roomchange=true;
+                }
+            }
+            ClientPlayerJoin(global.serverSocket);
+            if(global.rewardKey != "" and global.rewardId != "")
+            {
+                var rewardId;
+                rewardId = string_copy(global.rewardId, 0, 255);
+                write_ubyte(global.serverSocket, REWARD_REQUEST);
+                write_ubyte(global.serverSocket, string_length(rewardId));
+                write_string(global.serverSocket, rewardId);
+            }
+            if(global.queueJumping == true)
+            {
+                write_ubyte(global.serverSocket, CLIENT_SETTINGS);
+                write_ubyte(global.serverSocket, global.queueJumping);
+            }
+            socket_send(global.serverSocket);
+            break;
+            
+        case JOIN_UPDATE:
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            global.playerID = read_ubyte(global.tempBuffer);
+            global.currentMapArea = read_ubyte(global.tempBuffer);
+            break;
+        
+        case FULL_UPDATE:
+            deserializeState(FULL_UPDATE);
+            break;
+        
+        case QUICK_UPDATE:
+            deserializeState(QUICK_UPDATE);
+            break;
+             
+        case CAPS_UPDATE:
+            deserializeState(CAPS_UPDATE);
+            break;
+                  
+        case INPUTSTATE:
+            deserializeState(INPUTSTATE);
+            break;             
+        
+        case PLAYER_JOIN:
+            player = instance_create(0,0,Player);
+            player.name = receivestring(global.serverSocket, 1);
+                  
+            ds_list_add(global.players, player);
+            if(ds_list_size(global.players)-1 == global.playerID) {
+                global.myself = player;
+                instance_create(0,0,PlayerControl);
+            }
+            break;
+            
+        case PLAYER_LEAVE:
+            // Delete player from the game, adjust own ID accordingly
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            playerID = read_ubyte(global.tempBuffer);
+            player = ds_list_find_value(global.players, playerID);
+            removePlayer(player);
+            if(playerID < global.playerID) {
+                global.playerID -= 1;
+            }
+            break;
+                                   
+        case PLAYER_DEATH:
+            var causeOfDeath, assistantPlayerID, assistantPlayer;
+            receiveCompleteMessage(global.serverSocket,4,global.tempBuffer);
+            playerID = read_ubyte(global.tempBuffer);
+            otherPlayerID = read_ubyte(global.tempBuffer);
+            assistantPlayerID = read_ubyte(global.tempBuffer);
+            causeOfDeath = read_ubyte(global.tempBuffer);
+                  
+            player = ds_list_find_value(global.players, playerID);
+            
+            otherPlayer = noone;
+            if(otherPlayerID != 255)
+                otherPlayer = ds_list_find_value(global.players, otherPlayerID);
+            
+            assistantPlayer = noone;
+            if(assistantPlayerID != 255)
+                assistantPlayer = ds_list_find_value(global.players, assistantPlayerID);
+            
+            doEventPlayerDeath(player, otherPlayer, assistantPlayer, causeOfDeath);
+            break;
+             
+        case BALANCE:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            balanceplayer=read_ubyte(global.tempBuffer);
+            if balanceplayer == 255 {
+                if !instance_exists(Balancer) instance_create(x,y,Balancer);
+                with(Balancer) notice=0;
+            } else {
+                player = ds_list_find_value(global.players, balanceplayer);
+                if(player.object != -1) {
+                    with(player.object) {
+                        instance_destroy();
+                    }
+                    player.object = -1;
+                }
+                if(player.team==TEAM_RED) {
+                    player.team = TEAM_BLUE;
+                } else {
+                    player.team = TEAM_RED;
+                }
+                if !instance_exists(Balancer) instance_create(x,y,Balancer);
+                Balancer.name=player.name;
+                with (Balancer) notice=1;
+            }
+            break;
+                  
+        case PLAYER_CHANGETEAM:
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            if(player.object != -1) {
+                with(player.object) {
+                    instance_destroy();
+                }
+                player.object = -1;
+            }
+            player.team = read_ubyte(global.tempBuffer);
+            break;
+             
+        case PLAYER_CHANGECLASS:
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            if(player.object != -1) {
+                with(player.object) {
+                    instance_destroy();
+                }
+                player.object = -1;
+            }
+            player.class = read_ubyte(global.tempBuffer);
+            break;             
+        
+        case PLAYER_CHANGENAME:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            player.name = receivestring(global.serverSocket, 1);
+            if player=global.myself {
+                global.playerName=player.name
+            }
+            break;
+                 
+        case PLAYER_SPAWN:
+            receiveCompleteMessage(global.serverSocket,3,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventSpawn(player, read_ubyte(global.tempBuffer), read_ubyte(global.tempBuffer));
+            break;
+              
+        case CHAT_BUBBLE:
+            var bubbleImage;
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            setChatBubble(player, read_ubyte(global.tempBuffer));
+            break;
+             
+        case BUILD_SENTRY:
+            receiveCompleteMessage(global.serverSocket,6,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            buildSentry(player, read_ushort(global.tempBuffer)/5, read_ushort(global.tempBuffer)/5, read_byte(global.tempBuffer));
+            break;
+              
+        case DESTROY_SENTRY:
+            receiveCompleteMessage(global.serverSocket,4,global.tempBuffer);
+            playerID = read_ubyte(global.tempBuffer);
+            otherPlayerID = read_ubyte(global.tempBuffer);
+            assistantPlayerID = read_ubyte(global.tempBuffer);
+            causeOfDeath = read_ubyte(global.tempBuffer);
+            
+            player = ds_list_find_value(global.players, playerID);
+            if(otherPlayerID == 255) {
+                doEventDestruction(player, noone, noone, causeOfDeath);
+            } else {
+                otherPlayer = ds_list_find_value(global.players, otherPlayerID);
+                if (assistantPlayerID == 255) {
+                    doEventDestruction(player, otherPlayer, noone, causeOfDeath);
+                } else {
+                    assistantPlayer = ds_list_find_value(global.players, assistantPlayerID);
+                    doEventDestruction(player, otherPlayer, assistantPlayer, causeOfDeath);
+                }
+            }
+            break;
+                      
+        case GRAB_INTEL:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventGrabIntel(player);
+            break;
+      
+        case SCORE_INTEL:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventScoreIntel(player);
+            break;
+      
+        case DROP_INTEL:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventDropIntel(player); 
+            break;
+            
+        case RETURN_INTEL:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            doEventReturnIntel(read_ubyte(global.tempBuffer));
+            break;
+  
+        case GENERATOR_DESTROY:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            team = read_ubyte(global.tempBuffer);
+            doEventGeneratorDestroy(team);
+            break;
+      
+        case UBER_CHARGED:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventUberReady(player);
+            break;
+  
+        case UBER:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            doEventUber(player);
+            break;    
+  
+        case OMNOMNOMNOM:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            if(player.object != -1) {
+                with(player.object) {
+                    omnomnomnom=true;
+                    if(hp < 200)
+                    {
+                        canEat = false;
+                        alarm[6] = eatCooldown; //10 second cooldown
+                    }
+                    if(player.team == TEAM_RED) {
+                        omnomnomnomindex=0;
+                        omnomnomnomend=31;
+                    } else if(player.team==TEAM_BLUE) {
+                        omnomnomnomindex=32;
+                        omnomnomnomend=63;
+                    }
+                    xscale=image_xscale; 
+                } 
+            }
+            break;
+      
+        case TOGGLE_ZOOM:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            if player.object != -1 {
+                toggleZoom(player.object);
+            }
+            break;
+                                         
+        case PASSWORD_REQUEST:
+            if(!usePreviousPwd)
+                global.clientPassword = get_string("Enter Password:", "");
+            write_ubyte(global.serverSocket, string_length(global.clientPassword));
+            write_string(global.serverSocket, global.clientPassword);
+            socket_send(global.serverSocket);
+            break;
+       
+        case PASSWORD_WRONG:                                    
+            show_message("Incorrect Password.");
+            instance_destroy();
+            exit;
+        
+        case INCOMPATIBLE_PROTOCOL:
+            show_message("Incompatible server protocol version.");
+            instance_destroy();
+            exit;
+            
+        case KICK:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            reason = read_ubyte(global.tempBuffer);
+            if reason == KICK_NAME kickReason = "Name Exploit";
+            else if reason == KICK_BAD_PLUGIN_PACKET kickReason = "Invalid plugin packet ID";
+            else if reason == KICK_MULTI_CLIENT kickReason = "There are too many connections from your IP";
+            else kickReason = "";
+            show_message("You have been kicked from the server. "+kickReason+".");
+            instance_destroy();
+            exit;
+              
+        case ARENA_STARTROUND:
+            doEventArenaStartRound();
+            break;
+            
+        case ARENA_ENDROUND:
+            with ArenaHUD clientArenaEndRound();
+            break;   
+        
+        case ARENA_RESTART:
+            doEventArenaRestart();
+            break;
+            
+        case UNLOCKCP:
+            doEventUnlockCP();
+            break;
+                   
+        case MAP_END:
+            global.nextMap=receivestring(global.serverSocket, 1);
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            global.winners=read_ubyte(global.tempBuffer);
+            global.currentMapArea=read_ubyte(global.tempBuffer);
+            global.mapchanging = true;
+            if !instance_exists(ScoreTableController) instance_create(0,0,ScoreTableController);
+            instance_create(0,0,WinBanner);
+            break;
+
+        case CHANGE_MAP:
+            roomchange=true;
+            global.mapchanging = false;
+            global.currentMap = receivestring(global.serverSocket, 1);
+            global.currentMapMD5 = receivestring(global.serverSocket, 1);
+            if(global.currentMapMD5 == "") { // if this is an internal map (signified by the lack of an md5)
+                if(findInternalMapRoom(global.currentMap))
+                    room_goto_fix(findInternalMapRoom(global.currentMap));
+                else
+                {
+                    show_message("Error:#Server went to invalid internal map: " + global.currentMap + "#Exiting.");
+                    instance_destroy();
+                    exit;
+                }
+            } else { // it's an external map
+                if(string_pos("/", global.currentMap) != 0 or string_pos("\", global.currentMap) != 0)
+                {
+                    show_message("Server sent illegal map name: "+global.currentMap);
+                    instance_destroy();
+                    exit;
+                }
+                if(!file_exists("Maps/" + global.currentMap + ".png") or CustomMapGetMapMD5(global.currentMap) != global.currentMapMD5)
+                {   // Reconnect to the server to download the map
+                    var oldReturnRoom;
+                    oldReturnRoom = returnRoom;
+                    returnRoom = DownloadRoom;
+                    if (global.serverPluginsInUse)
+                        noUnloadPlugins = true;
+                    event_perform(ev_destroy,0);
+                    ClientCreate();
+                    if (global.serverPluginsInUse)
+                        noReloadPlugins = true;
+                    returnRoom = oldReturnRoom;
+                    usePreviousPwd = true;
+                    exit;
+                }
+                room_goto_fix(CustomMapRoom);
+            }
+                 
+            for(i=0; i<ds_list_size(global.players); i+=1) {
+                player = ds_list_find_value(global.players, i);
+                if global.currentMapArea == 1 { 
+                    player.stats[KILLS] = 0;
+                    player.stats[DEATHS] = 0;
+                    player.stats[CAPS] = 0;
+                    player.stats[ASSISTS] = 0;
+                    player.stats[DESTRUCTION] = 0;
+                    player.stats[STABS] = 0;
+                    player.stats[HEALING] = 0;
+                    player.stats[DEFENSES] = 0;
+                    player.stats[INVULNS] = 0;
+                    player.stats[BONUS] = 0;
+                    player.stats[DOMINATIONS] = 0;
+                    player.stats[REVENGE] = 0;
+                    player.stats[POINTS] = 0;
+                    player.roundStats[KILLS] = 0;
+                    player.roundStats[DEATHS] = 0;
+                    player.roundStats[CAPS] = 0;
+                    player.roundStats[ASSISTS] = 0;
+                    player.roundStats[DESTRUCTION] = 0;
+                    player.roundStats[STABS] = 0;
+                    player.roundStats[HEALING] = 0;
+                    player.roundStats[DEFENSES] = 0;
+                    player.roundStats[INVULNS] = 0;
+                    player.roundStats[BONUS] = 0;
+                    player.roundStats[DOMINATIONS] = 0;
+                    player.roundStats[REVENGE] = 0;
+                    player.roundStats[POINTS] = 0;
+                    player.team = TEAM_SPECTATOR;
+                }
+            }
+            break;
+        
+        case SERVER_FULL:
+            show_message("The server is full.");
+            instance_destroy();
+            exit;
+        
+        case REWARD_CHALLENGE_CODE:
+            var challengeData;
+            receiveCompleteMessage(global.serverSocket,16,global.tempBuffer);
+            challengeData = read_binstring(global.tempBuffer, buffer_size(global.tempBuffer));
+            challengeData += socket_remote_ip(global.serverSocket);
+
+            write_ubyte(global.serverSocket, REWARD_CHALLENGE_RESPONSE);
+            write_binstring(global.serverSocket, hmac_md5_bin(global.rewardKey, challengeData));
+            socket_send(global.serverSocket);
+            break;
+
+        case REWARD_UPDATE:
+            receiveCompleteMessage(global.serverSocket,1,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            var rewardString;
+            rewardString = receivestring(global.serverSocket, 2);
+            doEventUpdateRewards(player, rewardString);
+            break;
+            
+        case MESSAGE_STRING:
+            var message, notice;
+            message = receivestring(global.serverSocket, 1);
+            with NoticeO instance_destroy();
+            notice = instance_create(0, 0, NoticeO);
+            notice.notice = NOTICE_CUSTOM;
+            notice.message = message;
+            break;
+        
+        case SENTRY_POSITION:
+            receiveCompleteMessage(global.serverSocket,5,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            if(player.sentry)
+            {
+                player.sentry.x = read_ushort(global.tempBuffer) / 5;
+                player.sentry.y = read_ushort(global.tempBuffer) / 5;
+                player.sentry.xprevious = player.sentry.x;
+                player.sentry.yprevious = player.sentry.y;
+                player.sentry.vspeed = 0;
+            }
+            break;
+          
+        case WEAPON_FIRE:
+            receiveCompleteMessage(global.serverSocket,9,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            
+            if(player.object)
+            {
+                with(player.object)
+                {
+                    x = read_ushort(global.tempBuffer)/5;
+                    y = read_ushort(global.tempBuffer)/5;
+                    hspeed = read_byte(global.tempBuffer)/8.5;
+                    vspeed = read_byte(global.tempBuffer)/8.5;
+                    xprevious = x;
+                    yprevious = y;
+                }
+                
+                doEventFireWeapon(player, read_ushort(global.tempBuffer));
+            }
+            break;
+
+        case PLUGIN_PACKET:
+            var packetID, packetLen, buf, success;
+
+            // fetch full packet
+            receiveCompleteMessage(global.serverSocket, 2, global.tempBuffer);
+            packetLen = read_ushort(global.tempBuffer);
+            receiveCompleteMessage(global.serverSocket, packetLen, global.tempBuffer);
+
+            packetID = read_ubyte(global.tempBuffer);
+
+            // get packet data
+            buf = buffer_create();
+            write_buffer_part(buf, global.tempBuffer, packetLen - 1);
+
+            // try to enqueue
+            // give "noone" value for client since received from server
+            success = _PluginPacketPush(packetID, buf, noone);
+            
+            // if it returned false, packetID was invalid
+            if (!success)
+            {
+                // clear up buffer
+                buffer_destroy(buf);
+                show_error("ERROR when reading plugin packet: no such plugin packet ID " + string(packetID), true);
+            }
+            break;
+        
+        case CLIENT_SETTINGS:
+            receiveCompleteMessage(global.serverSocket,2,global.tempBuffer);
+            player = ds_list_find_value(global.players, read_ubyte(global.tempBuffer));
+            player.queueJump = read_ubyte(global.tempBuffer);
+            break;
+
+        default:
+            promptRestartOrQuit("The Server sent unexpected data.");
+            exit;
+        }
+    } else {
+        break;
+    }
+} until(roomchange);

samples/Game Maker Language/Create.gml

@@ -0,0 +1,141 @@
+/*
+    Originally from /Source/gg2/Objects/Updater.events/Create.xml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+// Downloading code. 
+
+var downloadHandle, url, tmpfile, window_oldshowborder, window_oldfullscreen;
+timeLeft = 0;
+counter = 0;
+AudioControlPlaySong(-1, false);
+window_oldshowborder = window_get_showborder();
+window_oldfullscreen = window_get_fullscreen();
+window_set_fullscreen(false);
+window_set_showborder(false);
+
+if(global.updaterBetaChannel)
+    url = UPDATE_SOURCE_BETA;
+else
+    url = UPDATE_SOURCE;
+
+tmpfile = temp_directory + "\gg2update.zip";
+    
+downloadHandle = httpGet(url, -1);
+
+while(!httpRequestStatus(downloadHandle)) 
+{ // while download isn't finished
+    sleep(floor(1000/30)); // sleep for the equivalent of one frame
+    io_handle(); // this prevents GameMaker from appearing locked-up
+    httpRequestStep(downloadHandle);
+    
+    // check if the user cancelled the download with the esc key
+    if(keyboard_check(vk_escape)) 
+    {
+        httpRequestDestroy(downloadHandle);
+        window_set_showborder(window_oldshowborder);
+        window_set_fullscreen(window_oldfullscreen);
+        room_goto_fix(Menu);
+        exit;
+    }
+     
+    if(counter == 0 || counter mod 60 == 0)
+        timer = random(359)+1;
+    draw_sprite(UpdaterBackgroundS,0,0,0);
+    draw_set_color(c_white);
+    draw_set_halign(fa_left);
+    draw_set_valign(fa_center);
+    minutes=floor(timer/60);
+    seconds=floor(timer-minutes*60);
+    draw_text(x,y-20,string(minutes) + " minutes " + string(seconds) + " seconds Remaining...");
+    counter+=1;
+    var progress, size;
+    progress = httpRequestResponseBodyProgress(downloadHandle);
+    size = httpRequestResponseBodySize(downloadHandle);
+    if (size != -1)
+    {
+        progressBar = floor((progress/size) * 20);
+        offset = 3;
+        for(i=0;i<progressBar;i+=1){
+            draw_sprite(UpdaterProgressS,0,x+offset,y);
+            offset+=12;
+        }
+    }
+    screen_refresh();
+}
+// Errored
+if (httpRequestStatus(downloadHandle) == 2)
+{
+    show_message("Downloading update failed!#" + httpRequestError(downloadHandle));
+    httpRequestDestroy(downloadHandle);
+    window_set_showborder(window_oldshowborder);
+    window_set_fullscreen(window_oldfullscreen);
+    room_goto_fix(Menu);
+    exit;
+}
+// Request failed
+if (httpRequestStatusCode(downloadHandle) != 200)
+{
+    show_message("Downloading update failed!#" + string(httpRequestStatusCode(downloadHandle)) + " " + httpRequestReasonPhrase(downloadHandle));
+    httpRequestDestroy(downloadHandle);
+    window_set_showborder(window_oldshowborder);
+    window_set_fullscreen(window_oldfullscreen);
+    room_goto_fix(Menu);
+    exit;
+}
+
+write_buffer_to_file(httpRequestResponseBody(downloadHandle), tmpfile);
+httpRequestDestroy(downloadHandle);
+
+if(!file_exists(tmpfile))
+{
+    window_set_showborder(window_oldshowborder);
+    window_set_fullscreen(window_oldfullscreen);
+    show_message("Error updating: Missing gg2update.zip in temp directory, download failed(?)");
+    room_goto_fix(Menu);
+    exit;
+}
+
+// rename existing "Gang Garrison 2.exe" to avoid conflict when extracting
+if (file_exists("Gang Garrison 2.exe"))
+{
+    var newName, n;
+    n = 1;
+    
+    // increment until unused name found
+    do
+    {
+        newName = "gg2-old.delete.me." + string(n);
+        n += 1;
+    }
+    until(!file_exists(newName));
+
+    file_rename("Gang Garrison 2.exe", newName);
+}
+
+
+
+// let's extract the downloaded file now.
+extractzip(tmpfile, working_directory);
+
+// run new version    
+execute_program("Gang Garrison 2.exe", "", false);
+
+// exit
+game_end();

samples/Game Maker Language/Draw.gml

@@ -0,0 +1,161 @@
+/*
+    Originally from /Source/gg2/Objects/InGameElements/Character.events/Draw.xml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+xoffset = view_xview[0];
+yoffset = view_yview[0];
+xsize = view_wview[0];
+ysize = view_hview[0];
+
+if (distance_to_point(xoffset+xsize/2,yoffset+ysize/2) > 800)
+    exit;
+
+var xr, yr;
+xr = round(x);
+yr = round(y);
+    
+image_alpha = cloakAlpha;
+
+if (global.myself.team == team and canCloak)
+    image_alpha = cloakAlpha/2 + 0.5;
+
+if (invisible)
+    exit;
+
+if(stabbing)
+    image_alpha -= power(currentWeapon.stab.alpha, 2);
+
+if team == global.myself.team && (player != global.myself || global.showHealthBar == 1){
+    draw_set_alpha(1);
+    draw_healthbar(xr-10, yr-30, xr+10, yr-25,hp*100/maxHp,c_black,c_red,c_green,0,true,true);
+}    
+if(distance_to_point(mouse_x, mouse_y)<25) {
+    if cloak && team!=global.myself.team exit;
+    draw_set_alpha(1);
+    draw_set_halign(fa_center);
+    draw_set_valign(fa_bottom);
+    if(team==TEAM_RED) {
+        draw_set_color(c_red);
+    } else {
+        draw_set_color(c_blue);
+    }
+    draw_text(xr, yr-35, player.name);
+    
+    if(team == global.myself.team && global.showTeammateStats)
+    {
+        if(weapons[0] == Medigun)
+            draw_text(xr,yr+50, "Superburst: " + string(currentWeapon.uberCharge/20) + "%");
+        else if(weapons[0] == Shotgun)
+            draw_text(xr,yr+50, "Nuts 'N' Bolts: " + string(nutsNBolts));
+        else if(weapons[0] == Minegun)
+            draw_text(xr,yr+50, "Lobbed Mines: " + string(currentWeapon.lobbed));
+    }
+}  
+
+draw_set_alpha(1);
+if team == TEAM_RED ubercolour = c_red;
+if team == TEAM_BLUE ubercolour = c_blue;
+
+var sprite, overlaySprite;
+if zoomed
+{
+    if (team == TEAM_RED)
+        sprite = SniperCrouchRedS;
+    else
+        sprite = SniperCrouchBlueS;
+    overlaySprite = sniperCrouchOverlay;
+}
+else
+{
+    sprite = sprite_index;
+    overlaySprite = overlay;
+}
+    
+if (omnomnomnom)
+{
+    draw_sprite_ext_overlay(omnomnomnomSprite,omnomnomnomOverlay,omnomnomnomindex,xr,yr,image_xscale,image_yscale,image_angle,c_white,1);
+    if (ubered)
+        draw_sprite_ext_overlay(omnomnomnomSprite,omnomnomnomOverlay,omnomnomnomindex,xr,yr,image_xscale,image_yscale,image_angle,ubercolour,0.7);
+}
+else if (taunting)
+{
+    draw_sprite_ext_overlay(tauntsprite,tauntOverlay,tauntindex,xr,yr,image_xscale,image_yscale,image_angle,c_white,1);
+    if (ubered)
+        draw_sprite_ext_overlay(tauntsprite,tauntOverlay,tauntindex,xr,yr,image_xscale,image_yscale,image_angle,ubercolour,0.7);
+}
+else if (player.humiliated)
+    draw_sprite_ext(humiliationPoses,floor(animationImage)+humiliationOffset,xr,yr,image_xscale,image_yscale,image_angle,c_white,image_alpha);
+else if (!taunting)
+{
+    if (cloak)
+    {
+        if (!ubered)
+            draw_sprite_ext(sprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,c_white,image_alpha);
+        else if (ubered)
+        {
+            draw_sprite_ext(sprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,c_white,1);
+            draw_sprite_ext(sprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,ubercolour,0.7);
+        }
+    }
+    else
+    {
+        if (!ubered)
+            draw_sprite_ext_overlay(sprite,overlaySprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,c_white,image_alpha);
+        else if (ubered)
+        {
+            draw_sprite_ext_overlay(sprite,overlaySprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,c_white,1);
+            draw_sprite_ext_overlay(sprite,overlaySprite,floor(animationImage+animationOffset),xr,yr,image_xscale,image_yscale,image_angle,ubercolour,0.7);
+        }
+    }
+}
+if (burnDuration > 0 or burnIntensity > 0) {
+    for(i = 0; i < numFlames * burnIntensity / maxIntensity; i += 1)
+    {
+        draw_sprite_ext(FlameS, alarm[5] + i + random(2), x + flameArray_x[i], y + flameArray_y[i], 1, 1, 0, c_white, burnDuration / maxDuration * 0.71 + 0.35);
+    }  
+}
+
+// Copied from Lorgan's itemserver "angels" with slight modifications
+// All credit be upon him
+if (demon != -1)
+{
+    demonX = median(x-40,demonX,x+40);
+    demonY = median(y-40,demonY,y);
+    demonOffset += demonDir;
+    if (abs(demonOffset) > 15)
+        demonDir *= -1;
+
+    var dir;
+    if (demonX > x)
+        dir = -1;
+    else
+        dir = 1;
+
+    if (demonFrame > sprite_get_number(demon))
+        demonFrame = 0;
+
+    if (stabbing || ubered)
+        draw_sprite_ext(demon,demonFrame+floor(animationImage)+7*player.team,demonX,demonY+demonOffset,dir*1,1,0,c_white,1);
+    else
+        draw_sprite_ext(demon,demonFrame+floor(animationImage)+7*player.team,demonX,demonY+demonOffset,dir*1,1,0,c_white,image_alpha);
+
+    demonFrame += 1;
+}

samples/Game Maker Language/characterDrawEvent.gml

@@ -0,0 +1,80 @@
+// Originally from /spelunky/Scripts/Platform Engine/characterDrawEvent.gml in the Spelunky Community Update Project
+
+/**********************************************************************************
+    Copyright (c) 2008, 2009 Derek Yu and Mossmouth, LLC
+    
+    This file is part of Spelunky.
+
+    You can redistribute and/or modify Spelunky, including its source code, under
+    the terms of the Spelunky User License.
+
+    Spelunky is distributed in the hope that it will be entertaining and useful,
+    but WITHOUT WARRANTY. Please see the Spelunky User License for more details.
+
+    The Spelunky User License should be available in "Game Information", which
+    can be found in the Resource Explorer, or as an external file called COPYING.
+    If not, please obtain a new copy of Spelunky from <http://spelunkyworld.com/>
+    
+***********************************************************************************/
+
+/*
+This event should be placed in the draw event of the platform character.
+*/
+//draws the sprite
+draw = true;
+if (facing == RIGHT) image_xscale = -1;
+else image_xscale = 1;
+
+if (blinkToggle != 1)
+{
+    if ((state == CLIMBING or (sprite_index == sPExit or sprite_index == sDamselExit or sprite_index == sTunnelExit)) and global.hasJetpack and not whipping)
+    {
+        draw_sprite_ext(sprite_index, -1, x, y, image_xscale, image_yscale, image_angle, image_blend, image_alpha);
+        //draw_sprite(sprite_index,-1,x,y);
+        draw_sprite(sJetpackBack,-1,x,y);
+        draw = false;
+    }
+    else if (global.hasJetpack and facing == RIGHT) draw_sprite(sJetpackRight,-1,x-4,y-1);
+    else if (global.hasJetpack) draw_sprite(sJetpackLeft,-1,x+4,y-1);
+    if (draw)
+    {
+        if (redColor > 0) draw_sprite_ext(sprite_index, -1, x, y, image_xscale, image_yscale, image_angle, make_color_rgb(200 + redColor,0,0), image_alpha);
+        else draw_sprite_ext(sprite_index, -1, x, y, image_xscale, image_yscale, image_angle, image_blend, image_alpha);
+    }
+    if (facing == RIGHT)
+    {
+        if (holdArrow == ARROW_NORM)
+        {
+            draw_sprite(sArrowRight, -1, x+4, y+1);
+        }
+        else if (holdArrow == ARROW_BOMB)
+        {
+            if (holdArrowToggle) draw_sprite(sBombArrowRight, 0, x+4, y+2);
+            else draw_sprite(sBombArrowRight, 1, x+4, y+2);
+        }
+    }
+    else if (facing == LEFT)
+    {
+        if (holdArrow == ARROW_NORM)
+        {
+            draw_sprite(sArrowLeft, -1, x-4, y+1);
+        }
+        else if (holdArrow == ARROW_BOMB)
+        {
+            if (holdArrowToggle) draw_sprite(sBombArrowLeft, 0, x-4, y+2);
+            else draw_sprite(sBombArrowLeft, 1, x-4, y+2);
+        }
+    }
+}
+/*
+if canRun
+{
+  xOffset=80
+  if player=1
+    yOffset=120
+  else
+    yOffset=143
+  //draw the "flySpeed" bar, which shows how much speed the character has acquired while holding the "run" button
+  //draw_healthbar(view_xview[0]+224+xOffset,view_yview[0]+432+yOffset,view_xview[0]+400+xOffset,view_yview[0]+450+yOffset,flySpeed,make_color_rgb(0,64,128),c_blue,c_aqua,0,1,1)
+}
+*/

samples/Game Maker Language/doEventPlayerDeath.gml

@@ -0,0 +1,251 @@
+/*
+    Originally from /Source/gg2/Scripts/Events/doEventPlayerDeath.gml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+/**
+ * Perform the "player death" event, i.e. change the appropriate scores,
+ * destroy the character object to much splattering and so on.
+ *
+ * argument0: The player whose character died
+ * argument1: The player who inflicted the fatal damage (or noone for unknown)
+ * argument2: The player who assisted the kill (or noone for no assist)
+ * argument3: The source of the fatal damage
+ */
+var victim, killer, assistant, damageSource;
+victim = argument0;
+killer = argument1;
+assistant = argument2;
+damageSource = argument3;
+
+if(!instance_exists(killer))
+    killer = noone;
+
+if(!instance_exists(assistant))
+    assistant = noone;
+
+//*************************************
+//*      Scoring and Kill log
+//*************************************
+ 
+
+recordKillInLog(victim, killer, assistant, damageSource);
+
+victim.stats[DEATHS] += 1;
+if(killer)
+{
+    if(damageSource == WEAPON_KNIFE || damageSource == WEAPON_BACKSTAB)
+    {
+        killer.stats[STABS] += 1;
+        killer.roundStats[STABS] += 1;
+        killer.stats[POINTS] += 1;
+        killer.roundStats[POINTS] +=1;
+    }
+    
+    if (victim.object.currentWeapon.object_index == Medigun)
+    {
+        if (victim.object.currentWeapon.uberReady)
+        {
+            killer.stats[BONUS] += 1;
+            killer.roundStats[BONUS] += 1;
+            killer.stats[POINTS] += 1;
+            killer.roundStats[POINTS] += 1;
+        }
+    }
+        
+    if (killer != victim)
+    {
+        killer.stats[KILLS] += 1;
+        killer.roundStats[KILLS] += 1;
+        killer.stats[POINTS] += 1;
+        killer.roundStats[POINTS] += 1;
+        if(victim.object.intel)
+        {
+            killer.stats[DEFENSES] += 1;
+            killer.roundStats[DEFENSES] += 1;
+            killer.stats[POINTS] += 1;
+            killer.roundStats[POINTS] += 1;
+            recordEventInLog(4, killer.team, killer.name, global.myself == killer);
+        }
+    }
+}
+
+if (assistant)
+{
+    assistant.stats[ASSISTS] += 1;
+    assistant.roundStats[ASSISTS] += 1;
+    assistant.stats[POINTS] += .5;
+    assistant.roundStats[POINTS] += .5;
+}
+
+//SPEC
+if (victim == global.myself)
+    instance_create(victim.object.x, victim.object.y, Spectator);
+
+//*************************************
+//*         Gibbing
+//*************************************
+var xoffset, yoffset, xsize, ysize;
+
+xoffset = view_xview[0];
+yoffset = view_yview[0];
+xsize = view_wview[0];
+ysize = view_hview[0];
+
+randomize();
+with(victim.object) {
+    if((damageSource == WEAPON_ROCKETLAUNCHER 
+    or damageSource == WEAPON_MINEGUN or damageSource == FRAG_BOX 
+    or damageSource == WEAPON_REFLECTED_STICKY or damageSource == WEAPON_REFLECTED_ROCKET 
+    or damageSource == FINISHED_OFF_GIB or damageSource == GENERATOR_EXPLOSION) 
+    and (player.class != CLASS_QUOTE) and (global.gibLevel>1) 
+    and distance_to_point(xoffset+xsize/2,yoffset+ysize/2) < 900) {
+        if (hasReward(victim, 'PumpkinGibs'))
+        {
+            repeat(global.gibLevel * 2) {
+                createGib(x,y,PumpkinGib,hspeed,vspeed,random(145)-72, choose(0,1,1,2,2,3), false, true)
+            }
+        }
+        else
+        {
+            repeat(global.gibLevel) {
+                createGib(x,y,Gib,hspeed,vspeed,random(145)-72, 0, false)
+            }
+            switch(player.team)
+            {
+            case TEAM_BLUE :
+                repeat(global.gibLevel - 1) {
+                    createGib(x,y,BlueClump,hspeed,vspeed,random(145)-72, 0, false)
+                }
+                break;
+            case TEAM_RED :
+                repeat(global.gibLevel - 1) {
+                    createGib(x,y,RedClump,hspeed,vspeed,random(145)-72, 0, false)
+                }
+                break;
+            }
+        }
+
+        repeat(global.gibLevel * 14) {
+            var blood;
+            blood = instance_create(x+random(23)-11,y+random(23)-11,BloodDrop);
+            blood.hspeed=(random(21)-10);
+            blood.vspeed=(random(21)-13);
+            if (hasReward(victim, 'PumpkinGibs'))
+            {
+                blood.sprite_index = PumpkinJuiceS;
+            }
+        }
+        if (!hasReward(victim, 'PumpkinGibs'))
+        {
+            //All Classes gib head, hands, and feet
+            if(global.gibLevel > 2 || choose(0,1) == 1)
+                createGib(x,y,Headgib,0,0,random(105)-52, player.class, false);
+            repeat(global.gibLevel -1){
+                //Medic has specially colored hands
+                if (player.class == CLASS_MEDIC){
+                    if (player.team == TEAM_RED)
+                        createGib(x,y,Hand, hspeed, vspeed, random(105)-52 , 9, false);
+                    else
+                        createGib(x,y,Hand, hspeed, vspeed, random(105)-52 , 10, false);
+                }else{
+                    createGib(x,y,Hand, hspeed, vspeed, random(105)-52 , player.class, false);
+                }
+                createGib(x,y,Feet,random(5)-2,random(3),random(13)-6 , player.class, true);
+            }
+        }
+
+        //Class specific gibs
+        switch(player.class) {
+        case CLASS_PYRO :
+            if(global.gibLevel > 2 || choose(0,1) == 1)
+                createGib(x,y,Accesory,hspeed,vspeed,random(105)-52, 4, false)
+            break;
+        case CLASS_SOLDIER :
+            if(global.gibLevel > 2 || choose(0,1) == 1){
+                switch(player.team) {
+                    case TEAM_BLUE :
+                        createGib(x,y,Accesory,hspeed,vspeed,random(105)-52, 2, false);
+                        break;
+                    case TEAM_RED :
+                        createGib(x,y,Accesory,hspeed,vspeed,random(105)-52, 1, false);
+                        break;
+                    }
+            }
+            break;
+        case CLASS_ENGINEER :
+            if(global.gibLevel > 2 || choose(0,1) == 1)
+                createGib(x,y,Accesory,hspeed,vspeed,random(105)-52, 3, false)
+            break;
+        case CLASS_SNIPER :
+            if(global.gibLevel > 2 || choose(0,1) == 1)
+                createGib(x,y,Accesory,hspeed,vspeed,random(105)-52, 0, false)
+            break;
+        }
+        playsound(x,y,Gibbing);
+    } else {
+        var deadbody;
+        if player.class != CLASS_QUOTE playsound(x,y,choose(DeathSnd1, DeathSnd2));
+        deadbody = instance_create(x,y-30,DeadGuy);
+        // 'GS' reward - *G*olden *S*tatue
+        if(hasReward(player, 'GS'))
+        {
+            deadbody.sprite_index = haxxyStatue;
+            deadbody.image_index = 0;
+        }
+        else
+        { 
+            deadbody.sprite_index = sprite_index;
+            deadbody.image_index = CHARACTER_ANIMATION_DEAD;
+        }
+        deadbody.hspeed=hspeed;
+        deadbody.vspeed=vspeed;
+        if(hspeed>0) {
+            deadbody.image_xscale = -1;  
+        }
+    }
+}
+
+if (global.gg_birthday){
+    myHat = instance_create(victim.object.x,victim.object.y,PartyHat);
+    myHat.image_index = victim.team;
+}
+if (global.xmas){
+    myHat = instance_create(victim.object.x,victim.object.y,XmasHat);
+    myHat.image_index = victim.team;
+}
+
+
+with(victim.object) {       
+    instance_destroy();
+}
+
+//*************************************
+//*         Deathcam
+//*************************************
+if( global.killCam and victim == global.myself and killer and killer != victim and !(damageSource == KILL_BOX || damageSource == FRAG_BOX || damageSource == FINISHED_OFF || damageSource == FINISHED_OFF_GIB || damageSource == GENERATOR_EXPLOSION)) {
+    instance_create(0,0,DeathCam);
+    DeathCam.killedby=killer;
+    DeathCam.name=killer.name;
+    DeathCam.oldxview=view_xview[0];
+    DeathCam.oldyview=view_yview[0];
+    DeathCam.lastDamageSource=damageSource;
+    DeathCam.team = global.myself.team;
+}

samples/Game Maker Language/game_init.gml

@@ -0,0 +1,484 @@
+/*
+    Originally from /Source/gg2/Scripts/game_init.gml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+// Returns true if the game is successfully initialized, false if there was an error and we should quit.
+{
+    instance_create(0,0,RoomChangeObserver);
+    set_little_endian_global(true);
+    if file_exists("game_errors.log") file_delete("game_errors.log");
+    if file_exists("last_plugin.log") file_delete("last_plugin.log");
+    
+    // Delete old left-over files created by the updater
+    var backupFilename;
+    backupFilename = file_find_first("gg2-old.delete.me.*", 0);
+    while(backupFilename != "")
+    {
+        file_delete(backupFilename);
+        backupFilename = file_find_next();
+    }
+    file_find_close();
+    
+    var customMapRotationFile, restart;
+    restart = false;
+
+    //import wav files for music
+    global.MenuMusic=sound_add(choose("Music/menumusic1.wav","Music/menumusic2.wav","Music/menumusic3.wav","Music/menumusic4.wav","Music/menumusic5.wav","Music/menumusic6.wav"), 1, true);
+    global.IngameMusic=sound_add("Music/ingamemusic.wav", 1, true);
+    global.FaucetMusic=sound_add("Music/faucetmusic.wav", 1, true);
+    if(global.MenuMusic != -1)
+        sound_volume(global.MenuMusic, 0.8);
+    if(global.IngameMusic != -1)
+        sound_volume(global.IngameMusic, 0.8);
+    if(global.FaucetMusic != -1)
+        sound_volume(global.FaucetMusic, 0.8);
+        
+    global.sendBuffer = buffer_create();
+    global.tempBuffer = buffer_create();
+    global.HudCheck = false;
+    global.map_rotation = ds_list_create();
+    
+    global.CustomMapCollisionSprite = -1;
+    
+    window_set_region_scale(-1, false);
+    
+    ini_open("gg2.ini");
+    global.playerName = ini_read_string("Settings", "PlayerName", "Player");
+    if string_count("#",global.playerName) > 0 global.playerName = "Player";
+    global.playerName = string_copy(global.playerName, 0, min(string_length(global.playerName), MAX_PLAYERNAME_LENGTH));
+    global.fullscreen = ini_read_real("Settings", "Fullscreen", 0);
+    global.useLobbyServer = ini_read_real("Settings", "UseLobby", 1);
+    global.hostingPort = ini_read_real("Settings", "HostingPort", 8190);
+    global.music = ini_read_real("Settings", "Music", ini_read_real("Settings", "IngameMusic", MUSIC_BOTH));
+    global.playerLimit = ini_read_real("Settings", "PlayerLimit", 10);
+    //thy playerlimit shalt not exceed 48!
+    if (global.playerLimit > 48)
+    {
+        if (global.dedicatedMode != 1)
+            show_message("Warning: Player Limit cannot exceed 48. It has been set to 48");
+        global.playerLimit = 48;
+        ini_write_real("Settings", "PlayerLimit", 48);
+    }
+    global.multiClientLimit = ini_read_real("Settings", "MultiClientLimit", 3);
+    global.particles =  ini_read_real("Settings", "Particles", PARTICLES_NORMAL);
+    global.gibLevel = ini_read_real("Settings", "Gib Level", 3);
+    global.killCam = ini_read_real("Settings", "Kill Cam", 1);
+    global.monitorSync = ini_read_real("Settings", "Monitor Sync", 0);
+    if global.monitorSync == 1 set_synchronization(true);
+    else set_synchronization(false);
+    global.medicRadar = ini_read_real("Settings", "Healer Radar", 1);
+    global.showHealer = ini_read_real("Settings", "Show Healer", 1);
+    global.showHealing = ini_read_real("Settings", "Show Healing", 1);
+    global.showHealthBar = ini_read_real("Settings", "Show Healthbar", 0);
+    global.showTeammateStats = ini_read_real("Settings", "Show Extra Teammate Stats", 0);
+    global.serverPluginsPrompt = ini_read_real("Settings", "ServerPluginsPrompt", 1);
+    global.restartPrompt = ini_read_real("Settings", "RestartPrompt", 1);
+    //user HUD settings
+    global.timerPos=ini_read_real("Settings","Timer Position", 0)
+    global.killLogPos=ini_read_real("Settings","Kill Log Position", 0)
+    global.kothHudPos=ini_read_real("Settings","KoTH HUD Position", 0)
+    global.clientPassword = "";
+    // for admin menu
+    customMapRotationFile = ini_read_string("Server", "MapRotation", "");
+    global.shuffleRotation = ini_read_real("Server", "ShuffleRotation", 1);
+    global.timeLimitMins = max(1, min(255, ini_read_real("Server", "Time Limit", 15)));
+    global.serverPassword = ini_read_string("Server", "Password", "");
+    global.mapRotationFile = customMapRotationFile;
+    global.dedicatedMode = ini_read_real("Server", "Dedicated", 0);
+    global.serverName = ini_read_string("Server", "ServerName", "My Server");
+    global.welcomeMessage = ini_read_string("Server", "WelcomeMessage", "");
+    global.caplimit = max(1, min(255, ini_read_real("Server", "CapLimit", 5)));
+    global.caplimitBkup = global.caplimit;
+    global.autobalance = ini_read_real("Server", "AutoBalance",1);
+    global.Server_RespawntimeSec = ini_read_real("Server", "Respawn Time", 5);
+    global.rewardKey = unhex(ini_read_string("Haxxy", "RewardKey", ""));
+    global.rewardId = ini_read_string("Haxxy", "RewardId", "");
+    global.mapdownloadLimitBps = ini_read_real("Server", "Total bandwidth limit for map downloads in bytes per second", 50000);
+    global.updaterBetaChannel = ini_read_real("General", "UpdaterBetaChannel", isBetaVersion());
+    global.attemptPortForward = ini_read_real("Server", "Attempt UPnP Forwarding", 0); 
+    global.serverPluginList = ini_read_string("Server", "ServerPluginList", "");
+    global.serverPluginsRequired = ini_read_real("Server", "ServerPluginsRequired", 0);
+    if (string_length(global.serverPluginList) > 254) {
+        show_message("Error: Server plugin list cannot exceed 254 characters");
+        return false;
+    }
+    var CrosshairFilename, CrosshairRemoveBG;
+    CrosshairFilename = ini_read_string("Settings", "CrosshairFilename", "");
+    CrosshairRemoveBG = ini_read_real("Settings", "CrosshairRemoveBG", 1);
+    global.queueJumping = ini_read_real("Settings", "Queued Jumping", 0);
+
+    global.backgroundHash = ini_read_string("Background", "BackgroundHash", "default");
+    global.backgroundTitle = ini_read_string("Background", "BackgroundTitle", "");
+    global.backgroundURL = ini_read_string("Background", "BackgroundURL", "");
+    global.backgroundShowVersion = ini_read_real("Background", "BackgroundShowVersion", true);
+    
+    readClasslimitsFromIni();
+
+    global.currentMapArea=1;
+    global.totalMapAreas=1;
+    global.setupTimer=1800;
+    global.joinedServerName="";
+    global.serverPluginsInUse=false;
+    // Create plugin packet maps
+    global.pluginPacketBuffers = ds_map_create();
+    global.pluginPacketPlayers = ds_map_create();
+        
+    ini_write_string("Settings", "PlayerName", global.playerName);
+    ini_write_real("Settings", "Fullscreen", global.fullscreen);
+    ini_write_real("Settings", "UseLobby", global.useLobbyServer);
+    ini_write_real("Settings", "HostingPort", global.hostingPort);
+    ini_key_delete("Settings", "IngameMusic");
+    ini_write_real("Settings", "Music", global.music);
+    ini_write_real("Settings", "PlayerLimit", global.playerLimit);
+    ini_write_real("Settings", "MultiClientLimit", global.multiClientLimit);
+    ini_write_real("Settings", "Particles", global.particles);
+    ini_write_real("Settings", "Gib Level", global.gibLevel);
+    ini_write_real("Settings", "Kill Cam", global.killCam);
+    ini_write_real("Settings", "Monitor Sync", global.monitorSync);
+    ini_write_real("Settings", "Healer Radar", global.medicRadar);
+    ini_write_real("Settings", "Show Healer", global.showHealer);
+    ini_write_real("Settings", "Show Healing", global.showHealing);
+    ini_write_real("Settings", "Show Healthbar", global.showHealthBar);
+    ini_write_real("Settings", "Show Extra Teammate Stats", global.showTeammateStats);
+    ini_write_real("Settings", "Timer Position", global.timerPos);
+    ini_write_real("Settings", "Kill Log Position", global.killLogPos);
+    ini_write_real("Settings", "KoTH HUD Position", global.kothHudPos);
+    ini_write_real("Settings", "ServerPluginsPrompt", global.serverPluginsPrompt);
+    ini_write_real("Settings", "RestartPrompt", global.restartPrompt);
+    ini_write_string("Server", "MapRotation", customMapRotationFile);
+    ini_write_real("Server", "ShuffleRotation", global.shuffleRotation);
+    ini_write_real("Server", "Dedicated", global.dedicatedMode);
+    ini_write_string("Server", "ServerName", global.serverName);
+    ini_write_string("Server", "WelcomeMessage", global.welcomeMessage);
+    ini_write_real("Server", "CapLimit", global.caplimit);
+    ini_write_real("Server", "AutoBalance", global.autobalance);
+    ini_write_real("Server", "Respawn Time", global.Server_RespawntimeSec);
+    ini_write_real("Server", "Total bandwidth limit for map downloads in bytes per second", global.mapdownloadLimitBps);
+    ini_write_real("Server", "Time Limit", global.timeLimitMins);
+    ini_write_string("Server", "Password", global.serverPassword);
+    ini_write_real("General", "UpdaterBetaChannel", global.updaterBetaChannel);
+    ini_write_real("Server", "Attempt UPnP Forwarding", global.attemptPortForward); 
+    ini_write_string("Server", "ServerPluginList", global.serverPluginList); 
+    ini_write_real("Server", "ServerPluginsRequired", global.serverPluginsRequired); 
+    ini_write_string("Settings", "CrosshairFilename", CrosshairFilename);
+    ini_write_real("Settings", "CrosshairRemoveBG", CrosshairRemoveBG);
+    ini_write_real("Settings", "Queued Jumping", global.queueJumping);
+
+    ini_write_string("Background", "BackgroundHash", global.backgroundHash);
+    ini_write_string("Background", "BackgroundTitle", global.backgroundTitle);
+    ini_write_string("Background", "BackgroundURL", global.backgroundURL);
+    ini_write_real("Background", "BackgroundShowVersion", global.backgroundShowVersion);
+    
+    ini_write_real("Classlimits", "Scout", global.classlimits[CLASS_SCOUT])
+    ini_write_real("Classlimits", "Pyro", global.classlimits[CLASS_PYRO])
+    ini_write_real("Classlimits", "Soldier", global.classlimits[CLASS_SOLDIER])
+    ini_write_real("Classlimits", "Heavy", global.classlimits[CLASS_HEAVY])
+    ini_write_real("Classlimits", "Demoman", global.classlimits[CLASS_DEMOMAN])
+    ini_write_real("Classlimits", "Medic", global.classlimits[CLASS_MEDIC])
+    ini_write_real("Classlimits", "Engineer", global.classlimits[CLASS_ENGINEER])
+    ini_write_real("Classlimits", "Spy", global.classlimits[CLASS_SPY])
+    ini_write_real("Classlimits", "Sniper", global.classlimits[CLASS_SNIPER])
+    ini_write_real("Classlimits", "Quote", global.classlimits[CLASS_QUOTE])
+
+    //screw the 0 index we will start with 1
+    //map_truefort 
+    maps[1] = ini_read_real("Maps", "ctf_truefort", 1);
+    //map_2dfort 
+    maps[2] = ini_read_real("Maps", "ctf_2dfort", 2);
+    //map_conflict 
+    maps[3] = ini_read_real("Maps", "ctf_conflict", 3);
+    //map_classicwell 
+    maps[4] = ini_read_real("Maps", "ctf_classicwell", 4);
+    //map_waterway 
+    maps[5] = ini_read_real("Maps", "ctf_waterway", 5);
+    //map_orange 
+    maps[6] = ini_read_real("Maps", "ctf_orange", 6);
+    //map_dirtbowl
+    maps[7] = ini_read_real("Maps", "cp_dirtbowl", 7);
+    //map_egypt
+    maps[8] = ini_read_real("Maps", "cp_egypt", 8);
+    //arena_montane
+    maps[9] = ini_read_real("Maps", "arena_montane", 9);
+    //arena_lumberyard
+    maps[10] = ini_read_real("Maps", "arena_lumberyard", 10);
+    //gen_destroy
+    maps[11] = ini_read_real("Maps", "gen_destroy", 11);
+    //koth_valley
+    maps[12] = ini_read_real("Maps", "koth_valley", 12);
+    //koth_corinth
+    maps[13] = ini_read_real("Maps", "koth_corinth", 13);
+    //koth_harvest
+    maps[14] = ini_read_real("Maps", "koth_harvest", 14);
+    //dkoth_atalia
+    maps[15] = ini_read_real("Maps", "dkoth_atalia", 15);
+    //dkoth_sixties
+    maps[16] = ini_read_real("Maps", "dkoth_sixties", 16);
+    
+    //Server respawn time calculator. Converts each second to a frame. (read: multiply by 30 :hehe:)
+    if (global.Server_RespawntimeSec == 0)
+    {
+        global.Server_Respawntime = 1;
+    }    
+    else
+    {
+        global.Server_Respawntime = global.Server_RespawntimeSec * 30;    
+    }    
+    
+    // I have to include this, or the client'll complain about an unknown variable.
+    global.mapchanging = false;
+    
+    ini_write_real("Maps", "ctf_truefort", maps[1]);
+    ini_write_real("Maps", "ctf_2dfort", maps[2]);
+    ini_write_real("Maps", "ctf_conflict", maps[3]);
+    ini_write_real("Maps", "ctf_classicwell", maps[4]);
+    ini_write_real("Maps", "ctf_waterway", maps[5]);
+    ini_write_real("Maps", "ctf_orange", maps[6]);
+    ini_write_real("Maps", "cp_dirtbowl", maps[7]);
+    ini_write_real("Maps", "cp_egypt", maps[8]);
+    ini_write_real("Maps", "arena_montane", maps[9]);
+    ini_write_real("Maps", "arena_lumberyard", maps[10]);
+    ini_write_real("Maps", "gen_destroy", maps[11]);
+    ini_write_real("Maps", "koth_valley", maps[12]);
+    ini_write_real("Maps", "koth_corinth", maps[13]);
+    ini_write_real("Maps", "koth_harvest", maps[14]);
+    ini_write_real("Maps", "dkoth_atalia", maps[15]);
+    ini_write_real("Maps", "dkoth_sixties", maps[16]);
+
+    ini_close();
+    
+    // parse the protocol version UUID for later use
+    global.protocolUuid = buffer_create();
+    parseUuid(PROTOCOL_UUID, global.protocolUuid);
+
+    global.gg2lobbyId = buffer_create();
+    parseUuid(GG2_LOBBY_UUID, global.gg2lobbyId);
+
+    // Create abbreviations array for rewards use
+    initRewards()
+    
+var a, IPRaw, portRaw;
+doubleCheck=0;
+global.launchMap = "";
+
+    for(a = 1; a <= parameter_count(); a += 1) 
+    {
+        if (parameter_string(a) == "-dedicated")
+        {
+            global.dedicatedMode = 1;
+        }
+        else if (parameter_string(a) == "-restart")
+        {
+            restart = true;
+        }
+        else if (parameter_string(a) == "-server")
+        {
+            IPRaw = parameter_string(a+1);
+            if (doubleCheck == 1)
+            {
+                doubleCheck = 2;
+            }
+            else
+            {
+                doubleCheck = 1;
+            }
+        }
+        else if (parameter_string(a) == "-port")
+        {
+            portRaw = parameter_string(a+1);
+            if (doubleCheck == 1)
+            {
+                doubleCheck = 2;
+            }
+            else
+            {
+                doubleCheck = 1;
+            }
+        }
+        else if (parameter_string(a) == "-map")
+        {
+            global.launchMap = parameter_string(a+1);
+            global.dedicatedMode = 1;
+        }
+    }
+    
+    if (doubleCheck == 2)
+    {
+        global.serverPort = real(portRaw);
+        global.serverIP = IPRaw;
+        global.isHost = false;
+        instance_create(0,0,Client);
+    }   
+    
+    global.customMapdesginated = 0;    
+    
+    // if the user defined a valid map rotation file, then load from there
+
+    if(customMapRotationFile != "" && file_exists(customMapRotationFile) && global.launchMap == "") {
+        global.customMapdesginated = 1;
+        var fileHandle, i, mapname;
+        fileHandle = file_text_open_read(customMapRotationFile);
+        for(i = 1; !file_text_eof(fileHandle); i += 1) {
+            mapname = file_text_read_string(fileHandle);
+            // remove leading whitespace from the string
+            while(string_char_at(mapname, 0) == " " || string_char_at(mapname, 0) == chr(9)) { // while it starts with a space or tab
+              mapname = string_delete(mapname, 0, 1); // delete that space or tab
+            }
+            if(mapname != "" && string_char_at(mapname, 0) != "#") { // if it's not blank and it's not a comment (starting with #)
+                ds_list_add(global.map_rotation, mapname);
+            }
+            file_text_readln(fileHandle);
+        }
+        file_text_close(fileHandle);
+    }
+    
+     else if (global.launchMap != "") && (global.dedicatedMode == 1)
+        {  
+        ds_list_add(global.map_rotation, global.launchMap);
+        }
+    
+     else { // else load from the ini file Maps section
+        //Set up the map rotation stuff
+        var i, sort_list;
+        sort_list = ds_list_create();
+        for(i=1; i <= 16; i += 1) {
+            if(maps[i] != 0) ds_list_add(sort_list, ((100*maps[i])+i));
+        }
+        ds_list_sort(sort_list, 1);
+        
+        // translate the numbers back into the names they represent
+        for(i=0; i < ds_list_size(sort_list); i += 1) {
+            switch(ds_list_find_value(sort_list, i) mod 100) {
+                case 1:
+                    ds_list_add(global.map_rotation, "ctf_truefort");
+                break;
+                case 2:
+                    ds_list_add(global.map_rotation, "ctf_2dfort");
+                break;
+                case 3:
+                    ds_list_add(global.map_rotation, "ctf_conflict");
+                break;
+                case 4:
+                    ds_list_add(global.map_rotation, "ctf_classicwell");
+                break;
+                case 5:
+                    ds_list_add(global.map_rotation, "ctf_waterway");
+                break;
+                case 6:
+                    ds_list_add(global.map_rotation, "ctf_orange");
+                break;
+                case 7:
+                    ds_list_add(global.map_rotation, "cp_dirtbowl");
+                break;
+                case 8:
+                    ds_list_add(global.map_rotation, "cp_egypt");
+                break;
+                case 9:
+                    ds_list_add(global.map_rotation, "arena_montane");
+                break;
+                case 10:
+                    ds_list_add(global.map_rotation, "arena_lumberyard");
+                break;
+                case 11:
+                    ds_list_add(global.map_rotation, "gen_destroy");
+                break;
+                case 12:
+                    ds_list_add(global.map_rotation, "koth_valley");
+                break;
+                case 13:
+                    ds_list_add(global.map_rotation, "koth_corinth");
+                break;
+                case 14:
+                    ds_list_add(global.map_rotation, "koth_harvest");
+                break;
+                case 15:
+                    ds_list_add(global.map_rotation, "dkoth_atalia");
+                break;
+                case 16:
+                    ds_list_add(global.map_rotation, "dkoth_sixties");
+                break;
+                    
+            }
+        }
+        ds_list_destroy(sort_list);
+    }
+    
+    window_set_fullscreen(global.fullscreen);
+    
+    global.gg2Font = font_add_sprite(gg2FontS,ord("!"),false,0);
+    global.countFont = font_add_sprite(countFontS, ord("0"),false,2);
+    draw_set_font(global.gg2Font);
+    cursor_sprite = CrosshairS;
+    
+    if(!directory_exists(working_directory + "\Maps")) directory_create(working_directory + "\Maps");
+    
+    instance_create(0, 0, AudioControl);
+    instance_create(0, 0, SSControl);
+    
+    // custom dialog box graphics
+    message_background(popupBackgroundB);
+    message_button(popupButtonS);
+    message_text_font("Century",9,c_white,1);
+    message_button_font("Century",9,c_white,1);
+    message_input_font("Century",9,c_white,0);
+    
+    //Key Mapping
+    ini_open("controls.gg2");
+    global.jump = ini_read_real("Controls", "jump", ord("W"));
+    global.down = ini_read_real("Controls", "down", ord("S"));
+    global.left = ini_read_real("Controls", "left", ord("A"));
+    global.right = ini_read_real("Controls", "right", ord("D"));
+    global.attack = ini_read_real("Controls", "attack", MOUSE_LEFT);
+    global.special = ini_read_real("Controls", "special", MOUSE_RIGHT);
+    global.taunt = ini_read_real("Controls", "taunt", ord("F"));
+    global.chat1 = ini_read_real("Controls", "chat1", ord("Z"));
+    global.chat2 = ini_read_real("Controls", "chat2", ord("X"));
+    global.chat3 = ini_read_real("Controls", "chat3", ord("C"));
+    global.medic = ini_read_real("Controls", "medic", ord("E"));
+    global.drop = ini_read_real("Controls", "drop", ord("B"));
+    global.changeTeam = ini_read_real("Controls", "changeTeam", ord("N"));
+    global.changeClass = ini_read_real("Controls", "changeClass", ord("M"));
+    global.showScores = ini_read_real("Controls", "showScores", vk_shift);
+    ini_close();
+    
+    calculateMonthAndDay();
+
+    if(!directory_exists(working_directory + "\Plugins")) directory_create(working_directory + "\Plugins");
+    loadplugins();
+    
+    /* Windows 8 is known to crash GM when more than three (?) sounds play at once
+     * We'll store the kernel version (Win8 is 6.2, Win7 is 6.1) and check it there.
+     ***/
+    registry_set_root(1); // HKLM
+    global.NTKernelVersion = real(registry_read_string_ext("\SOFTWARE\Microsoft\Windows NT\CurrentVersion\", "CurrentVersion")); // SIC
+
+    if (file_exists(CrosshairFilename))
+    {
+        sprite_replace(CrosshairS,CrosshairFilename,1,CrosshairRemoveBG,false,0,0);
+        sprite_set_offset(CrosshairS,sprite_get_width(CrosshairS)/2,sprite_get_height(CrosshairS)/2);
+    }
+    if(global.dedicatedMode == 1) {
+        AudioControlToggleMute();
+        room_goto_fix(Menu);
+    } else if(restart) {
+        room_goto_fix(Menu);
+    }
+    return true;
+}

samples/Game Maker Language/loadserverplugins.gml

@@ -0,0 +1,252 @@
+/*
+    Originally from /Source/gg2/Scripts/Plugins/loadserverplugins.gml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+// loads plugins from ganggarrison.com asked for by server
+// argument0 - comma separated plugin list (pluginname@md5hash)
+// returns true on success, false on failure
+var list, hashList, text, i, pluginname, pluginhash, realhash, url, handle, filesize, progress, tempfile, tempdir, failed, lastContact, isCached;
+
+failed = false;
+list = ds_list_create();
+lastContact = 0;
+isCached = false;
+isDebug = false;
+hashList = ds_list_create();
+
+// split plugin list string
+list = split(argument0, ',');
+
+// Split hashes from plugin names
+for (i = 0; i < ds_list_size(list); i += 1)
+{
+    text = ds_list_find_value(list, i);
+    pluginname = string_copy(text, 0, string_pos("@", text) - 1);
+    pluginhash = string_copy(text, string_pos("@", text) + 1, string_length(text) - string_pos("@", text));
+    ds_list_replace(list, i, pluginname);
+    ds_list_add(hashList, pluginhash);
+}
+
+// Check plugin names and check for duplicates
+for (i = 0; i < ds_list_size(list); i += 1)
+{
+    pluginname = ds_list_find_value(list, i);
+    
+    // invalid plugin name
+    if (!checkpluginname(pluginname))
+    {
+        show_message('Error loading server-sent plugins - invalid plugin name:#"' + pluginname + '"');
+        return false;
+    }
+    // is duplicate
+    else if (ds_list_find_index(list, pluginname) != i)
+    {
+        show_message('Error loading server-sent plugins - duplicate plugin:#"' + pluginname + '"');
+        return false;
+    }
+}
+
+// Download plugins
+for (i = 0; i < ds_list_size(list); i += 1)
+{
+    pluginname = ds_list_find_value(list, i);
+    pluginhash = ds_list_find_value(hashList, i);
+    isDebug = file_exists(working_directory + "\ServerPluginsDebug\" + pluginname + ".zip");
+    isCached = file_exists(working_directory + "\ServerPluginsCache\" + pluginname + "@" + pluginhash);
+    tempfile = temp_directory + "\" + pluginname + ".zip.tmp";
+    tempdir = temp_directory + "\" + pluginname + ".tmp";
+
+    // check to see if we have a local copy for debugging
+    if (isDebug)
+    {
+        file_copy(working_directory + "\ServerPluginsDebug\" + pluginname + ".zip", tempfile);
+        // show warning
+        if (global.isHost)
+        {
+            show_message(
+                "Warning: server-sent plugin '"
+                + pluginname
+                + "' is being loaded from ServerPluginsDebug. Make sure clients have the same version, else they may be unable to connect."
+            );
+        }
+        else
+        {
+            show_message(
+                "Warning: server-sent plugin '"
+                + pluginname
+                + "' is being loaded from ServerPluginsDebug. Make sure the server has the same version, else you may be unable to connect."
+            );
+        }
+    }
+    // otherwise, check if we have it cached
+    else if (isCached)
+    {
+        file_copy(working_directory + "\ServerPluginsCache\" + pluginname + "@" + pluginhash, tempfile);
+    }
+    // otherwise, download as usual
+    else
+    {
+        // construct the URL
+        // http://www.ganggarrison.com/plugins/$PLUGINNAME$@$PLUGINHASH$.zip)
+        url = PLUGIN_SOURCE + pluginname + "@" + pluginhash + ".zip";
+        
+        // let's make the download handle
+        handle = httpGet(url, -1);
+        
+        // download it
+        while (!httpRequestStatus(handle)) {
+            // prevent game locking up
+            io_handle();
+
+            httpRequestStep(handle);
+            
+            if (!global.isHost) {
+                // send ping if we haven't contacted server in 20 seconds
+                // we need to do this to keep the connection open
+                if (current_time-lastContact > 20000) {
+                    write_byte(global.serverSocket, PING);
+                    socket_send(global.serverSocket);
+                    lastContact = current_time;
+                }
+            }
+
+            // draw progress bar since they may be waiting a while
+            filesize = httpRequestResponseBodySize(handle);
+            progress = httpRequestResponseBodyProgress(handle);
+            draw_background_ext(background_index[0], 0, 0, background_xscale[0], background_yscale[0], 0, c_white, 1);
+            draw_set_color(c_white);
+            draw_set_alpha(1);
+            draw_set_halign(fa_left);
+            draw_rectangle(50, 550, 300, 560, 2);
+            draw_text(50, 530, "Downloading server-sent plugin " + string(i + 1) + "/" + string(ds_list_size(list)) + ' - "' + pluginname + '"');
+            if (filesize != -1)
+                draw_rectangle(50, 550, 50 + progress / filesize * 250, 560, 0);
+            screen_refresh();
+        }
+
+        // errored
+        if (httpRequestStatus(handle) == 2)
+        {
+            show_message('Error loading server-sent plugins - download failed for "' + pluginname + '":#' + httpRequestError(handle));
+            failed = true;
+            break;
+        }
+
+        // request failed
+        if (httpRequestStatusCode(handle) != 200)
+        {
+            show_message('Error loading server-sent plugins - download failed for "' + pluginname + '":#' + string(httpRequestStatusCode(handle)) + ' ' + httpRequestReasonPhrase(handle));
+            failed = true;
+            break;
+        }
+        else
+        {
+            write_buffer_to_file(httpRequestResponseBody(handle), tempfile);
+            if (!file_exists(tempfile))
+            {
+                show_message('Error loading server-sent plugins - download failed for "' + pluginname + '":# No such file?');
+                failed = true;
+                break;
+            }
+        }
+
+        httpRequestDestroy(handle);
+    }
+
+    // check file integrity
+    realhash = GG2DLL_compute_MD5(tempfile);
+    if (realhash != pluginhash)
+    {
+        show_message('Error loading server-sent plugins - integrity check failed (MD5 hash mismatch) for:#"' + pluginname + '"');
+        failed = true;
+        break;
+    }
+    
+    // don't try to cache debug plugins
+    if (!isDebug)
+    {
+        // add to cache if we don't already have it
+        if (!file_exists(working_directory + "\ServerPluginsCache\" + pluginname + "@" + pluginhash))
+        {
+            // make sure directory exists
+            if (!directory_exists(working_directory + "\ServerPluginsCache"))
+            {
+                directory_create(working_directory + "\ServerPluginsCache");
+            }
+            // store in cache
+            file_copy(tempfile, working_directory + "\ServerPluginsCache\" + pluginname + "@" + pluginhash);
+        }
+    }
+
+    // let's get 7-zip to extract the files
+    extractzip(tempfile, tempdir);
+    
+    // if the directory doesn't exist, extracting presumably failed
+    if (!directory_exists(tempdir))
+    {
+        show_message('Error loading server-sent plugins - extracting zip failed for:#"' + pluginname + '"');
+        failed = true;
+        break;
+    }
+}
+
+if (!failed)
+{
+    // Execute plugins
+    for (i = 0; i < ds_list_size(list); i += 1)
+    {
+        pluginname = ds_list_find_value(list, i);
+        tempdir = temp_directory + "\" + pluginname + ".tmp";
+        
+        // Debugging facility, so we know *which* plugin caused compile/execute error
+        fp = file_text_open_write(working_directory + "\last_plugin.log");
+        file_text_write_string(fp, pluginname);
+        file_text_close(fp);
+
+        // packetID is (i), so make queues for it
+        ds_map_add(global.pluginPacketBuffers, i, ds_queue_create());
+        ds_map_add(global.pluginPacketPlayers, i, ds_queue_create());
+
+        // Execute plugin
+        execute_file(
+            // the plugin's main gml file must be in the root of the zip
+            // it is called plugin.gml
+            tempdir + "\plugin.gml",
+            // the plugin needs to know where it is
+            // so the temporary directory is passed as first argument
+            tempdir,
+            // the plugin needs to know its packetID
+            // so it is passed as the second argument
+            i
+        );
+    }
+}
+
+// Delete last plugin log
+file_delete(working_directory + "\last_plugin.log");
+
+// Get rid of plugin list
+ds_list_destroy(list);
+
+// Get rid of plugin hash list
+ds_list_destroy(hashList);
+
+return !failed;

samples/Game Maker Language/processClientCommands.gml

@@ -0,0 +1,384 @@
+/*
+    Originally from /Source/gg2/Scripts/GameServer/processClientCommands.gml in Gang Garrison 2
+
+    Copyright (C) 2008-2013 Faucet Software
+    http://www.ganggarrison.com
+
+    This program is free software; 
+    you can redistribute it and/or modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation; either version 3 of the License, or (at your option)
+    any later version.
+    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+    without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+    See the GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License along with this program; if not,
+    see <http://www.gnu.org/licenses>.
+
+    Additional permission under GNU GPL version 3 section 7
+    If you modify this Program, or any covered work, by linking or combining it with the Game Maker runtime library, 
+    the 39dll library/extension, Hobbel's Download Manager DLL, or modified versions of these libraries,
+    the licensors of this Program grant you additional permission to convey the resulting work.
+*/
+
+var player, playerId, commandLimitRemaining;
+
+player = argument0;
+playerId = argument1;
+
+// To prevent players from flooding the server, limit the number of commands to process per step and player.
+commandLimitRemaining = 10;
+
+with(player) {
+    if(!variable_local_exists("commandReceiveState")) {
+        // 0: waiting for command byte.
+        // 1: waiting for command data length (1 byte)
+        // 2: waiting for command data.
+        commandReceiveState = 0;
+        commandReceiveExpectedBytes = 1;
+        commandReceiveCommand = 0;
+    }
+}
+
+while(commandLimitRemaining > 0) {
+    var socket;
+    socket = player.socket;
+    if(!tcp_receive(socket, player.commandReceiveExpectedBytes)) {
+        return 0;
+    }
+    
+    switch(player.commandReceiveState)
+    {
+    case 0:
+        player.commandReceiveCommand = read_ubyte(socket);
+        switch(commandBytes[player.commandReceiveCommand]) {
+        case commandBytesInvalidCommand:
+            // Invalid byte received. Wait for another command byte.
+            break;
+            
+        case commandBytesPrefixLength1:
+            player.commandReceiveState = 1;
+            player.commandReceiveExpectedBytes = 1;
+            break;
+
+        case commandBytesPrefixLength2:
+            player.commandReceiveState = 3;
+            player.commandReceiveExpectedBytes = 2;
+            break;
+
+        default:
+            player.commandReceiveState = 2;
+            player.commandReceiveExpectedBytes = commandBytes[player.commandReceiveCommand];
+            break;
+        }
+        break;
+        
+    case 1:
+        player.commandReceiveState = 2;
+        player.commandReceiveExpectedBytes = read_ubyte(socket);
+        break;
+
+    case 3:
+        player.commandReceiveState = 2;
+        player.commandReceiveExpectedBytes = read_ushort(socket);
+        break;
+        
+    case 2:
+        player.commandReceiveState = 0;
+        player.commandReceiveExpectedBytes = 1;
+        commandLimitRemaining -= 1;
+        
+        switch(player.commandReceiveCommand)
+        {
+        case PLAYER_LEAVE:
+            socket_destroy(player.socket);
+            player.socket = -1;
+            break;
+            
+        case PLAYER_CHANGECLASS:
+            var class;
+            class = read_ubyte(socket);
+            if(getCharacterObject(player.team, class) != -1)
+            {
+                if(player.object != -1)
+                {
+                    with(player.object)
+                    {
+                        if (collision_point(x,y,SpawnRoom,0,0) < 0)
+                        {
+                            if (!instance_exists(lastDamageDealer) || lastDamageDealer == player)
+                            {
+                                sendEventPlayerDeath(player, player, noone, BID_FAREWELL);
+                                doEventPlayerDeath(player, player, noone, BID_FAREWELL);
+                            }
+                            else
+                            {
+                                var assistant;
+                                assistant = secondToLastDamageDealer;
+                                if (lastDamageDealer.object)
+                                    if (lastDamageDealer.object.healer)
+                                        assistant = lastDamageDealer.object.healer;
+                                sendEventPlayerDeath(player, lastDamageDealer, assistant, FINISHED_OFF);
+                                doEventPlayerDeath(player, lastDamageDealer, assistant, FINISHED_OFF);
+                            }
+                        }
+                        else 
+                        instance_destroy(); 
+                        
+                    }
+                }
+                else if(player.alarm[5]<=0)
+                    player.alarm[5] = 1;
+                class = checkClasslimits(player, player.team, class);
+                player.class = class;
+                ServerPlayerChangeclass(playerId, player.class, global.sendBuffer);
+            }
+            break;
+            
+        case PLAYER_CHANGETEAM:
+            var newTeam, balance, redSuperiority;
+            newTeam = read_ubyte(socket);
+            
+            redSuperiority = 0   //calculate which team is bigger
+            with(Player)
+            {
+                if(team == TEAM_RED)
+                    redSuperiority += 1;
+                else if(team == TEAM_BLUE)
+                    redSuperiority -= 1;
+            }
+            if(redSuperiority > 0)
+                balance = TEAM_RED;
+            else if(redSuperiority < 0)
+                balance = TEAM_BLUE;
+            else
+                balance = -1;
+            
+            if(balance != newTeam)
+            {
+                if(getCharacterObject(newTeam, player.class) != -1 or newTeam==TEAM_SPECTATOR)
+                {  
+                    if(player.object != -1)
+                    {
+                        with(player.object)
+                        {
+                            if (!instance_exists(lastDamageDealer) || lastDamageDealer == player)
+                            {
+                                sendEventPlayerDeath(player, player, noone, BID_FAREWELL);
+                                doEventPlayerDeath(player, player, noone, BID_FAREWELL);
+                            }
+                            else
+                            {
+                                var assistant;
+                                assistant = secondToLastDamageDealer;
+                                if (lastDamageDealer.object)
+                                    if (lastDamageDealer.object.healer)
+                                        assistant = lastDamageDealer.object.healer;
+                                sendEventPlayerDeath(player, lastDamageDealer, assistant, FINISHED_OFF);
+                                doEventPlayerDeath(player, lastDamageDealer, assistant, FINISHED_OFF);
+                            }
+                        }
+                        player.alarm[5] = global.Server_Respawntime;
+                    }
+                    else if(player.alarm[5]<=0)
+                        player.alarm[5] = 1;                    
+                    var newClass;
+                    newClass = checkClasslimits(player, newTeam, player.class);
+                    if newClass != player.class
+                    {
+                        player.class = newClass;
+                        ServerPlayerChangeclass(playerId, player.class, global.sendBuffer);
+                    }
+                    player.team = newTeam;
+                    ServerPlayerChangeteam(playerId, player.team, global.sendBuffer);
+                    ServerBalanceTeams();
+                }
+            }
+            break;                   
+            
+        case CHAT_BUBBLE:
+            var bubbleImage;
+            bubbleImage = read_ubyte(socket);
+            if(global.aFirst) {
+                bubbleImage = 0;
+            }
+            write_ubyte(global.sendBuffer, CHAT_BUBBLE);
+            write_ubyte(global.sendBuffer, playerId);
+            write_ubyte(global.sendBuffer, bubbleImage);
+            
+            setChatBubble(player, bubbleImage);
+            break;
+            
+        case BUILD_SENTRY:
+            if(player.object != -1)
+            {
+                if(player.class == CLASS_ENGINEER
+                        and collision_circle(player.object.x, player.object.y, 50, Sentry, false, true) < 0
+                        and player.object.nutsNBolts == 100
+                        and (collision_point(player.object.x,player.object.y,SpawnRoom,0,0) < 0)
+                        and !player.sentry
+                        and !player.object.onCabinet)
+                {
+                    write_ubyte(global.sendBuffer, BUILD_SENTRY);
+                    write_ubyte(global.sendBuffer, playerId);
+                    write_ushort(global.serializeBuffer, round(player.object.x*5));
+                    write_ushort(global.serializeBuffer, round(player.object.y*5));
+                    write_byte(global.serializeBuffer, player.object.image_xscale);
+                    buildSentry(player, player.object.x, player.object.y, player.object.image_xscale);
+                }
+            }
+            break;                                       
+
+        case DESTROY_SENTRY:
+            with(player.sentry)
+                instance_destroy();
+            break;                     
+        
+        case DROP_INTEL:
+            if (player.object != -1)
+            {
+                if (player.object.intel)
+                {
+                    sendEventDropIntel(player);
+                    doEventDropIntel(player);
+                }
+            }
+            break;     
+              
+        case OMNOMNOMNOM:
+            if(player.object != -1) {
+                if(!player.humiliated
+                    and !player.object.taunting
+                    and !player.object.omnomnomnom
+                    and player.object.canEat
+                    and player.class==CLASS_HEAVY)
+                {                            
+                    write_ubyte(global.sendBuffer, OMNOMNOMNOM);
+                    write_ubyte(global.sendBuffer, playerId);
+                    with(player.object)
+                    {
+                        omnomnomnom = true;
+                        if player.team == TEAM_RED {
+                            omnomnomnomindex=0;
+                            omnomnomnomend=31;
+                        } else if player.team==TEAM_BLUE {
+                            omnomnomnomindex=32;
+                            omnomnomnomend=63;
+                        } 
+                        xscale=image_xscale;
+                    }             
+                }
+            }
+            break;
+             
+        case TOGGLE_ZOOM:
+            if player.object != -1 {
+                if player.class == CLASS_SNIPER {
+                    write_ubyte(global.sendBuffer, TOGGLE_ZOOM);
+                    write_ubyte(global.sendBuffer, playerId);
+                    toggleZoom(player.object);
+                }
+            }
+            break;
+                                                      
+        case PLAYER_CHANGENAME:
+            var nameLength;
+            nameLength = socket_receivebuffer_size(socket);
+            if(nameLength > MAX_PLAYERNAME_LENGTH)
+            {
+                write_ubyte(player.socket, KICK);
+                write_ubyte(player.socket, KICK_NAME);
+                socket_destroy(player.socket);
+                player.socket = -1;
+            }
+            else
+            {
+                with(player)
+                {
+                    if(variable_local_exists("lastNamechange")) 
+                        if(current_time - lastNamechange < 1000)
+                            break;
+                    lastNamechange = current_time;
+                    name = read_string(socket, nameLength);
+                    if(string_count("#",name) > 0)
+                    {
+                        name = "I <3 Bacon";
+                    }
+                    write_ubyte(global.sendBuffer, PLAYER_CHANGENAME);
+                    write_ubyte(global.sendBuffer, playerId);
+                    write_ubyte(global.sendBuffer, string_length(name));
+                    write_string(global.sendBuffer, name);
+                }
+            }
+            break;
+            
+        case INPUTSTATE:
+            if(player.object != -1)
+            {
+                with(player.object)
+                {
+                    keyState = read_ubyte(socket);
+                    netAimDirection = read_ushort(socket);
+                    aimDirection = netAimDirection*360/65536;
+                    event_user(1);
+                }
+            }
+            break;
+        
+        case REWARD_REQUEST:
+            player.rewardId = read_string(socket, socket_receivebuffer_size(socket));
+            player.challenge = rewardCreateChallenge();
+            
+            write_ubyte(socket, REWARD_CHALLENGE_CODE);
+            write_binstring(socket, player.challenge);
+            break;
+            
+        case REWARD_CHALLENGE_RESPONSE:
+            var answer, i, authbuffer;
+            answer = read_binstring(socket, 16);
+            
+            with(player)
+                if(variable_local_exists("challenge") and variable_local_exists("rewardId"))
+                    rewardAuthStart(player, answer, challenge, true, rewardId);
+           
+            break;
+
+        case PLUGIN_PACKET:
+            var packetID, buf, success;
+
+            packetID = read_ubyte(socket);
+            
+            // get packet data
+            buf = buffer_create();
+            write_buffer_part(buf, socket, socket_receivebuffer_size(socket));
+
+            // try to enqueue
+            success = _PluginPacketPush(packetID, buf, player);
+            
+            // if it returned false, packetID was invalid
+            if (!success)
+            {
+                // clear up buffer
+                buffer_destroy(buf);
+
+                // kick player
+                write_ubyte(player.socket, KICK);
+                write_ubyte(player.socket, KICK_BAD_PLUGIN_PACKET);
+                socket_destroy(player.socket);
+                player.socket = -1;
+            }
+            break;
+            
+        case CLIENT_SETTINGS:
+            var mirror;
+            mirror = read_ubyte(player.socket);
+            player.queueJump = mirror;
+            
+            write_ubyte(global.sendBuffer, CLIENT_SETTINGS);
+            write_ubyte(global.sendBuffer, playerId);
+            write_ubyte(global.sendBuffer, mirror);
+            break;
+        
+        }
+        break;
+    } 
+}

samples/Game Maker Language/scrInitLevel.gml

@@ -0,0 +1,298 @@
+// Originally from /spelunky/Scripts/Level Generation/scrInitLevel.gml in the Spelunky Community Update Project
+
+//
+// scrInitLevel()
+//
+// Calls scrLevelGen(), scrRoomGen*(), and scrEntityGen() to build level.
+//
+
+/**********************************************************************************
+    Copyright (c) 2008, 2009 Derek Yu and Mossmouth, LLC
+    
+    This file is part of Spelunky.
+
+    You can redistribute and/or modify Spelunky, including its source code, under
+    the terms of the Spelunky User License.
+
+    Spelunky is distributed in the hope that it will be entertaining and useful,
+    but WITHOUT WARRANTY.  Please see the Spelunky User License for more details.
+
+    The Spelunky User License should be available in "Game Information", which
+    can be found in the Resource Explorer, or as an external file called COPYING.
+    If not, please obtain a new copy of Spelunky from <http://spelunkyworld.com/>
+    
+***********************************************************************************/
+
+global.levelType = 0;
+//global.currLevel = 16;
+if (global.currLevel > 4 and global.currLevel < 9) global.levelType = 1;
+if (global.currLevel > 8 and global.currLevel < 13) global.levelType = 2;
+if (global.currLevel > 12 and global.currLevel < 16) global.levelType = 3;
+if (global.currLevel == 16) global.levelType = 4;
+
+if (global.currLevel <= 1 or
+    global.currLevel == 5 or
+    global.currLevel == 9 or
+    global.currLevel == 13)
+{
+    global.hadDarkLevel = false;
+}
+
+// global.levelType = 3; // debug
+
+// DEBUG MODE //
+/*
+if (global.currLevel == 2) global.levelType = 4;
+if (global.currLevel == 3) global.levelType = 2;
+if (global.currLevel == 4) global.levelType = 3;
+if (global.currLevel == 5) global.levelType = 4;
+*/
+
+// global.levelType = 0;
+
+global.startRoomX = 0;
+global.startRoomY = 0;
+global.endRoomX = 0;
+global.endRoomY = 0;
+oGame.levelGen = false;
+
+// this is used to determine the path to the exit (generally no bombs required)
+for (i = 0; i < 4; i += 1)
+{
+    for (j = 0; j < 4; j += 1)
+    {
+        global.roomPath[i,j] = 0;
+    }
+}
+
+// side walls
+if (global.levelType == 4)
+    k = 54;
+else if (global.levelType == 2)
+    k = 38;
+else if (global.lake)
+    k = 41;
+else
+    k = 33;
+for (i = 0; i <= 42; i += 1)
+{
+    for (j = 0; j <= k; j += 1)
+    {
+        if (not isLevel())
+        {
+            i = 999;
+            j = 999;
+        }
+        else if (global.levelType == 2)
+        {
+            if (i*16 == 0 or
+                i*16 == 656 or
+                j*16 == 0)
+            {
+                obj = instance_create(i*16, j*16, oDark);
+                obj.invincible = true;
+                obj.sprite_index = sDark;
+            }
+        }
+        else if (global.levelType == 4)
+        {
+            if (i*16 == 0 or
+                i*16 == 656 or
+                j*16 == 0)
+            {
+                obj = instance_create(i*16, j*16, oTemple);
+                obj.invincible = true;
+                if (not global.cityOfGold) obj.sprite_index = sTemple;
+            }
+        }
+        else if (global.lake)
+        {
+            if (i*16 == 0 or
+                i*16 == 656 or
+                j*16 == 0 or
+                j*16 >= 656)
+            {
+                obj = instance_create(i*16, j*16, oLush); obj.sprite_index = sLush;
+                obj.invincible = true;
+            }
+        }
+        else if (i*16 == 0 or
+            i*16 == 656 or
+            j*16 == 0 or
+            j*16 >= 528)
+        {
+            if (global.levelType == 0) { obj = instance_create(i*16, j*16, oBrick); obj.sprite_index = sBrick; }
+            else if (global.levelType == 1) { obj = instance_create(i*16, j*16, oLush); obj.sprite_index = sLush; }
+            else { obj = instance_create(i*16, j*16, oTemple); if (not global.cityOfGold) obj.sprite_index = sTemple; }
+            obj.invincible = true;
+        }
+    }
+}
+
+if (global.levelType == 2)
+{
+    for (i = 0; i <= 42; i += 1)
+    {
+        instance_create(i*16, 40*16, oDark);
+        //instance_create(i*16, 35*16, oSpikes);
+    }
+}
+
+if (global.levelType == 3)
+{
+    background_index = bgTemple;
+}
+
+global.temp1 = global.gameStart;
+scrLevelGen();
+
+global.cemetary = false;
+if (global.levelType == 1 and rand(1,global.probCemetary) == 1) global.cemetary = true;
+
+with oRoom
+{
+    if (global.levelType == 0) scrRoomGen();
+    else if (global.levelType == 1)
+    {
+        if (global.blackMarket) scrRoomGenMarket();
+        else scrRoomGen2();
+    }
+    else if (global.levelType == 2)
+    {
+        if (global.yetiLair) scrRoomGenYeti();
+        else scrRoomGen3();
+    }
+    else if (global.levelType == 3) scrRoomGen4();
+    else scrRoomGen5();
+}
+
+global.darkLevel = false;
+//if (not global.hadDarkLevel and global.currLevel != 0 and global.levelType != 2 and global.currLevel != 16 and rand(1,1) == 1)
+if (not global.hadDarkLevel and not global.noDarkLevel and global.currLevel != 0 and global.currLevel != 1 and global.levelType != 2 and global.currLevel != 16 and rand(1,global.probDarkLevel) == 1)
+{
+    global.darkLevel = true;
+    global.hadDarkLevel = true;
+    //instance_create(oPlayer1.x, oPlayer1.y, oFlare);
+}
+
+if (global.blackMarket) global.darkLevel = false;
+
+global.genUdjatEye = false;
+if (not global.madeUdjatEye)
+{
+    if (global.currLevel == 2 and rand(1,3) == 1) global.genUdjatEye = true;
+    else if (global.currLevel == 3 and rand(1,2) == 1) global.genUdjatEye = true;
+    else if (global.currLevel == 4) global.genUdjatEye = true;
+}
+
+global.genMarketEntrance = false;
+if (not global.madeMarketEntrance)
+{
+    if (global.currLevel == 5 and rand(1,3) == 1) global.genMarketEntrance = true;
+    else if (global.currLevel == 6 and rand(1,2) == 1) global.genMarketEntrance = true;
+    else if (global.currLevel == 7) global.genMarketEntrance = true;
+}
+
+////////////////////////////
+// ENTITY / TREASURES
+////////////////////////////
+global.temp2 = global.gameStart;
+if (not isRoom("rTutorial") and not isRoom("rLoadLevel")) scrEntityGen();
+
+if (instance_exists(oEntrance) and not global.customLevel)
+{
+    oPlayer1.x = oEntrance.x+8;
+    oPlayer1.y = oEntrance.y+8;
+}
+
+if (global.darkLevel or
+    global.blackMarket or
+    global.snakePit or
+    global.cemetary or
+    global.lake or
+    global.yetiLair or
+    global.alienCraft or
+    global.sacrificePit or
+    global.cityOfGold)
+{
+    if (not isRoom("rLoadLevel"))
+    {
+        with oPlayer1 { alarm[0] = 10; }
+    }
+}
+
+if (global.levelType == 4) scrSetupWalls(864);
+else if (global.lake) scrSetupWalls(656);
+else scrSetupWalls(528);
+
+// add background details
+if (global.graphicsHigh)
+{
+    repeat(20)
+    {
+        // bg = instance_create(16*rand(1,42), 16*rand(1,33), oCaveBG);
+        if (global.levelType == 1 and rand(1,3) < 3)
+            tile_add(bgExtrasLush, 32*rand(0,1), 0, 32, 32, 16*rand(1,42), 16*rand(1,33), 10002);
+        else if (global.levelType == 2 and rand(1,3) < 3)
+            tile_add(bgExtrasIce, 32*rand(0,1), 0, 32, 32, 16*rand(1,42), 16*rand(1,33), 10002);
+        else if (global.levelType == 3 and rand(1,3) < 3)
+            tile_add(bgExtrasTemple, 32*rand(0,1), 0, 32, 32, 16*rand(1,42), 16*rand(1,33), 10002);
+        else
+            tile_add(bgExtras, 32*rand(0,1), 0, 32, 32, 16*rand(1,42), 16*rand(1,33), 10002);
+    }
+}
+
+oGame.levelGen = true;
+
+// generate angry shopkeeper at exit if murderer or thief
+if ((global.murderer or global.thiefLevel > 0) and isRealLevel())
+{
+    with oExit
+    {
+        if (type == "Exit")
+        {
+            obj = instance_create(x, y, oShopkeeper);
+            obj.status = 4;
+        }
+    }
+    // global.thiefLevel -= 1;
+}
+
+with oTreasure
+{
+    if (collision_point(x, y, oSolid, 0, 0))
+    {
+        obj = instance_place(x, y, oSolid);
+        if (obj.invincible) instance_destroy();
+    }
+}
+
+with oWater
+{
+    if (sprite_index == sWaterTop or sprite_index == sLavaTop)
+    {
+        scrCheckWaterTop();
+    }
+    /*
+        obj = instance_place(x-16, y, oWater);
+        if (instance_exists(obj))
+        {
+            if (obj.sprite_index == sWaterTop or obj.sprite_index == sLavaTop)
+            {
+                if (type == "Lava") sprite_index = sLavaTop;
+                else sprite_index = sWaterTop;
+            }
+        }
+        obj = instance_place(x+16, y, oWater);
+        if (instance_exists(obj))
+        {
+            if (obj.sprite_index == sWaterTop or obj.sprite_index == sLavaTop)
+            {
+                if (type == "Lava") sprite_index = sLavaTop;
+                else sprite_index = sWaterTop;
+            }
+        }
+    */
+}
+
+global.temp3 = global.gameStart;

samples/Gnuplot/dashcolor.1.gnu

@@ -0,0 +1,22 @@
+# set terminal pngcairo  background "#ffffff" fontscale 1.0 dashed size 640, 480 
+# set output 'dashcolor.1.png'
+set label 1 "set style line 1 lt 2 lc rgb \"red\" lw 3" at -0.4, -0.25, 0 left norotate back textcolor rgb "red"  nopoint offset character 0, 0, 0
+set label 2 "set style line 2 lt 2 lc rgb \"orange\" lw 2" at -0.4, -0.35, 0 left norotate back textcolor rgb "orange"  nopoint offset character 0, 0, 0
+set label 3 "set style line 3 lt 2 lc rgb \"yellow\" lw 3" at -0.4, -0.45, 0 left norotate back textcolor rgb "yellow"  nopoint offset character 0, 0, 0
+set label 4 "set style line 4 lt 2 lc rgb \"green\" lw 2" at -0.4, -0.55, 0 left norotate back textcolor rgb "green"  nopoint offset character 0, 0, 0
+set label 5 "plot ... lt 1 lc 3 " at -0.4, -0.65, 0 left norotate back textcolor lt 3 nopoint offset character 0, 0, 0
+set label 6 "plot ... lt 3 lc 3 " at -0.4, -0.75, 0 left norotate back textcolor lt 3 nopoint offset character 0, 0, 0
+set label 7 "plot ... lt 5 lc 3 " at -0.4, -0.85, 0 left norotate back textcolor lt 3 nopoint offset character 0, 0, 0
+set style line 1  linetype 2 linecolor rgb "red"  linewidth 3.000 pointtype 2 pointsize default pointinterval 0
+set style line 2  linetype 2 linecolor rgb "orange"  linewidth 2.000 pointtype 2 pointsize default pointinterval 0
+set style line 3  linetype 2 linecolor rgb "yellow"  linewidth 3.000 pointtype 2 pointsize default pointinterval 0
+set style line 4  linetype 2 linecolor rgb "green"  linewidth 2.000 pointtype 2 pointsize default pointinterval 0
+set noxtics
+set noytics
+set title "Independent colors and dot/dash styles" 
+set xlabel "You will only see dashed lines if your current terminal setting permits it" 
+set xrange [ -0.500000 : 3.50000 ] noreverse nowriteback
+set yrange [ -1.00000 : 1.40000 ] noreverse nowriteback
+set bmargin  7
+unset colorbox
+plot cos(x)     ls 1 title 'ls 1',        cos(x-.2)  ls 2 title 'ls 2',     cos(x-.4)  ls 3 title 'ls 3',     cos(x-.6)  ls 4 title 'ls 4',      cos(x-.8)  lt 1 lc 3 title 'lt 1 lc 3',       cos(x-1.)  lt 3 lc 3 title 'lt 3 lc 3',       cos(x-1.2) lt 5 lc 3 title 'lt 5 lc 3'

samples/Gnuplot/histograms.2.gnu

@@ -0,0 +1,15 @@
+# set terminal pngcairo  transparent enhanced font "arial,10" fontscale 1.0 size 500, 350 
+# set output 'histograms.2.png'
+set boxwidth 0.9 absolute
+set style fill   solid 1.00 border lt -1
+set key inside right top vertical Right noreverse noenhanced autotitles nobox
+set style histogram clustered gap 1 title  offset character 0, 0, 0
+set datafile missing '-'
+set style data histograms
+set xtics border in scale 0,0 nomirror rotate by -45  offset character 0, 0, 0 autojustify
+set xtics  norangelimit font ",8"
+set xtics   ()
+set title "US immigration from Northern Europe\nPlot selected data columns as histogram of clustered boxes" 
+set yrange [ 0.00000 : 300000. ] noreverse nowriteback
+i = 22
+plot 'immigration.dat' using 6:xtic(1) ti col, '' u 12 ti col, '' u 13 ti col, '' u 14 ti col

samples/Gnuplot/rates.gp

@@ -0,0 +1,14 @@
+#!/usr/bin/env gnuplot
+
+reset
+
+set terminal png
+set output 'rates100.png'
+
+set xlabel "A2A price"
+set ylabel "Response Rate"
+
+#set xr [0:5]
+#set yr [0:6]
+
+plot 'rates100.dat' pt 7 notitle

samples/Gnuplot/surface1.16.gnu

@@ -0,0 +1,40 @@
+# set terminal pngcairo  transparent enhanced font "arial,10" fontscale 1.0 size 500, 350 
+# set output 'surface1.16.png'
+set dummy u,v
+set label 1 "increasing v" at 6, 0, -1 left norotate back nopoint offset character 0, 0, 0
+set label 2 "u=0" at 5, 6.5, -1 left norotate back nopoint offset character 0, 0, 0
+set label 3 "u=1" at 5, 6.5, 0.100248 left norotate back nopoint offset character 0, 0, 0
+set arrow 1 from 5, -5, -1.2 to 5, 5, -1.2 head back nofilled linetype -1 linewidth 1.000
+set arrow 2 from 5, 6, -1 to 5, 5, -1 head back nofilled linetype -1 linewidth 1.000
+set arrow 3 from 5, 6, 0.100248 to 5, 5, 0.100248 head back nofilled linetype -1 linewidth 1.000
+set parametric
+set view 70, 20, 1, 1
+set samples 51, 51
+set isosamples 2, 33
+set hidden3d back offset 1 trianglepattern 3 undefined 1 altdiagonal bentover
+set ztics -1.00000,0.25,1.00000 norangelimit
+set title "\"fence plot\" using separate parametric surfaces" 
+set xlabel "X axis" 
+set xlabel  offset character -3, -2, 0 font "" textcolor lt -1 norotate
+set xrange [ -5.00000 : 5.00000 ] noreverse nowriteback
+set ylabel "Y axis" 
+set ylabel  offset character 3, -2, 0 font "" textcolor lt -1 rotate by -270
+set yrange [ -5.00000 : 5.00000 ] noreverse nowriteback
+set zlabel "Z axis" 
+set zlabel  offset character -5, 0, 0 font "" textcolor lt -1 norotate
+set zrange [ -1.00000 : 1.00000 ] noreverse nowriteback
+sinc(u,v) = sin(sqrt(u**2+v**2)) / sqrt(u**2+v**2)
+GPFUN_sinc = "sinc(u,v) = sin(sqrt(u**2+v**2)) / sqrt(u**2+v**2)"
+xx = 6.08888888888889
+dx = 1.10888888888889
+x0 = -5
+x1 = -3.89111111111111
+x2 = -2.78222222222222
+x3 = -1.67333333333333
+x4 = -0.564444444444444
+x5 = 0.544444444444445
+x6 = 1.65333333333333
+x7 = 2.76222222222222
+x8 = 3.87111111111111
+x9 = 4.98
+splot [u=0:1][v=-4.99:4.99] 	x0, v, (u<0.5) ? -1 : sinc(x0,v) notitle, 	x1, v, (u<0.5) ? -1 : sinc(x1,v) notitle, 	x2, v, (u<0.5) ? -1 : sinc(x2,v) notitle, 	x3, v, (u<0.5) ? -1 : sinc(x3,v) notitle, 	x4, v, (u<0.5) ? -1 : sinc(x4,v) notitle, 	x5, v, (u<0.5) ? -1 : sinc(x5,v) notitle, 	x6, v, (u<0.5) ? -1 : sinc(x6,v) notitle, 	x7, v, (u<0.5) ? -1 : sinc(x7,v) notitle, 	x8, v, (u<0.5) ? -1 : sinc(x8,v) notitle, 	x9, v, (u<0.5) ? -1 : sinc(x9,v) notitle

samples/Gnuplot/surface1.17.gnu

@@ -0,0 +1,46 @@
+# set terminal pngcairo  transparent enhanced font "arial,10" fontscale 1.0 size 500, 350 
+# set output 'surface1.17.png'
+set dummy u,v
+set label 1 "increasing v" at 6, 0, -1 left norotate back nopoint offset character 0, 0, 0
+set label 2 "increasing u" at 0, -5, -1.5 left norotate back nopoint offset character 0, 0, 0
+set label 3 "floor(u)%3=0" at 5, 6.5, -1 left norotate back nopoint offset character 0, 0, 0
+set label 4 "floor(u)%3=1" at 5, 6.5, 0.100248 left norotate back nopoint offset character 0, 0, 0
+set arrow 1 from 5, -5, -1.2 to 5, 5, -1.2 head back nofilled linetype -1 linewidth 1.000
+set arrow 2 from -5, -5, -1.2 to 5, -5, -1.2 head back nofilled linetype -1 linewidth 1.000
+set arrow 3 from 5, 6, -1 to 5, 5, -1 head back nofilled linetype -1 linewidth 1.000
+set arrow 4 from 5, 6, 0.100248 to 5, 5, 0.100248 head back nofilled linetype -1 linewidth 1.000
+set parametric
+set view 70, 20, 1, 1
+set samples 51, 51
+set isosamples 30, 33
+set hidden3d back offset 1 trianglepattern 3 undefined 1 altdiagonal bentover
+set ztics -1.00000,0.25,1.00000 norangelimit
+set title "\"fence plot\" using single parametric surface with undefined points" 
+set xlabel "X axis" 
+set xlabel  offset character -3, -2, 0 font "" textcolor lt -1 norotate
+set xrange [ -5.00000 : 5.00000 ] noreverse nowriteback
+set ylabel "Y axis" 
+set ylabel  offset character 3, -2, 0 font "" textcolor lt -1 rotate by -270
+set yrange [ -5.00000 : 5.00000 ] noreverse nowriteback
+set zlabel "Z axis" 
+set zlabel  offset character -5, 0, 0 font "" textcolor lt -1 norotate
+set zrange [ -1.00000 : 1.00000 ] noreverse nowriteback
+sinc(u,v) = sin(sqrt(u**2+v**2)) / sqrt(u**2+v**2)
+GPFUN_sinc = "sinc(u,v) = sin(sqrt(u**2+v**2)) / sqrt(u**2+v**2)"
+xx = 6.08888888888889
+dx = 1.11
+x0 = -5
+x1 = -3.89111111111111
+x2 = -2.78222222222222
+x3 = -1.67333333333333
+x4 = -0.564444444444444
+x5 = 0.544444444444445
+x6 = 1.65333333333333
+x7 = 2.76222222222222
+x8 = 3.87111111111111
+x9 = 4.98
+xmin = -4.99
+xmax = 5
+n = 10
+zbase = -1
+splot [u=.5:3*n-.5][v=-4.99:4.99] 	 xmin+floor(u/3)*dx, v, ((floor(u)%3)==0) ? zbase : 			 (((floor(u)%3)==1) ? sinc(xmin+u/3.*dx,v) : 1/0) notitle

samples/Gnuplot/world2.1.gnu

@@ -0,0 +1,21 @@
+# set terminal pngcairo  transparent enhanced font "arial,10" fontscale 1.0 size 500, 350 
+# set output 'world2.1.png'
+unset border
+set dummy u,v
+set angles degrees
+set parametric
+set view 60, 136, 1.22, 1.26
+set samples 64, 64
+set isosamples 13, 13
+set mapping spherical
+set noxtics
+set noytics
+set noztics
+set title "Labels colored by GeV plotted in spherical coordinate system" 
+set urange [ -90.0000 : 90.0000 ] noreverse nowriteback
+set vrange [ 0.00000 : 360.000 ] noreverse nowriteback
+set cblabel "GeV" 
+set cbrange [ 0.00000 : 8.00000 ] noreverse nowriteback
+set colorbox user
+set colorbox vertical origin screen 0.9, 0.2, 0 size screen 0.02, 0.75, 0 front bdefault
+splot cos(u)*cos(v),cos(u)*sin(v),sin(u) notitle with lines lt 5,       'world.dat' notitle with lines lt 2,       'srl.dat' using 3:2:(1):1:4 with labels notitle point pt 6 lw .1 left offset 1,0 font "Helvetica,7" tc pal

samples/Gosu/hello.gsp

@@ -1 +0,0 @@
-print("hello")

samples/Hy/fibonacci.hy

@@ -0,0 +1,9 @@
+;; Fibonacci example in Hy.
+
+(defn fib [n]
+  (if (<= n 2) n
+      (+ (fib (- n 1)) (fib (- n 2)))))
+
+(if (= __name__ "__main__")
+  (for [x [1 2 3 4 5 6 7 8]]
+    (print (fib x))))

samples/Hy/hello-world.hy

@@ -0,0 +1,13 @@
+;; The concurrent.futures example in Hy.
+
+(import [concurrent.futures [ThreadPoolExecutor as-completed]]
+        [random [randint]]
+        [sh [sleep]])
+
+(defn task-to-do []
+  (sleep (randint 1 5)))
+
+(with-as (ThreadPoolExecutor 10) executor
+  (setv jobs (list-comp (.submit executor task-to-do) (x (range 0 10))))
+  (for (future (as-completed jobs))
+    (.result future)))

samples/IDL/mg_acosh.pro

@@ -0,0 +1,29 @@
+; docformat = 'rst'
+
+;+
+; Inverse hyperbolic cosine. Uses the formula:
+; 
+; $$\text{acosh}(z) = \ln(z + \sqrt{z + 1} \sqrt{z - 1})$$
+;
+; :Examples:
+;    The arc hyperbolic sine function looks like::
+;
+;       IDL> x = 2.5 * findgen(1000) / 999. + 1.
+;       IDL> plot, x, mg_acosh(x), xstyle=1
+;
+;    This should look like:
+;
+;    .. image:: acosh.png
+;
+; :Returns:
+;    float, double, complex, or double complex depending on the input
+;
+; :Params:
+;    z : in, required, type=numeric
+;       input
+;-
+function mg_acosh, z
+  compile_opt strictarr
+  
+  return, alog(z + sqrt(z + 1) * sqrt(z - 1))
+end

samples/IDL/mg_analysis.dlm

@@ -0,0 +1,9 @@
+MODULE mg_analysis
+DESCRIPTION Tools for analysis
+VERSION 1.0
+SOURCE mgalloy
+BUILD_DATE January 18, 2011
+
+FUNCTION MG_ARRAY_EQUAL      2 2 KEYWORDS
+FUNCTION MG_TOTAL            1 1
+

samples/IDL/mg_gcd.pro

@@ -0,0 +1,35 @@
+; docformat = 'rst'
+
+;+
+; Find the greatest common denominator (GCD) for two positive integers.
+; 
+; :Returns:
+;    integer
+;
+; :Params:
+;    a : in, required, type=integer
+;       first integer
+;    b : in, required, type=integer
+;       second integer
+;-
+function mg_gcd, a, b
+  compile_opt strictarr
+  on_error, 2
+  
+  if (n_params() ne 2) then message, 'incorrect number of arguments'
+  if (~mg_isinteger(a) || ~mg_isinteger(b)) then begin
+    message, 'integer arguments required'
+  endif
+  
+  _a = abs(a)
+  _b = abs(b)
+  minArg = _a < _b
+  maxArg = _a > _b
+  
+  if (minArg eq 0) then return, maxArg
+  
+  remainder = maxArg mod minArg
+  if (remainder eq 0) then return, minArg
+  
+  return, mg_gcd(minArg, remainder)
+end

samples/IDL/mg_trunc.pro

@@ -0,0 +1,42 @@
+; docformat = 'rst'
+
+;+
+; Truncate argument towards 0.0, i.e., takes the `FLOOR` of positive values
+; and the `CEIL` of negative values.
+;
+; :Examples:
+;   Try the main-level program at the end of this file. It does::
+;
+;      IDL> print, mg_trunc([1.2, -1.2, 0.0])
+;                 1          -1           0
+;      IDL> print, floor([1.2, -1.2, 0.0])
+;                 1          -2           0
+;      IDL> print, ceil([1.2, -1.2, 0.0])
+;                 2          -1           0
+;
+; :Returns:
+;    array of same type as argument
+;
+; :Params:
+;    x : in, required, type=float/double
+;       array containing values to truncate
+;-
+function mg_trunc, x
+  compile_opt strictarr
+  
+  result = ceil(x)
+  posInd = where(x gt 0, nposInd)
+  
+  if (nposInd gt 0L) then begin
+    result[posInd] = floor(x[posInd])
+  endif
+  
+  return, result
+end
+
+
+; main-level example program
+
+print, mg_trunc([1.2, -1.2, 0.0])
+
+end

samples/JSON5/example.json5

@@ -0,0 +1,29 @@
+/*
+ * The following is a contrived example, but it illustrates most of the features:
+ */
+
+{
+    foo: 'bar',
+    while: true,
+
+    this: 'is a \
+multi-line string',
+
+    // this is an inline comment
+    here: 'is another', // inline comment
+
+    /* this is a block comment
+       that continues on another line */
+
+    hex: 0xDEADbeef,
+    half: .5,
+    delta: +10,
+    to: Infinity,   // and beyond!
+
+    finally: 'a trailing comma',
+    oh: [
+        "we shouldn't forget",
+        'arrays can have',
+        'trailing commas too',
+    ],
+}

samples/JSON5/package.json5

@@ -0,0 +1,28 @@
+// This file is written in JSON5 syntax, naturally, but npm needs a regular
+// JSON file, so compile via `npm run build`. Be sure to keep both in sync!
+
+{
+    name: 'json5',
+    version: '0.2.0',
+    description: 'JSON for the ES5 era.',
+    keywords: ['json', 'es5'],
+    author: 'Aseem Kishore <aseem.kishore@gmail.com>',
+    contributors: [
+        'Max Nanasy <max.nanasy@gmail.com>',
+    ],
+    main: 'lib/json5.js',
+    bin: 'lib/cli.js',
+    dependencies: {},
+    devDependencies: {
+        mocha: '~1.0.3',
+    },
+    scripts: {
+        build: './lib/cli.js -c package.json5',
+        test: 'mocha --ui exports --reporter spec',
+    },
+    homepage: 'http://json5.org/',
+    repository: {
+        type: 'git',
+        url: 'https://github.com/aseemk/json5.git',
+    },
+}

samples/JSONLD/sample.jsonld

@@ -0,0 +1,30 @@
+{
+  "@context": {
+    "property": "http://example.com/vocab#property"
+  },
+  "@id": "../document-relative",
+  "@type": "#document-relative",
+  "property": {
+    "@context": {
+      "@base": "http://example.org/test/"
+    },
+    "@id": "../document-base-overwritten",
+    "@type": "#document-base-overwritten",
+    "property": [
+      {
+        "@context": null,
+        "@id": "../document-relative",
+        "@type": "#document-relative",
+        "property": "context completely reset, drops property"
+      },
+      {
+        "@context": {
+          "@base": null
+        },
+        "@id": "../document-relative",
+        "@type": "#document-relative",
+        "property": "only @base is cleared"
+      }
+    ]
+  }
+}

samples/M/Comment.m

@@ -0,0 +1,36 @@
+Comment ;
+  ; this is a comment block
+  ; comments always start with a semicolon
+  ; the next line, while not a comment, is a legal blank line
+  
+  ;whitespace alone is a valid line in a routine
+  ;** Comments can have any graphic character, but no "control"
+  ;** characters
+  
+  ;graphic characters such as: !@#$%^&*()_+=-{}[]|\:"?/>.<,
+  ;the space character is considered a graphic character, even 
+  ;though you can't see it.
+  ; ASCII characters whose numeric code is above 128 and below 32
+  ; are NOT allowed on a line in a routine.
+  ;; multiple semicolons are okay
+  ; a line that has a tag must have whitespace after the tag, bug
+  ; does not have to have a comment or a command on it
+Tag1  
+  ;
+  ;Tags can start with % or an uppercase or lowercase alphabetic
+  ; or can be a series of numeric characters
+%HELO ;
+ ;
+0123 ;
+  ;
+%987  ;
+  ; the most common label is uppercase alphabetic
+LABEL ;
+  ; 
+  ; Tags can be followed directly by an open parenthesis and a
+  ; formal list of variables, and a close parenthesis
+ANOTHER(X) ;
+  ;
+  ;Normally, a subroutine would be ended by a QUIT command, but we
+  ; are taking advantage of the rule that the END of routine is an
+  ; implicit QUIT

samples/Mask/view.mask

@@ -0,0 +1,61 @@
+
+// HTML Elements
+header {
+    
+    img .logo src='/images/~[currentLogo].png' alt=logo;
+    
+    h4 > 'Bar View'
+    
+    if (currentUser) {
+        
+        .account >
+            a href='/acount' >
+                'Hello, ~[currentUser.username]'
+    }
+}
+
+.view {
+    ul {
+       
+        // Iteration
+        for ((user, index) of users) {
+            
+            li.user data-id='~[user.id]' {
+                
+                // interpolation
+                .name > '~[ user.username ]'
+                
+                // expression
+                .count > '~[: user.level.toFixed(2) ]'
+                
+                // util
+                /* Localization sample
+                 * lastActivity: "Am {0:dd. MM} war der letzte Eintrag"
+                 */
+                .date > '~[ L: "lastActivity",  user.date]'
+            }
+        }
+    }
+    
+    // Component
+    :countdownComponent {
+        input type = text >
+            :dualbind value='number';
+            
+        button x-signal='click: countdownStart' > 'Start';
+        
+        h5 {
+            '~[bind: number]'
+            
+            :animation x-slot='countdownStart' {
+                @model > 'transition | scale(0) > scale(1) | 500ms'
+                @next  > 'background-color | red > blue | 2s linear'
+            }
+        }
+    }
+}
+
+footer > :bazCompo {
+    
+    'Component generated at ~[: $u.format($c.date, "HH-mm") ]'
+}

samples/Mathematica/Init.m

@@ -0,0 +1,3 @@
+(* Mathematica Init File *)
+
+Get[ "Foobar`Foobar`"]

samples/Mathematica/PacletInfo.m

@@ -0,0 +1,17 @@
+(* Paclet Info File *)
+
+(* created 2014/02/07*)
+
+Paclet[
+    Name -> "Foobar",
+    Version -> "0.0.1",
+    MathematicaVersion -> "8+",
+    Description -> "Example of an automatically generated PacletInfo file.",
+    Creator -> "Chris Granade",
+    Extensions -> 
+        {
+            {"Documentation", Language -> "English", MainPage -> "Guides/Foobar"}
+        }
+]
+
+

samples/Mathematica/Predicates.m

@@ -0,0 +1,150 @@
+(* ::Package:: *)
+
+BeginPackage["Predicates`"];
+
+
+(* ::Title:: *)
+(*Predicates*)
+
+
+(* ::Section::Closed:: *)
+(*Fuzzy Logic*)
+
+
+(* ::Subsection:: *)
+(*Documentation*)
+
+
+PossiblyTrueQ::usage="Returns True if the argument is not definitely False.";
+PossiblyFalseQ::usage="Returns True if the argument is not definitely True.";
+PossiblyNonzeroQ::usage="Returns True if and only if its argument is not definitely zero.";
+
+
+(* ::Subsection:: *)
+(*Implimentation*)
+
+
+Begin["`Private`"];
+
+
+PossiblyTrueQ[expr_]:=\[Not]TrueQ[\[Not]expr]
+
+
+PossiblyFalseQ[expr_]:=\[Not]TrueQ[expr]
+
+
+End[];
+
+
+(* ::Section::Closed:: *)
+(*Numbers and Lists*)
+
+
+(* ::Subsection:: *)
+(*Documentation*)
+
+
+AnyQ::usage="Given a predicate and a list, retuns True if and only if that predicate is True for at least one element of the list.";
+AnyElementQ::usage="Returns True if cond matches any element of L.";
+AllQ::usage="Given a predicate and a list, retuns True if and only if that predicate is True for all elements of the list.";
+AllElementQ::usage="Returns True if cond matches any element of L.";
+
+
+AnyNonzeroQ::usage="Returns True if L is a list such that at least one element is definitely not zero.";
+AnyPossiblyNonzeroQ::usage="Returns True if expr is a list such that at least one element is not definitely zero.";
+
+
+RealQ::usage="Returns True if and only if the argument is a real number";
+PositiveQ::usage="Returns True if and only if the argument is a positive real number";
+NonnegativeQ::usage="Returns True if and only if the argument is a non-negative real number";
+PositiveIntegerQ::usage="Returns True if and only if the argument is a positive integer";
+NonnegativeIntegerQ::usage="Returns True if and only if the argument is a non-negative integer";
+
+
+IntegerListQ::usage="Returns True if and only if the input is a list of integers.";
+PositiveIntegerListQ::usage="Returns True if and only if the input is a list of positive integers.";
+NonnegativeIntegerListQ::usage="Returns True if and only if the input is a list of non-negative integers.";
+IntegerOrListQ::usage="Returns True if and only if the input is a list of integers or an integer.";
+PositiveIntegerOrListQ::usage="Returns True if and only if the input is a list of positive integers or a positive integer.";
+NonnegativeIntegerOrListQ::usage="Returns True if and only if the input is a list of positive integers or a positive integer.";
+
+
+SymbolQ::usage="Returns True if argument is an unassigned symbol.";
+SymbolOrNumberQ::usage="Returns True if argument is a number of has head 'Symbol'";
+
+
+(* ::Subsection:: *)
+(*Implimentation*)
+
+
+Begin["`Private`"];
+
+
+AnyQ[cond_, L_] := Fold[Or, False, cond /@ L]
+
+
+AnyElementQ[cond_,L_]:=AnyQ[cond,Flatten[L]]
+
+
+AllQ[cond_, L_] := Fold[And, True, cond /@ L]
+
+
+AllElementQ[cond_, L_] := Fold[And, True, cond /@ L]
+
+
+AnyNonzeroQ[L_]:=AnyElementQ[#!=0&,L]
+
+
+PossiblyNonzeroQ[expr_]:=PossiblyTrueQ[expr!=0]
+
+
+AnyPossiblyNonzeroQ[expr_]:=AnyElementQ[PossiblyNonzeroQ,expr]
+
+
+RealQ[n_]:=TrueQ[Im[n]==0];
+
+
+PositiveQ[n_]:=Positive[n];
+
+
+PositiveIntegerQ[n_]:=PositiveQ[n]\[And]IntegerQ[n];
+
+
+NonnegativeQ[n_]:=TrueQ[RealQ[n]&&n>=0];
+
+
+NonnegativeIntegerQ[n_]:=NonnegativeQ[n]\[And]IntegerQ[n];
+
+
+IntegerListQ[input_]:=ListQ[input]&&Not[MemberQ[IntegerQ/@input,False]];
+
+
+IntegerOrListQ[input_]:=IntegerListQ[input]||IntegerQ[input];
+
+
+PositiveIntegerListQ[input_]:=IntegerListQ[input]&&Not[MemberQ[Positive[input],False]];
+
+
+PositiveIntegerOrListQ[input_]:=PositiveIntegerListQ[input]||PositiveIntegerQ[input];
+
+
+NonnegativeIntegerListQ[input_]:=IntegerListQ[input]&&Not[MemberQ[NonnegativeIntegerQ[input],False]];
+
+
+NonnegativeIntegerOrListQ[input_]:=NonnegativeIntegerListQ[input]||NonnegativeIntegerQ[input];
+
+
+SymbolQ[a_]:=Head[a]===Symbol;
+
+
+SymbolOrNumberQ[a_]:=NumericQ[a]||Head[a]===Symbol;
+
+
+End[];
+
+
+(* ::Section:: *)
+(*Epilogue*)
+
+
+EndPackage[];

samples/Oxygene/Program.pas

@@ -1,125 +0,0 @@
-namespace Loops;
-
-interface
-
-uses System.Linq;
-
-type
-  ConsoleApp = class
-  public
-    class method Main;
-    method loopsTesting;
-    method fillData : sequence of Country;
-  var 
-    Countries : sequence of Country;
-  end;
-
-type 
-  Country = public class
-  public
-    property Name : String;
-    property Capital : String;
-
-    constructor (setName : String; setCapital : String);
-  end;
-implementation
-
-class method ConsoleApp.Main;
-begin
-  Console.WriteLine('Loops example');
-  Console.WriteLine();
-
-  with myConsoleApp := new ConsoleApp() do
-     myConsoleApp.loopsTesting;
-end;
-
-method ConsoleApp.loopsTesting;
-begin
-  {---------------------------------}
-  {"for" loop, taking every 5th item}
-  for i : Int32 :=0 to 50 step 5 do 
-  begin
-    Console.Write(i); Console.Write(' ');
-  end;
-
-  Console.WriteLine(); Console.WriteLine();
-
-  {---------------------------------}
-  {"for" loop, going from high to low value}
-  for i : Int32 := 10 downto 1 do
-  begin
-    Console.Write(i); Console.Write(' ');
-  end;
-
-  Console.WriteLine(); Console.WriteLine();
-
-  Countries := fillData;
-  
-  {---------------------------------}
-  {loop with defined "index" variable, which will count from 0 through the number of elements looped}
-  Console.WriteLine('Countries: ');
-  for each c in Countries index num do 
-    Console.WriteLine(Convert.ToString(num + 1) + ') ' + c.Name);
-
-  Console.WriteLine();
-
-  Console.WriteLine('Cities: ');
-  var ind : Integer :=0;
-
-  {---------------------------------}
-  {simple "loop" construct that loops endlessly, until broken out of}
-  loop
-  begin
-    Console.WriteLine(Countries.ElementAt(ind).Capital);
-    Inc(ind);
-    if ind = Countries.Count then break;
-  end;
-
-  Console.WriteLine();
-
-  {---------------------------------}
-  {the type of 'c' is inferred automatically}
-  for each c in Countries do
-    Console.WriteLine(c.Capital + ' is the capital of ' + c.Name);
-
-  Console.WriteLine();
-
-  ind := 0;
-  Console.WriteLine('Cities: ');
-
-  {"repeat ... until" loop}
-  repeat 
-    Console.WriteLine(Countries.ElementAt(ind).Capital);
-    Inc(ind);
-  until ind = Countries.Count;
-
-  Console.WriteLine();
-
-  ind := 0;
-  Console.WriteLine('Countries: ');
-
-  {---------------------------------}
-  {"while ... do" loop}
-  while ind < Countries.Count do
-  begin
-    Console.WriteLine(Countries.ElementAt(ind).Name);
-    Inc(ind);
-  end;
-
-  Console.ReadLine();
-end;
-
-method ConsoleApp.fillData: sequence of Country;
-begin
-  result := [new Country('UK', 'London'), new Country('USA', 'Washington'), new Country('Germany', 'Berlin'), 
-             new Country('Ukraine', 'Kyiv'), new Country('Russia', 'Moscow'), new Country('France', 'Paris')];
-             
-end;
-
-constructor Country (setName :String; setCapital: String);
-begin
-  Name := setName;
-  Capital := setCapital;
-end;
-
-end.

samples/PAWN/grandlarc.pwn

@@ -0,0 +1,520 @@
+//----------------------------------------------------------
+//
+// GRAND LARCENY 1.0
+// A freeroam gamemode for SA-MP 0.3
+//
+//----------------------------------------------------------
+
+#include <a_samp>
+#include <core>
+#include <float>
+#include "../include/gl_common.inc"
+#include "../include/gl_spawns.inc"
+
+#pragma tabsize 0
+
+//----------------------------------------------------------
+
+#define COLOR_WHITE                 0xFFFFFFFF
+#define COLOR_NORMAL_PLAYER 0xFFBB7777
+
+#define CITY_LOS_SANTOS         0
+#define CITY_SAN_FIERRO         1
+#define CITY_LAS_VENTURAS         2
+
+new total_vehicles_from_files=0;
+
+// Class selection globals
+new gPlayerCitySelection[MAX_PLAYERS];
+new gPlayerHasCitySelected[MAX_PLAYERS];
+new gPlayerLastCitySelectionTick[MAX_PLAYERS];
+
+new Text:txtClassSelHelper;
+new Text:txtLosSantos;
+new Text:txtSanFierro;
+new Text:txtLasVenturas;
+
+new thisanimid=0;
+new lastanimid=0;
+
+//----------------------------------------------------------
+
+main()
+{
+        print("\n---------------------------------------");
+        print("Running Grand Larceny - by the SA-MP team\n");
+        print("---------------------------------------\n");
+}
+
+//----------------------------------------------------------
+
+public OnPlayerConnect(playerid)
+{
+        GameTextForPlayer(playerid,"~w~Grand Larceny",3000,4);
+          SendClientMessage(playerid,COLOR_WHITE,"Welcome to {88AA88}G{FFFFFF}rand {88AA88}L{FFFFFF}arceny");
+          
+          // class selection init vars
+          gPlayerCitySelection[playerid] = -1;
+        gPlayerHasCitySelected[playerid] = 0;
+        gPlayerLastCitySelectionTick[playerid] = GetTickCount();
+
+        //SetPlayerColor(playerid,COLOR_NORMAL_PLAYER);
+
+        //Kick(playerid);
+        
+        /*
+        Removes vending machines
+        RemoveBuildingForPlayer(playerid, 1302, 0.0, 0.0, 0.0, 6000.0);
+        RemoveBuildingForPlayer(playerid, 1209, 0.0, 0.0, 0.0, 6000.0);
+        RemoveBuildingForPlayer(playerid, 955, 0.0, 0.0, 0.0, 6000.0);
+        RemoveBuildingForPlayer(playerid, 1775, 0.0, 0.0, 0.0, 6000.0);
+        RemoveBuildingForPlayer(playerid, 1776, 0.0, 0.0, 0.0, 6000.0);
+        */
+        
+        /*
+        new ClientVersion[32];
+        GetPlayerVersion(playerid, ClientVersion, 32);
+        printf("Player %d reports client version: %s", playerid, ClientVersion);*/
+
+         return 1;
+}
+
+//----------------------------------------------------------
+
+public OnPlayerSpawn(playerid)
+{
+        if(IsPlayerNPC(playerid)) return 1;
+        
+        new randSpawn = 0;
+        
+        SetPlayerInterior(playerid,0);
+        TogglePlayerClock(playerid,0);
+         ResetPlayerMoney(playerid);
+        GivePlayerMoney(playerid, 30000);
+
+        if(CITY_LOS_SANTOS == gPlayerCitySelection[playerid]) {
+          randSpawn = random(sizeof(gRandomSpawns_LosSantos));
+          SetPlayerPos(playerid,
+                 gRandomSpawns_LosSantos[randSpawn][0],
+                 gRandomSpawns_LosSantos[randSpawn][1],
+                 gRandomSpawns_LosSantos[randSpawn][2]);
+                SetPlayerFacingAngle(playerid,gRandomSpawns_LosSantos[randSpawn][3]);
+        }
+        else if(CITY_SAN_FIERRO == gPlayerCitySelection[playerid]) {
+          randSpawn = random(sizeof(gRandomSpawns_SanFierro));
+          SetPlayerPos(playerid,
+                 gRandomSpawns_SanFierro[randSpawn][0],
+                 gRandomSpawns_SanFierro[randSpawn][1],
+                 gRandomSpawns_SanFierro[randSpawn][2]);
+                SetPlayerFacingAngle(playerid,gRandomSpawns_SanFierro[randSpawn][3]);
+        }
+        else if(CITY_LAS_VENTURAS == gPlayerCitySelection[playerid]) {
+          randSpawn = random(sizeof(gRandomSpawns_LasVenturas));
+          SetPlayerPos(playerid,
+                 gRandomSpawns_LasVenturas[randSpawn][0],
+                 gRandomSpawns_LasVenturas[randSpawn][1],
+                 gRandomSpawns_LasVenturas[randSpawn][2]);
+                SetPlayerFacingAngle(playerid,gRandomSpawns_LasVenturas[randSpawn][3]);
+        }
+
+        //SetPlayerColor(playerid,COLOR_NORMAL_PLAYER);
+        
+        SetPlayerSkillLevel(playerid,WEAPONSKILL_PISTOL,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_PISTOL_SILENCED,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_DESERT_EAGLE,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_SHOTGUN,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_SAWNOFF_SHOTGUN,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_SPAS12_SHOTGUN,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_MICRO_UZI,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_MP5,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_AK47,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_M4,200);
+    SetPlayerSkillLevel(playerid,WEAPONSKILL_SNIPERRIFLE,200);
+    
+    GivePlayerWeapon(playerid,WEAPON_COLT45,100);
+        //GivePlayerWeapon(playerid,WEAPON_MP5,100);
+        TogglePlayerClock(playerid, 0);
+
+        return 1;
+}
+
+//----------------------------------------------------------
+
+public OnPlayerDeath(playerid, killerid, reason)
+{
+    new playercash;
+    
+    // if they ever return to class selection make them city
+        // select again first
+        gPlayerHasCitySelected[playerid] = 0;
+    
+        if(killerid == INVALID_PLAYER_ID) {
+        ResetPlayerMoney(playerid);
+        } else {
+                playercash = GetPlayerMoney(playerid);
+                if(playercash > 0) {
+                        GivePlayerMoney(killerid, playercash);
+                        ResetPlayerMoney(playerid);
+                }
+        }
+           return 1;
+}
+
+//----------------------------------------------------------
+
+ClassSel_SetupCharSelection(playerid)
+{
+           if(gPlayerCitySelection[playerid] == CITY_LOS_SANTOS) {
+                SetPlayerInterior(playerid,11);
+                SetPlayerPos(playerid,508.7362,-87.4335,998.9609);
+                SetPlayerFacingAngle(playerid,0.0);
+            SetPlayerCameraPos(playerid,508.7362,-83.4335,998.9609);
+                SetPlayerCameraLookAt(playerid,508.7362,-87.4335,998.9609);
+        }
+        else if(gPlayerCitySelection[playerid] == CITY_SAN_FIERRO) {
+                SetPlayerInterior(playerid,3);
+                SetPlayerPos(playerid,-2673.8381,1399.7424,918.3516);
+                SetPlayerFacingAngle(playerid,181.0);
+            SetPlayerCameraPos(playerid,-2673.2776,1394.3859,918.3516);
+                SetPlayerCameraLookAt(playerid,-2673.8381,1399.7424,918.3516);
+        }
+        else if(gPlayerCitySelection[playerid] == CITY_LAS_VENTURAS) {
+                SetPlayerInterior(playerid,3);
+                SetPlayerPos(playerid,349.0453,193.2271,1014.1797);
+                SetPlayerFacingAngle(playerid,286.25);
+            SetPlayerCameraPos(playerid,352.9164,194.5702,1014.1875);
+                SetPlayerCameraLookAt(playerid,349.0453,193.2271,1014.1797);
+        }
+        
+}
+
+//----------------------------------------------------------
+// Used to init textdraws of city names
+
+ClassSel_InitCityNameText(Text:txtInit)
+{
+          TextDrawUseBox(txtInit, 0);
+        TextDrawLetterSize(txtInit,1.25,3.0);
+        TextDrawFont(txtInit, 0);
+        TextDrawSetShadow(txtInit,0);
+    TextDrawSetOutline(txtInit,1);
+    TextDrawColor(txtInit,0xEEEEEEFF);
+    TextDrawBackgroundColor(txtClassSelHelper,0x000000FF);
+}
+
+//----------------------------------------------------------
+
+ClassSel_InitTextDraws()
+{
+    // Init our observer helper text display
+        txtLosSantos = TextDrawCreate(10.0, 380.0, "Los Santos");
+        ClassSel_InitCityNameText(txtLosSantos);
+        txtSanFierro = TextDrawCreate(10.0, 380.0, "San Fierro");
+        ClassSel_InitCityNameText(txtSanFierro);
+        txtLasVenturas = TextDrawCreate(10.0, 380.0, "Las Venturas");
+        ClassSel_InitCityNameText(txtLasVenturas);
+
+    // Init our observer helper text display
+        txtClassSelHelper = TextDrawCreate(10.0, 415.0,
+         " Press ~b~~k~~GO_LEFT~ ~w~or ~b~~k~~GO_RIGHT~ ~w~to switch cities.~n~ Press ~r~~k~~PED_FIREWEAPON~ ~w~to select.");
+        TextDrawUseBox(txtClassSelHelper, 1);
+        TextDrawBoxColor(txtClassSelHelper,0x222222BB);
+        TextDrawLetterSize(txtClassSelHelper,0.3,1.0);
+        TextDrawTextSize(txtClassSelHelper,400.0,40.0);
+        TextDrawFont(txtClassSelHelper, 2);
+        TextDrawSetShadow(txtClassSelHelper,0);
+    TextDrawSetOutline(txtClassSelHelper,1);
+    TextDrawBackgroundColor(txtClassSelHelper,0x000000FF);
+    TextDrawColor(txtClassSelHelper,0xFFFFFFFF);
+}
+
+//----------------------------------------------------------
+
+ClassSel_SetupSelectedCity(playerid)
+{
+        if(gPlayerCitySelection[playerid] == -1) {
+                gPlayerCitySelection[playerid] = CITY_LOS_SANTOS;
+        }
+        
+        if(gPlayerCitySelection[playerid] == CITY_LOS_SANTOS) {
+                SetPlayerInterior(playerid,0);
+                   SetPlayerCameraPos(playerid,1630.6136,-2286.0298,110.0);
+                SetPlayerCameraLookAt(playerid,1887.6034,-1682.1442,47.6167);
+                
+                TextDrawShowForPlayer(playerid,txtLosSantos);
+                TextDrawHideForPlayer(playerid,txtSanFierro);
+                TextDrawHideForPlayer(playerid,txtLasVenturas);
+        }
+        else if(gPlayerCitySelection[playerid] == CITY_SAN_FIERRO) {
+                SetPlayerInterior(playerid,0);
+                   SetPlayerCameraPos(playerid,-1300.8754,68.0546,129.4823);
+                SetPlayerCameraLookAt(playerid,-1817.9412,769.3878,132.6589);
+                
+                TextDrawHideForPlayer(playerid,txtLosSantos);
+                TextDrawShowForPlayer(playerid,txtSanFierro);
+                TextDrawHideForPlayer(playerid,txtLasVenturas);
+        }
+        else if(gPlayerCitySelection[playerid] == CITY_LAS_VENTURAS) {
+                SetPlayerInterior(playerid,0);
+                   SetPlayerCameraPos(playerid,1310.6155,1675.9182,110.7390);
+                SetPlayerCameraLookAt(playerid,2285.2944,1919.3756,68.2275);
+                
+                TextDrawHideForPlayer(playerid,txtLosSantos);
+                TextDrawHideForPlayer(playerid,txtSanFierro);
+                TextDrawShowForPlayer(playerid,txtLasVenturas);
+        }
+}
+
+//----------------------------------------------------------
+
+ClassSel_SwitchToNextCity(playerid)
+{
+    gPlayerCitySelection[playerid]++;
+        if(gPlayerCitySelection[playerid] > CITY_LAS_VENTURAS) {
+         gPlayerCitySelection[playerid] = CITY_LOS_SANTOS;
+        }
+        PlayerPlaySound(playerid,1052,0.0,0.0,0.0);
+        gPlayerLastCitySelectionTick[playerid] = GetTickCount();
+        ClassSel_SetupSelectedCity(playerid);
+}
+
+//----------------------------------------------------------
+
+ClassSel_SwitchToPreviousCity(playerid)
+{
+    gPlayerCitySelection[playerid]--;
+        if(gPlayerCitySelection[playerid] < CITY_LOS_SANTOS) {
+         gPlayerCitySelection[playerid] = CITY_LAS_VENTURAS;
+        }
+        PlayerPlaySound(playerid,1053,0.0,0.0,0.0);
+        gPlayerLastCitySelectionTick[playerid] = GetTickCount();
+        ClassSel_SetupSelectedCity(playerid);
+}
+
+//----------------------------------------------------------
+
+ClassSel_HandleCitySelection(playerid)
+{
+        new Keys,ud,lr;
+    GetPlayerKeys(playerid,Keys,ud,lr);
+    
+    if(gPlayerCitySelection[playerid] == -1) {
+                ClassSel_SwitchToNextCity(playerid);
+                return;
+        }
+
+        // only allow new selection every ~500 ms
+        if( (GetTickCount() - gPlayerLastCitySelectionTick[playerid]) < 500 ) return;
+        
+        if(Keys & KEY_FIRE) {
+         gPlayerHasCitySelected[playerid] = 1;
+         TextDrawHideForPlayer(playerid,txtClassSelHelper);
+                TextDrawHideForPlayer(playerid,txtLosSantos);
+                TextDrawHideForPlayer(playerid,txtSanFierro);
+                TextDrawHideForPlayer(playerid,txtLasVenturas);
+         TogglePlayerSpectating(playerid,0);
+         return;
+        }
+        
+        if(lr > 0) {
+         ClassSel_SwitchToNextCity(playerid);
+        }
+        else if(lr < 0) {
+         ClassSel_SwitchToPreviousCity(playerid);
+        }
+}
+
+//----------------------------------------------------------
+
+public OnPlayerRequestClass(playerid, classid)
+{
+        if(IsPlayerNPC(playerid)) return 1;
+
+        if(gPlayerHasCitySelected[playerid]) {
+                ClassSel_SetupCharSelection(playerid);
+                return 1;
+        } else {
+                if(GetPlayerState(playerid) != PLAYER_STATE_SPECTATING) {
+                        TogglePlayerSpectating(playerid,1);
+                    TextDrawShowForPlayer(playerid, txtClassSelHelper);
+                    gPlayerCitySelection[playerid] = -1;
+                }
+          }
+    
+        return 0;
+}
+
+//----------------------------------------------------------
+
+public OnGameModeInit()
+{
+        SetGameModeText("Grand Larceny");
+        ShowPlayerMarkers(PLAYER_MARKERS_MODE_GLOBAL);
+        ShowNameTags(1);
+        SetNameTagDrawDistance(40.0);
+        EnableStuntBonusForAll(0);
+        DisableInteriorEnterExits();
+        SetWeather(2);
+        SetWorldTime(11);
+
+        //UsePlayerPedAnims();
+        //ManualVehicleEngineAndLights();
+        //LimitGlobalChatRadius(300.0);
+        
+        ClassSel_InitTextDraws();
+
+        // Player Class
+        AddPlayerClass(281,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(282,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(283,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(284,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(285,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(286,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(287,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(288,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(289,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(265,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(266,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(267,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(268,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(269,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(270,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(1,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(2,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(3,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(4,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(5,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(6,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(8,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(42,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(65,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        //AddPlayerClass(74,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(86,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(119,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+         AddPlayerClass(149,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(208,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(273,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(289,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        
+        AddPlayerClass(47,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(48,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(49,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(50,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(51,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(52,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(53,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(54,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(55,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(56,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(57,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(58,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+           AddPlayerClass(68,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(69,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(70,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(71,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(72,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(73,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(75,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(76,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(78,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(79,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(80,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(81,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(82,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(83,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(84,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(85,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(87,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(88,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(89,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(91,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(92,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(93,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(95,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(96,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(97,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(98,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+        AddPlayerClass(99,1759.0189,-1898.1260,13.5622,266.4503,-1,-1,-1,-1,-1,-1);
+
+        // SPECIAL
+        total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/trains.txt");
+        total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/pilots.txt");
+
+           // LAS VENTURAS
+     total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/lv_law.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/lv_airport.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/lv_gen.txt");
+    
+    // SAN FIERRO
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/sf_law.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/sf_airport.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/sf_gen.txt");
+    
+    // LOS SANTOS
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/ls_law.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/ls_airport.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/ls_gen_inner.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/ls_gen_outer.txt");
+    
+    // OTHER AREAS
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/whetstone.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/bone.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/flint.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/tierra.txt");
+    total_vehicles_from_files += LoadStaticVehiclesFromFile("vehicles/red_county.txt");
+
+    printf("Total vehicles from files: %d",total_vehicles_from_files);
+
+        return 1;
+}
+
+//----------------------------------------------------------
+
+public OnPlayerUpdate(playerid)
+{
+        if(!IsPlayerConnected(playerid)) return 0;
+        if(IsPlayerNPC(playerid)) return 1;
+
+        // changing cities by inputs
+        if( !gPlayerHasCitySelected[playerid] &&
+         GetPlayerState(playerid) == PLAYER_STATE_SPECTATING ) {
+         ClassSel_HandleCitySelection(playerid);
+         return 1;
+        }
+        
+        // No weapons in interiors
+        if(GetPlayerInterior(playerid) != 0 && GetPlayerWeapon(playerid) != 0) {
+         SetPlayerArmedWeapon(playerid,0); // fists
+         return 0; // no syncing until they change their weapon
+        }
+        
+        // Don't allow minigun
+        if(GetPlayerWeapon(playerid) == WEAPON_MINIGUN) {
+         Kick(playerid);
+         return 0;
+        }
+        
+        /* No jetpacks allowed
+        if(GetPlayerSpecialAction(playerid) == SPECIAL_ACTION_USEJETPACK) {
+         Kick(playerid);
+         return 0;
+        }*/
+
+        /* For testing animations
+    new msg[128+1];
+        new animlib[32+1];
+        new animname[32+1];
+
+        thisanimid = GetPlayerAnimationIndex(playerid);
+        if(lastanimid != thisanimid)
+        {
+                GetAnimationName(thisanimid,animlib,32,animname,32);
+                format(msg, 128, "anim(%d,%d): %s %s", lastanimid, thisanimid, animlib, animname);
+                lastanimid = thisanimid;
+                SendClientMessage(playerid, 0xFFFFFFFF, msg);
+        }*/
+
+        return 1;
+}
+
+//----------------------------------------------------------

samples/Perl6/RoleQ.pm6

@@ -0,0 +1,23 @@
+role q {
+    token stopper { \' }
+
+    token escape:sym<\\> { <sym> <item=.backslash> }
+
+    token backslash:sym<qq> { <?before 'q'> <quote=.LANG('MAIN','quote')> }
+    token backslash:sym<\\> { <text=.sym> }
+    token backslash:sym<stopper> { <text=.stopper> }
+
+    token backslash:sym<miscq> { {} . }
+
+    method tweak_q($v) { self.panic("Too late for :q") }
+    method tweak_qq($v) { self.panic("Too late for :qq") }
+}
+
+role qq does b1 does c1 does s1 does a1 does h1 does f1 {
+    token stopper { \" }
+    token backslash:sym<unrec> { {} (\w) { self.throw_unrecog_backslash_seq: $/[0].Str } }
+    token backslash:sym<misc> { \W }
+
+    method tweak_q($v) { self.panic("Too late for :q") }
+    method tweak_qq($v) { self.panic("Too late for :qq") }
+}

samples/Perl6/grammar-test.p6

@@ -0,0 +1,22 @@
+token pod_formatting_code {
+    $<code>=<[A..Z]>
+    '<' { $*POD_IN_FORMATTINGCODE := 1 }
+    $<content>=[ <!before '>'> <pod_string_character> ]+
+    '>' { $*POD_IN_FORMATTINGCODE := 0 }
+}
+
+token pod_string {
+    <pod_string_character>+
+}
+
+token something:sym«<» {
+    <!>
+}
+
+token name {
+    <!>
+}
+
+token comment:sym<#> {
+   '#' {} \N*
+}

samples/Perl6/test.p6

@@ -0,0 +1,252 @@
+#!/usr/bin/env perl6
+
+use v6;
+
+my $string = 'I look like a # comment!';
+
+if $string eq 'foo' {
+    say 'hello';
+}
+
+regex http-verb {
+      'GET'
+    | 'POST'
+    | 'PUT'
+    | 'DELETE'
+    | 'TRACE'
+    | 'OPTIONS'
+    | 'HEAD'
+}
+
+# a sample comment
+
+say 'Hello from Perl 6!'
+
+
+#`{
+multi-line comment!
+}
+
+say 'here';
+
+#`(
+multi-line comment!
+)
+
+say 'here';
+
+#`{{{
+I'm a special comment!
+}}}
+
+say 'there';
+
+#`{{
+I'm { even } specialer!
+}}
+
+say 'there';
+
+#`{{
+does {{nesting}} work?
+}}
+
+#`«<
+trying mixed delimiters
+»
+
+my $string = qq<Hooray, arbitrary delimiter!>;
+my $string = qq«Hooray, arbitrary delimiter!»;
+my $string = q <now with whitespace!>;
+my $string = qq<<more strings>>;
+
+my %hash := Hash.new;
+
+=begin pod
+
+Here's some POD!  Wooo
+
+=end pod
+
+=for Testing
+    This is POD (see? role isn't highlighted)
+
+say('this is not!');
+
+=table
+    Of role things
+
+say('not in your table');
+#= A single line declarator "block" (with a keyword like role)
+#| Another single line declarator "block" (with a keyword like role)
+#={
+    A declarator block (with a keyword like role)
+  }
+#|{
+    Another declarator block (with a keyword like role)
+  }
+#= { A single line declarator "block" with a brace (with a keyword like role)
+#=«
+    More declarator blocks! (with a keyword like role)
+  »
+#|«
+    More declarator blocks! (with a keyword like role)
+  »
+
+say 'Moar code!';
+
+my $don't = 16;
+
+sub don't($x) {
+    !$x
+}
+
+say don't 'foo';
+
+my %hash = (
+    :foo(1),
+);
+
+say %hash<foo>;
+say %hash<<foo>>;
+say %hash«foo»;
+
+say %*hash<foo>;
+say %*hash<<foo>>;
+say %*hash«foo»;
+
+say $<todo>;
+say $<todo>;
+
+for (@A Z @B) -> $a, $b {
+    say $a + $b;
+}
+
+Q:PIR {
+    .loadlib "somelib"
+}
+
+my $longstring = q/
+    lots
+    of
+    text
+/;
+
+my $heredoc = q:to/END_SQL/;
+SELECT * FROM Users
+WHERE first_name = 'Rob'
+END_SQL
+my $hello;
+
+# Fun with regexen
+
+if 'food' ~~ /foo/ {
+    say 'match!'
+}
+
+my $re  = /foo/;
+my $re2 = m/ foo /;
+my $re3 = m:i/ FOO /;
+
+call-a-sub(/ foo /);
+call-a-sub(/ foo \/ bar /);
+
+my $re4    = rx/something | something-else/;
+my $result = ms/regexy stuff/;
+my $sub0   = s/regexy stuff/more stuff/;
+my $sub    = ss/regexy stuff/more stuff/;
+my $trans  = tr/regexy stuff/more stuff/;
+
+my @values = <a b c d>;
+call-sub(<a b c d>);
+call-sub <a b c d>;
+
+my $result = $a < $b;
+
+for <a b c d> -> $letter {
+    say $letter;
+}
+
+sub test-sub {
+    say @_;
+    say $!;
+    say $/;
+    say $0;
+    say $1;
+    say @*ARGS;
+    say $*ARGFILES;
+    say &?BLOCK;
+    say ::?CLASS;
+    say $?CLASS;
+    say @=COMMENT;
+    say %?CONFIG;
+    say $*CWD;
+    say $=data;
+    say %?DEEPMAGIC;
+    say $?DISTRO;
+    say $*DISTRO;
+    say $*EGID;
+    say %*ENV;
+    say $*ERR;
+    say $*EUID;
+    say $*EXECUTABLE_NAME;
+    say $?FILE;
+    say $?GRAMMAR;
+    say $*GID;
+    say $*IN;
+    say @*INC;
+    say %?LANG;
+    say $*LANG;
+    say $?LINE;
+    say %*META-ARGS;
+    say $?MODULE;
+    say %*OPTS;
+    say %*OPT;
+    say $?KERNEL;
+    say $*KERNEL;
+    say $*OUT;
+    say $?PACKAGE;
+    say $?PERL;
+    say $*PERL;
+    say $*PID;
+    say %=pod;
+    say $*PROGRAM_NAME;
+    say %*PROTOCOLS;
+    say ::?ROLE;
+    say $?ROLE;
+    say &?ROUTINE;
+    say $?SCOPE;
+    say $*TZ;
+    say $*UID;
+    say $?USAGE;
+    say $?VM;
+    say $?XVM;
+}
+
+say <a b c>;
+
+my $perl5_re = m:P5/ fo{2} /;
+my $re5      = rx«something | something-else»;
+
+my $M := %*COMPILING<%?OPTIONS><M>;
+
+say $M;
+
+sub regex-name { ... }
+my $pair = role-name => 'foo';
+$pair = rolesque => 'foo';
+
+my sub something(Str:D $value) { ... }
+
+my $s = q«<
+some
+string
+stuff
+»;
+
+my $regex = m«< some chars »;
+# after
+
+say $/<foo><bar>;
+
+roleq;

samples/Pod/contents.pod

@@ -0,0 +1,159 @@
+$Id: contents.pod,v 1.3 2003/05/04 04:05:14 tower Exp $
+
+=begin html
+
+<style = "text/css">
+code { font-family: sans-serif; font-weight:bold; }
+</style>
+
+=end html
+
+=head1 Net::Z3950::AsyncZ
+
+=head2 Intro
+
+Net::Z3950::AsyncZ adds an additional layer of asynchronous support for the Z3950 module through the use
+of multiple forked processes. I hope that users will also find that it provides a convenient
+front end to C<Net::Z3950>.  My initial idea was to write something that
+would provide a convenient means of processing and formatting Z39.50 records--which I
+did, using the C<Z3950> synchronous code.  But I also wanted something that could
+handle queries to large numbers of servers at one session. Working on this part of my
+project, I found that I had trouble with the C<Z3950> asynchronous features
+and so ended up with what I have here.
+
+=begin html
+
+I give a more detailed account in the <A href="AsyncZ.html#apologia"><B>DESCRIPTION</b></a>
+section of <code>AsyncZ.html</code>.
+
+=end html
+
+=pod
+
+I give a more detailed account in in the B<DESCRIPTION> section of C<AsyncZ.pod>.
+
+=cut
+
+=head2 Documentation
+
+=pod
+
+=over 4
+
+=item AsyncZ.pod
+
+This is the starting point--it gives an overview of the AsyncZ module,
+describes the basic mechanics of its asynchronous workings, and details
+the particulars of the objects and methods.  But see
+L</"Examples.pod> for detailed explanations of the sample
+scripts which come with the C<Net::Z3950::AsyncZ> distribution.
+
+=item Options.pod
+
+This document details the various options that can be set to modify
+the behavior of AsyncZ Index
+
+=item Report.pod
+
+Report.pod deals with how records are treated line by line
+and how you can affect the apearance of a record's line by line output
+
+=item Examples.pod
+
+This document goes through the sample scripts that come with the
+C<Net::Z3950::AsyncZ> distribution and annotates them
+in a line-by-line fashion.  It's a basic HOW-TO.
+
+=back
+
+=cut
+
+=begin html
+
+<UL>
+<LI>
+ <A href="AsyncZ.html">AsyncZ.html</a>
+    	<br>This is the starting point--it gives an overview of the AsyncZ module,
+describes the basic mechanics of its asynchronous workings, and details
+the particulars of the objects and methods.  But see
+<a href="#examples">Examples</a> for detailed explanations of the sample
+scripts which come with the <code>Net::Z3950::AsyncZ</code> distribution.
+
+<LI>
+ <A href="Options.html">Options.html</a>
+	<br> This document details the various options that can be set to modify
+the behavior of <code>AsyncZ</code>
+
+<LI>
+ <A href="Report.html">Report.html</a>
+        <br><Code>Report.html</code> deals with how records are treated line by line
+and how you can affect the apearance of a record's line by line output
+
+<LI><A name = "examples"></a>
+ <A href="Examples.html">Examples.html</a>
+This document goes through the sample scripts that come with the
+<code>Net::Z3950::AsyncZ</code> distribution and annotates them
+in a line-by-line fashion.  It's a basic HOW-TO.
+
+</UL>
+
+=end html
+
+=head2 The Modules
+
+=pod
+
+There are more modules than there is documentation. The reason for this
+is that the only module you have full and complete access to is
+C<Net::Z3950::AsyncZ>.  The other modules are either internal to C<Net::AsyncZ>
+or accessed indirectly or in part indirectly.
+
+=cut
+
+=for html
+There are more modules than there is documentation. The reason for this
+is that the only module you have full and complete access to is
+<code>Net::Z3950::AsyncZ</code>.  The other modules are either internal to <code>Net::AsyncZ</code>
+or accessed indirectly or in part indirectly.
+
+=head3  Here are the modules:
+
+=over 4
+
+=item Net::Z3950::AsyncZ
+
+The main module: direct access --documented in
+C<AsyncZ> and C<Options> documentation
+
+=item Net::Z3950::AsyncZ::ErrMsg
+
+User error message handling: indirect access  -- documented in
+C<AsyncZ> documentation
+
+=item Net::Z3950::AsyncZ::Errors
+
+Error handling for debugging: limited access -- documented in
+C<AsyncZ> documentation
+
+=item Net::Z3950::AsyncZ::Report
+
+Module reponsible for fetching and formatting records: limited access -- documented
+
+=item Net::Z3950::AsyncZ::ZLoop
+
+Event loop for child processes: no access -- not documented
+
+=item Net::Z3950::AsyncZ::ZSend
+
+Connection details for child processes: no access -- not documented
+
+=item Net::Z3950::AsyncZ::Options::_params
+
+Options for child processes: direct and indirect access -- documented
+in C<Options> and C<AsyncZ> documentation
+
+=back
+
+=head1 INDEX
+
+

samples/PostScript/sierpinski.ps

@@ -0,0 +1,41 @@
+%!PS-Adobe-3.0
+%%Creator: Aaron Puchert
+%%Title: The Sierpinski triangle
+%%Pages: 1
+%%PageOrder: Ascend
+
+%%BeginProlog
+% PAGE SETTINGS
+/pageset {
+  28.3464566 28.3464566 scale    % set cm = 1
+  0.5 0.5 translate
+  0 setlinewidth
+} def
+
+% sierpinski(n) draws a sierpinski triangle of order n
+/sierpinski {
+dup 0 gt {
+  [0.5 0 0 0.5 0 0] concat dup 1 sub sierpinski
+  [1 0 0 1 1 0] concat dup 1 sub sierpinski
+  [1 0 0 1 -1 1] concat dup 1 sub sierpinski
+  [2 0 0 2 0 -1] concat
+} {
+  newpath
+    0 0 moveto
+    1 0 lineto
+    0 1 lineto
+  closepath
+  fill
+} ifelse pop} def
+%%EndProlog
+
+%%BeginSetup
+<< /PageSize [596 843] >> setpagedevice  % A4
+%%EndSetup
+
+%%Page: Test 1
+pageset
+[20 0 10 300 sqrt 0 0] concat
+9 sierpinski
+showpage
+%%EOF

samples/Prolog/calc.pl

@@ -1,68 +0,0 @@
-action_module(calculator) .
-
-
-%[-,-,d1,-] --push(D)-->          [-,-,D,-]  if mode(init)
-push(D) < -
-  mode(init),
-  deny([displayed(D1),mode(init)]),
-  affirm([displayed(D),mode(cont)]).
-
-%[-,-,D1,-] --push(D)-->          [-,-,10*D1+D,-]  if mode(cont)
-push(D) < -
-  mode(cont),
-  deny(displayed(D1)),
-  New = 10*D1 + D,
-  affirm(displayed(New)).
-
-%[a,op,d,m] --push(clear)-->      [0,nop,0,0]
-push(clear) < -
-  deny([accumulator(A),op(O),displayed(D),memory(M),mode(X)]),
-  affirm([accumulator(0),op(nop),displayed(0),memory(0),mode(init)]).
-
-%[a,op,d,m] --push(mem_rec)-->    [a,op,m,m]
-push(mem_rec) < -
-  memory(M),
-  deny([displayed(D),mode(X)]),
-  affirm([displayed(M),mode(init)]).
-
-%[a,op,d,m] --push(plus)-->       [op(a,d),plus,d,m]
-push(plus) < -
-  displayed(D),
-  deny([accumulator(A),op(O),mode(X)]),
-  eval(O,A,D,V),   ; use normal arithmetic, i.e., V=O(A,D)
-  affirm([accumulator(V),op(plus),mode(init)]).
-
-%[a,op,d,m] --push(minus)-->      [op(a,d,minus,d,m]
-push(minus) lt -
-  displayed(D),
-  deny([accumulator(A),op(O),mode(X)]),
-  eval(O,A,D,V),   ; use normal arithmetic, i.e., V=O(A,D)
-  affirm([accumulator(V),op(minus),mode(init)]).
-
-%[a,op,d,m] --push(times)-->      [op(a,d),times,d,m]
-push(times) < -
-  displayed(D),
-  deny([accumulator(A),op(O),mode(X)]),
-  eval(O,A,D,V),   ; use normal arithmetic, i.e., V=O(A,D)
-  affirm([accumulator(V),op(times),mode(init)]).
-
-%[a,op,d,m] --push(equal)-->      [a,nop,op(a,d),m]
-push(equal) < -
-  accumulator(A),
-  deny([op(O),displayed(D),mode(X)]),
-  eval(O,A,D,V),
-  affirm([op(nop),displayed(V),mode(init)]).
-
-%[a,op,d,m] --push(mem_plus)-->   [a,nop,v,plus(m,v)] where v=op(a,d)
-push(mem_plus) < -
-  accumulator(A),
-  deny([op(O),displayed(D),memory(M),mode(X)]),
-  eval(O,A,D,V),
-  eval(plus,M,V,V1),
-  affirm([op(nop),displayed(V),memory(V1),mode(init)]).
-
-%[a,op,d,m] --push(plus_minus)--> [a,op,-d,m]
-push(clear) < -
-  deny([displayed(D),mode(X)]),
-  eval(minus,0,D,V),
-  affirm([displayed(V),mode(init)]).

samples/Prolog/normal_form.pl

@@ -1,94 +0,0 @@
-%%----- normalize(+Wff,-NormalClauses) ------
-normalize(Wff,NormalClauses) :-
-   conVert(Wff,[],S),
-   cnF(S,T),
-   flatten_and(T,U),
-   make_clauses(U,NormalClauses).
-
-%%-----  make a sequence out of a conjunction -----
-flatten_and(X /\ Y, F) :-
-   !,
-   flatten_and(X,A),
-   flatten_and(Y, B),
-   sequence_append(A,B,F).
-flatten_and(X,X).
-
-%%-----  make a sequence out of a disjunction -----
-flatten_or(X \/ Y, F) :-
-   !,
-   flatten_or(X,A),
-   flatten_or(Y,B),
-   sequence_append(A,B,F).
-flatten_or(X,X).
-
-
-%%----- append two sequences -------------------------------
-sequence_append((X,R),S,(X,T)) :- !, sequence_append(R,S,T).
-sequence_append((X),S,(X,S)).
-
-%%----- separate into positive and negative literals -----------
-separate((A,B),P,N) :-
-   !,
-   (A = ~X -> N=[X|N1],
-               separate(B,P,N1)
-             ;
-               P=[A|P1],
-               separate(B,P1,N) ).
-separate(A,P,N) :-
-   (A = ~X -> N=[X],
-               P = []
-            ;
-               P=[A],
-               N = [] ).
-
-%%----- tautology ----------------------------
-tautology(P,N) :- some_occurs(N,P).
-
-some_occurs([F|R],B) :-
-   occurs(F,B) | some_occurs(R,B).
-
-occurs(A,[F|_]) :-
-   A == F,
-   !.
-occurs(A,[_|R]) :-
-   occurs(A,R).
-
-make_clauses((A,B),C) :-
-   !,
-   flatten_or(A,F),
-   separate(F,P,N),
-   (tautology(P,N) ->
-      make_clauses(B,C)
-          ;
-      make_clause(P,N,D),
-      C = [D|R],
-      make_clauses(B,R) ).
-make_clauses(A,C) :-
-   flatten_or(A,F),
-   separate(F,P,N),
-   (tautology(P,N) ->
-       C = []
-        ;
-       make_clause(P,N,D),
-       C = [D] ).
-
-make_clause([],N, false :- B) :-
-   !,
-   make_sequence(N,B,',').
-make_clause(P,[],H) :-
-   !,
-   make_sequence(P,H,'|').
-make_clause(P,N, H :- T) :-
-   make_sequence(P,H,'|'),
-   make_sequence(N,T,',').
-
-make_sequence([A],A,_) :- !.
-make_sequence([F|R],(F|S),'|') :-
-   make_sequence(R,S,'|').
-make_sequence([F|R],(F,S),',') :-
-   make_sequence(R,S,',').
-
-write_list([F|R]) :-
-   write(F), write('.'), nl,
-   write_list(R).
-write_list([]).

samples/Prolog/or-constraint.ecl

@@ -0,0 +1,90 @@
+:- lib(ic).
+
+/**
+ * Question 1.11
+ * vabs(?Val, ?AbsVal)
+ */
+vabs(Val, AbsVal):-
+	AbsVal #> 0,
+	(
+		Val #= AbsVal
+	;
+		Val #= -AbsVal
+	),
+	labeling([Val, AbsVal]).
+
+/**
+ * vabsIC(?Val, ?AbsVal)
+ */
+vabsIC(Val, AbsVal):-
+	AbsVal #> 0,
+	Val #= AbsVal or Val #= -AbsVal,
+	labeling([Val, AbsVal]).
+
+/**
+ * Question 1.12
+ */
+% X #:: -10..10, vabs(X, Y).
+% X #:: -10..10, vabsIC(X, Y).
+
+/**
+ * Question 1.13
+ * faitListe(?ListVar, ?Taille, +Min, +Max)
+ */
+faitListe([], 0, _, _):-!.
+faitListe([First|Rest], Taille, Min, Max):-
+	First #:: Min..Max,
+	Taille1 #= Taille - 1,
+	faitListe(Rest, Taille1, Min, Max).
+
+/**
+ * Question 1.14
+ * suite(?ListVar)
+ */
+suite([Xi, Xi1, Xi2]):-
+	checkRelation(Xi, Xi1, Xi2).
+suite([Xi, Xi1, Xi2|Rest]):-
+	checkRelation(Xi, Xi1, Xi2),
+	suite([Xi1, Xi2|Rest]).
+
+/**
+ * checkRelation(?Xi, ?Xi1, ?Xi2)
+ */
+checkRelation(Xi, Xi1, Xi2):-
+	vabs(Xi1, VabsXi1),
+	Xi2 #= VabsXi1 - Xi.
+
+/**
+ * Question 1.15
+ * checkPeriode(+ListVar).
+ */
+% TODO Any better solution?
+checkPeriode(ListVar):-
+	length(ListVar, Length),
+	Length < 10.
+checkPeriode([X1, X2, X3, X4, X5, X6, X7, X8, X9, X10|Rest]):-
+	X1 =:= X10,
+	checkPeriode([X2, X3, X4, X5, X6, X7, X8, X9, X10|Rest]).
+% faitListe(ListVar, 18, -9, 9), suite(ListVar), checkPeriode(ListVar). => 99 solutions
+
+
+/**
+ * Tests
+ */
+/*
+vabs(5, 5). => Yes
+vabs(5, -5). => No
+vabs(-5, 5). => Yes
+vabs(X, 5).
+vabs(X, AbsX). 
+vabsIC(5, 5). => Yes
+vabsIC(5, -5). => No
+vabsIC(-5, 5). => Yes
+vabsIC(X, 5).
+vabsIC(X, AbsX).
+
+faitListe(ListVar, 5, 1, 3). => 243 solutions
+faitListe([_, _, _, _, _], Taille, 1, 3). => Taille = 5 !!!!!!!!!!!!!!!!
+
+faitListe(ListVar, 18, -9, 9), suite(ListVar). => 99 solutions
+*/

samples/Prolog/puzzle.pl

@@ -1,287 +0,0 @@
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%
-%%%     A* Algorithm
-%%%
-%%%
-%%%     Nodes have form    S#D#F#A
-%%%            where S describes the state or configuration
-%%%                  D is the depth of the node
-%%%                  F is the evaluation function value
-%%%                  A is the ancestor list for the node
-
-:- op(400,yfx,'#').    /* Node builder notation */
-
-solve(State,Soln) :- f_function(State,0,F),
-                     search([State#0#F#[]],S), reverse(S,Soln).
-
-f_function(State,D,F) :- h_function(State,H),
-                         F is D + H.
-
-search([State#_#_#Soln|_], Soln) :- goal(State).
-search([B|R],S) :- expand(B,Children),
-                   insert_all(Children,R,Open),
-                   search(Open,S).
-
-insert_all([F|R],Open1,Open3) :- insert(F,Open1,Open2),
-                                 insert_all(R,Open2,Open3).
-insert_all([],Open,Open).
-
-insert(B,Open,Open) :- repeat_node(B,Open), ! .
-insert(B,[C|R],[B,C|R]) :- cheaper(B,C), ! .
-insert(B,[B1|R],[B1|S]) :- insert(B,R,S), !.
-insert(B,[],[B]).
-
-repeat_node(P#_#_#_, [P#_#_#_|_]).
-
-cheaper( _#_#F1#_ , _#_#F2#_ ) :- F1 < F2.
-
-expand(State#D#_#S,All_My_Children) :-
-     bagof(Child#D1#F#[Move|S],
-           (D1 is D+1,
-             move(State,Child,Move),
-             f_function(Child,D1,F)),
-           All_My_Children).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%
-%%%     8-puzzle solver
-%%%
-%%%
-%%%     State have form    A/B/C/D/E/F/G/H/I
-%%%            where {A,...,I} = {0,...,8}
-%%%               0 represents the empty tile
-%%%
-
-goal(1/2/3/8/0/4/7/6/5).
-
-%%% The puzzle moves
-
-left( A/0/C/D/E/F/H/I/J , 0/A/C/D/E/F/H/I/J ).
-left( A/B/C/D/0/F/H/I/J , A/B/C/0/D/F/H/I/J ).
-left( A/B/C/D/E/F/H/0/J , A/B/C/D/E/F/0/H/J ).
-left( A/B/0/D/E/F/H/I/J , A/0/B/D/E/F/H/I/J ).
-left( A/B/C/D/E/0/H/I/J , A/B/C/D/0/E/H/I/J ).
-left( A/B/C/D/E/F/H/I/0 , A/B/C/D/E/F/H/0/I ).
-
-up( A/B/C/0/E/F/H/I/J , 0/B/C/A/E/F/H/I/J ).
-up( A/B/C/D/0/F/H/I/J , A/0/C/D/B/F/H/I/J ).
-up( A/B/C/D/E/0/H/I/J , A/B/0/D/E/C/H/I/J ).
-up( A/B/C/D/E/F/0/I/J , A/B/C/0/E/F/D/I/J ).
-up( A/B/C/D/E/F/H/0/J , A/B/C/D/0/F/H/E/J ).
-up( A/B/C/D/E/F/H/I/0 , A/B/C/D/E/0/H/I/F ).
-
-right( A/0/C/D/E/F/H/I/J , A/C/0/D/E/F/H/I/J ).
-right( A/B/C/D/0/F/H/I/J , A/B/C/D/F/0/H/I/J ).
-right( A/B/C/D/E/F/H/0/J , A/B/C/D/E/F/H/J/0 ).
-right( 0/B/C/D/E/F/H/I/J , B/0/C/D/E/F/H/I/J ).
-right( A/B/C/0/E/F/H/I/J , A/B/C/E/0/F/H/I/J ).
-right( A/B/C/D/E/F/0/I/J , A/B/C/D/E/F/I/0/J ).
-
-down( A/B/C/0/E/F/H/I/J , A/B/C/H/E/F/0/I/J ).
-down( A/B/C/D/0/F/H/I/J , A/B/C/D/I/F/H/0/J ).
-down( A/B/C/D/E/0/H/I/J , A/B/C/D/E/J/H/I/0 ).
-down( 0/B/C/D/E/F/H/I/J , D/B/C/0/E/F/H/I/J ).
-down( A/0/C/D/E/F/H/I/J , A/E/C/D/0/F/H/I/J ).
-down( A/B/0/D/E/F/H/I/J , A/B/F/D/E/0/H/I/J ).
-
-%%% the heuristic function
-h_function(Puzz,H) :- p_fcn(Puzz,P),
-                      s_fcn(Puzz,S),
-                      H is P + 3*S.
-
-
-%%% the move
-move(P,C,left) :-  left(P,C).
-move(P,C,up) :-  up(P,C).
-move(P,C,right) :-  right(P,C).
-move(P,C,down) :-  down(P,C).
-
-%%% the Manhattan distance function
-p_fcn(A/B/C/D/E/F/G/H/I, P) :-
-     a(A,Pa), b(B,Pb), c(C,Pc),
-     d(D,Pd), e(E,Pe), f(F,Pf),
-     g(G,Pg), h(H,Ph), i(I,Pi),
-     P is Pa+Pb+Pc+Pd+Pe+Pf+Pg+Ph+Pg+Pi.
-
-a(0,0). a(1,0). a(2,1). a(3,2). a(4,3). a(5,4). a(6,3). a(7,2). a(8,1).
-b(0,0). b(1,1). b(2,0). b(3,1). b(4,2). b(5,3). b(6,2). b(7,3). b(8,2).
-c(0,0). c(1,2). c(2,1). c(3,0). c(4,1). c(5,2). c(6,3). c(7,4). c(8,3).
-d(0,0). d(1,1). d(2,2). d(3,3). d(4,2). d(5,3). d(6,2). d(7,2). d(8,0).
-e(0,0). e(1,2). e(2,1). e(3,2). e(4,1). e(5,2). e(6,1). e(7,2). e(8,1).
-f(0,0). f(1,3). f(2,2). f(3,1). f(4,0). f(5,1). f(6,2). f(7,3). f(8,2).
-g(0,0). g(1,2). g(2,3). g(3,4). g(4,3). g(5,2). g(6,2). g(7,0). g(8,1).
-h(0,0). h(1,3). h(2,3). h(3,3). h(4,2). h(5,1). h(6,0). h(7,1). h(8,2).
-i(0,0). i(1,4). i(2,3). i(3,2). i(4,1). i(5,0). i(6,1). i(7,2). i(8,3).
-
-%%% the out-of-cycle function
-s_fcn(A/B/C/D/E/F/G/H/I, S) :-
-     s_aux(A,B,S1), s_aux(B,C,S2), s_aux(C,F,S3),
-     s_aux(F,I,S4), s_aux(I,H,S5), s_aux(H,G,S6),
-     s_aux(G,D,S7), s_aux(D,A,S8), s_aux(E,S9),
-     S is S1+S2+S3+S4+S5+S6+S7+S8+S9.
-
-s_aux(0,0) :- !.
-s_aux(_,1).
-
-s_aux(X,Y,0) :- Y is X+1, !.
-s_aux(8,1,0) :- !.
-s_aux(_,_,2).
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%
-%%%     8-puzzle animation -- using VT100 character graphics
-%%%
-%%%
-%%%
-
-puzzle(P) :- solve(P,S),
-             animate(P,S),
-             message.
-
-animate(P,S) :- initialize(P),
-                cursor(1,2), write(S),
-                cursor(1,22), write('Hit ENTER to step solver.'),
-                get0(_X),
-                play_back(S).
-
-:- dynamic location/3.
-
-initialize(A/B/C/D/E/F/H/I/J) :-
-  cls,
-  retractall(location(_,_,_)),
-  assert(location(A,20,5)),
-  assert(location(B,30,5)),
-  assert(location(C,40,5)),
-  assert(location(F,40,10)),
-  assert(location(J,40,15)),
-  assert(location(I,30,15)),
-  assert(location(H,20,15)),
-  assert(location(D,20,10)),
-  assert(location(E,30,10)), draw_all.
-
-draw_all :- draw(1), draw(2), draw(3), draw(4),
-            draw(5), draw(6), draw(7), draw(8).
-
-%%% play_back([left,right,up,...]).
-play_back([M|R]) :- call(M), get0(_X), play_back(R).
-play_back([]) :- cursor(1,24).  %%% Put cursor out of the way
-
-message :- nl,nl,
-   write('    ********************************************'), nl,
-   write('    *  Enter 8-puzzle goals in the form ...    *'), nl,
-   write('    *     ?-  puzzle(0/8/1/2/4/3/7/6/5).       *'), nl,
-   write('    *   Enter goal ''message'' to reread this.   *'), nl,
-   write('    ********************************************'), nl, nl.
-
-
-cursor(X,Y) :- put(27), put(91), %%% ESC [
-               write(Y),
-               put(59),           %%%   ;
-               write(X),
-               put(72).           %%%   M
-
-%%% clear the screen, quickly
-cls :-  put(27), put("["), put("2"), put("J").
-
-%%% video attributes -- bold and blink not working
-plain         :- put(27), put("["), put("0"), put("m").
-reverse_video :- put(27), put("["), put("7"), put("m").
-
-
-%%% Tile objects, character map(s)
-%%% Each tile should be drawn using the character map,
-%%%   drawn at 'location', which is asserted and retracted
-%%%   by 'playback'.
-character_map(N, [ [' ',' ',' ',' ',' ',' ',' '],
-                   [' ',' ',' ', N ,' ',' ',' '],
-                   [' ',' ',' ',' ',' ',' ',' '] ]).
-
-
-%%% move empty tile (spot) to the left
-left :- retract(location(0,X0,Y0)),
-        Xnew is X0 - 10,
-        location(Tile,Xnew,Y0),
-        assert(location(0,Xnew,Y0)),
-        right(Tile),right(Tile),right(Tile),
-        right(Tile),right(Tile),
-        right(Tile),right(Tile),right(Tile),
-        right(Tile),right(Tile).
-
-up :- retract(location(0,X0,Y0)),
-      Ynew is Y0 - 5,
-      location(Tile,X0,Ynew),
-      assert(location(0,X0,Ynew)),
-      down(Tile),down(Tile),down(Tile),down(Tile),down(Tile).
-
-right :- retract(location(0,X0,Y0)),
-         Xnew is X0 + 10,
-         location(Tile,Xnew,Y0),
-         assert(location(0,Xnew,Y0)),
-         left(Tile),left(Tile),left(Tile),left(Tile),left(Tile),
-         left(Tile),left(Tile),left(Tile),left(Tile),left(Tile).
-
-down :- retract(location(0,X0,Y0)),
-        Ynew is Y0 + 5,
-        location(Tile,X0,Ynew),
-        assert(location(0,X0,Ynew)),
-        up(Tile),up(Tile),up(Tile),up(Tile),up(Tile).
-
-
-draw(Obj) :- reverse_video, character_map(Obj,M),
-             location(Obj,X,Y),
-             draw(X,Y,M), plain.
-
-%%% hide tile
-hide(Obj) :- character_map(Obj,M),
-             location(Obj,X,Y),
-             hide(X,Y,M).
-
-hide(_,_,[]).
-hide(X,Y,[R|G]) :- hide_row(X,Y,R),
-                   Y1 is Y + 1,
-                   hide(X,Y1,G).
-
-hide_row(_,_,[]).
-hide_row(X,Y,[_|R]) :- cursor(X,Y),
-                       write(' '),
-                       X1 is X + 1,
-                       hide_row(X1,Y,R).
-
-%%% draw tile
-draw(_,_,[]).
-draw(X,Y,[R|G]) :- draw_row(X,Y,R),
-                   Y1 is Y + 1,
-                   draw(X,Y1,G).
-
-draw_row(_,_,[]).
-draw_row(X,Y,[P|R]) :- cursor(X,Y),
-                       write(P),
-                       X1 is X + 1,
-                       draw_row(X1,Y,R).
-
-%%% Move an Object up
-up(Obj)    :- hide(Obj),
-              retract(location(Obj,X,Y)),
-              Y1 is Y - 1,
-              assert(location(Obj,X,Y1)),
-              draw(Obj).
-
-down(Obj)  :- hide(Obj),
-              retract(location(Obj,X,Y)),
-              Y1 is Y + 1,
-              assert(location(Obj,X,Y1)),
-              draw(Obj).
-
-left(Obj)  :- hide(Obj),
-              retract(location(Obj,X,Y)),
-              X1 is X - 1,
-              assert(location(Obj,X1,Y)),
-              draw(Obj).
-
-right(Obj) :- hide(Obj),
-              retract(location(Obj,X,Y)),
-              X1 is X + 1,
-              assert(location(Obj,X1,Y)),
-              draw(Obj).
-
-:- message.

samples/Prolog/quicksort.pl

@@ -1,13 +0,0 @@
-partition([], _, [], []).
-partition([X|Xs], Pivot, Smalls, Bigs) :-
-    (   X @< Pivot ->
-        Smalls = [X|Rest],
-        partition(Xs, Pivot, Rest, Bigs)
-    ;   Bigs = [X|Rest],
-        partition(Xs, Pivot, Smalls, Rest)
-    ).
-
-quicksort([])     --> [].
-quicksort([X|Xs]) -->
-    { partition(Xs, X, Smaller, Bigger) },
-    quicksort(Smaller), [X], quicksort(Bigger).

samples/Prolog/test-prolog.pl

@@ -1,12 +0,0 @@
-/* Prolog test file */
-male(john).
-male(peter).
-
-female(vick).
-female(christie).
-
-parents(john, peter, christie).
-parents(vick, peter, christie).
-
-/* X is a brother of Y */
-brother(X, Y) :- male(X), parents(X, F, M), parents(Y, F, M).

samples/Prolog/test-prolog.prolog

@@ -0,0 +1,12 @@
+-/* Prolog test file */
+ -male(john).
+ -male(peter).
+ -
+ -female(vick).
+ -female(christie).
+ -
+ -parents(john, peter, christie).
+ -parents(vick, peter, christie).
+ -
+ -/* X is a brother of Y */
+ -brother(X, Y) :- male(X), parents(X, F, M), parents(Y, F, M).

samples/Prolog/turing.pl

@@ -1,21 +1,21 @@
-turing(Tape0, Tape) :-
-    perform(q0, [], Ls, Tape0, Rs),
-    reverse(Ls, Ls1),
-    append(Ls1, Rs, Tape).
-
-perform(qf, Ls, Ls, Rs, Rs) :- !.
-perform(Q0, Ls0, Ls, Rs0, Rs) :-
-    symbol(Rs0, Sym, RsRest),
-    once(rule(Q0, Sym, Q1, NewSym, Action)),
-    action(Action, Ls0, Ls1, [NewSym|RsRest], Rs1),
-    perform(Q1, Ls1, Ls, Rs1, Rs).
-
-symbol([], b, []).
-symbol([Sym|Rs], Sym, Rs).
-
-action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
-action(stay, Ls, Ls, Rs, Rs).
-action(right, Ls0, [Sym|Ls0], [Sym|Rs], Rs).
-
-left([], [], Rs0, [b|Rs0]).
-left([L|Ls], Ls, Rs, [L|Rs]).
+-turing(Tape0, Tape) :-
+ -    perform(q0, [], Ls, Tape0, Rs),
+ -    reverse(Ls, Ls1),
+ -    append(Ls1, Rs, Tape).
+ -
+ -perform(qf, Ls, Ls, Rs, Rs) :- !.
+ -perform(Q0, Ls0, Ls, Rs0, Rs) :-
+ -    symbol(Rs0, Sym, RsRest),
+ -    once(rule(Q0, Sym, Q1, NewSym, Action)),
+ -    action(Action, Ls0, Ls1, [NewSym|RsRest], Rs1),
+ -    perform(Q1, Ls1, Ls, Rs1, Rs).
+ -
+ -symbol([], b, []).
+ -symbol([Sym|Rs], Sym, Rs).
+ -
+ -action(left, Ls0, Ls, Rs0, Rs) :- left(Ls0, Ls, Rs0, Rs).
+ -action(stay, Ls, Ls, Rs, Rs).
+ -action(right, Ls0, [Sym|Ls0], [Sym|Rs], Rs).
+ -
+ -left([], [], Rs0, [b|Rs0]).
+ -left([L|Ls], Ls, Rs, [L|Rs]).

samples/R/R-qgis-extension.rsx

@@ -0,0 +1,5 @@
+##polyg=vector
+##numpoints=number 10
+##output=output vector
+##[Example scripts]=group
+pts=spsample(polyg,numpoints,type="regular")

samples/RMarkdown/example.rmd

@@ -0,0 +1,10 @@
+# An example RMarkdown
+
+Some text.
+
+## A graphic in R
+
+```{r}
+plot(1:10)
+hist(rnorm(10000))
+```

samples/Scala/node11.sc

@@ -0,0 +1,75 @@
+import math.random
+import scala.language.postfixOps
+import scala.util._
+import scala.util.{Try, Success, Failure}
+import scala.concurrent._
+import duration._
+import ExecutionContext.Implicits.global
+import scala.concurrent.{ ExecutionContext, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException, blocking }
+/* This worksheet demonstrates some of the code snippets from
+* Week3, Lecture 4, "Composing Futures".
+*/
+
+
+object node11 {
+  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
+
+  /**
+  * Retry successfully completing block at most noTimes
+  * and give up after that
+  */
+
+   def retry[T](n: Int)(block: =>Future[T]): Future[T] = {
+    val ns: Iterator[Int] = (1 to n).iterator
+    val attempts: Iterator[()=>Future[T]] = ns.map(_ => ()=>block)
+    val failed: Future[T] = Future.failed(new Exception)
+    attempts.foldLeft(failed)((a, block) => a fallbackTo { block() })
+  }                                               //> retry: [T](n: Int)(block: => scala.concurrent.Future[T])scala.concurrent.Fut
+                                                  //| ure[T]
+  def rb(i: Int) = {
+    blocking{Thread.sleep(100*random.toInt)}
+    println("Hi " ++ i.toString)
+    i + 10
+  }                                               //> rb: (i: Int)Int
+  def block(i: Int) = {
+    println("Iteration: " + i.toString)
+
+    val ri = retry(i)( Future {rb(i)} )
+
+    ri onComplete {
+      case Success(s) => println(s.toString  ++ " = 10 + " ++ i.toString)
+      case Failure(t:Exception) => println(t.toString  ++ " " ++ i.toString)
+      case r => println(r.toString  ++ " " ++ i.toString)
+    }
+
+	}                                         //> block: (i: Int)Unit
+  /* Multiple executions of a block of commands where
+   * each block contains one collectCoins and
+   * one buyTreasure. If either call fails, the whole iteration does not fail,
+   * because we are catching exceptions (with flatMap) in this implementation.
+   * Note that these blocks execute synchrounsly.
+   */
+  (0 to 4 toList).foreach(i =>block(i))           //> Iteration: 0
+                                                  //| Iteration: 1
+                                                  //| java.lang.Exception 0
+                                                  //| Hi 1
+                                                  //| Iteration: 2
+                                                  //| 11 = 10 + 1
+                                                  //| Hi 2
+                                                  //| Iteration: 3
+                                                  //| Hi 3
+                                                  //| Hi 2
+                                                  //| Iteration: 4
+                                                  //| 12 = 10 + 2
+    blocking{Thread.sleep(3000)}                  //> Hi 4
+                                                  //| Hi 3
+                                                  //| 13 = 10 + 3
+                                                  //| Hi 3
+                                                  //| 14 = 10 + 4
+                                                  //| Hi 4
+                                                  //| Hi 4
+                                                  //| Hi 4-
+
+
+
+}

samples/Scheme/basic.sld

@@ -0,0 +1,7 @@
+(define-library (libs basic)
+    (export list2 x)
+    (begin
+        (define (list2 . objs)  objs)
+        (define x 'libs-basic)
+        (define not-exported 'should-not-be-exported)
+        ))

samples/Shen/graph.shen

@@ -0,0 +1,321 @@
+\* graph.shen --- a library for graph definition and manipulation
+
+Copyright (C) 2011,  Eric Schulte
+
+*** License:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*** Commentary:
+
+Graphs are represented as two dictionaries one for vertices and one
+for edges.  It is important to note that the dictionary implementation
+used is able to accept arbitrary data structures as keys.  This
+structure technically encodes hypergraphs (a generalization of graphs
+in which each edge may contain any number of vertices).  Examples of a
+regular graph G and a hypergraph H with the corresponding data
+structure are given below.
+
+
+--G=<graph Vertices Edges>------------------------------------------------
+                            Vertices                  Edges
+                           ----------                -------
+ +----Graph G-----+      hash | key -> value      hash |  key  -> value
+ |                |      -----+------>--------    -----+-------->---------
+ | a---b---c   g  |         1 |  a  -> [1]           1 | [a b] -> [1 2]
+ |     |   |      |         2 |  b  -> [1 2 3]       2 | [b c] -> [2 3]
+ |     d---e---f  |         3 |  c  -> [2 4]         3 | [b d] -> [2 4]
+ |                |         4 |  d  -> [3 5]         4 | [c e] -> [3 5]
+ +----------------+         5 |  e  -> [4 5 6]       5 | [d e] -> [4 5]
+                            6 |  f  -> [6]           6 | [e f] -> [5 6]
+                            7 |  g  -> []
+
+
+--H=<graph Vertices Edges>------------------------------------------------
+                            Vertices                  Edges
+                           ----------                -------
+                         hash | key -> value      hash |  key  -> value
+ +-- Hypergraph H----+   -----+------>--------    -----+-------->---------
+ |                   |      1 |  a  -> [1]           1 | [a b     [1 2
+ |        +------+   |      2 |  b  -> [1]             |  c d  ->  3 4
+ | +------+------+   |      3 |  c  -> [1]             |  e f]     5 6]
+ | |a b c |d e f |   |      4 |  d  -> [1 2]           |
+ | +------+------+   |      5 |  e  -> [1 2]         2 | [d e     [4 5
+ |        |g h i | j |      6 |  f  -> [1 2]           |  f g  ->  6 7
+ |        +------+   |      7 |  g  -> [2]             |  h i]     8 9]
+ |                   |      8 |  h  -> [2]
+ +-------------------+      9 |  i  -> [2]
+                           10 |  j  -> []
+
+
+--G=<graph Vertices Edges>-------Graph with associated edge/vertex data---------
+                            Vertices                    Edges
+                           ----------                  -------
+ +----Graph G-----+      hash | key -> value        hash |  key  -> value
+ |   4   6     7  |      -----+------>--------      -----+-------->---------
+ |0a---b---c   g  |         1 |  a  -> (@p 0 [1])      1 | [a b] -> (@p 4 [1 2])
+ |    1|  3|      |         2 |  b  -> [1 2 3]         2 | [b c] -> (@p 6 [2 3])
+ |     d---e---f  |         3 |  c  -> [2 4]           3 | [b d] -> (@p 1 [2 4])
+ |       2   5    |         4 |  d  -> [3 5]           4 | [c e] -> (@p 3 [3 5])
+ +----------------+         5 |  e  -> [4 5 6]         5 | [d e] -> (@p 2 [4 5])
+                            6 |  f  -> [6]             6 | [e f] -> (@p 5 [5 6])
+                            7 |  g  -> (@p 7 [])
+
+V = # of vertices
+E = # of edges
+M = # of vertex edge associations
+
+size = size of all vertices +            all vertices stored in Vertices dict
+       M * sizeof(int) * 4 +             indices into Vertices & Edge dicts
+       V * sizeof(dict entry) +          storage in the Vertex dict
+       E * sizeof(dict entry) +          storage in the Edge dict
+       2 * sizeof(dict)                  the Vertices and Edge dicts
+
+*** Code: *\
+(require dict)
+(require sequence)
+
+(datatype graph
+  Vertices : dictionary;
+     Edges : dictoinary;
+  ===================
+  (vector symbol Vertices Edges);)
+
+(package graph- [graph graph? vertices edges add-vertex
+                 add-edge has-edge? has-vertex? edges-for
+                 neighbors connected-to connected? connected-components
+                 vertex-partition bipartite?
+                 \* included from the sequence library\ *\
+                 take drop take-while drop-while range flatten
+                 filter complement seperate zip indexed reduce
+                 mapcon partition partition-with unique frequencies
+                 shuffle pick remove-first interpose subset?
+                 cartesian-product
+                 \* included from the dict library\ *\
+                 dict? dict dict-> <-dict contents key? keys vals
+                 dictionary make-dict]
+
+(define graph?
+  X -> (= graph (<-address X 0)))
+
+(define make-graph
+  \* create a graph with specified sizes for the vertex dict and edge dict *\
+  {number --> number --> graph}
+  Vertsize Edgesize ->
+    (let Graph (absvector 3)
+      (do (address-> Graph 0 graph)
+          (address-> Graph 1 (make-dict Vertsize))
+          (address-> Graph 2 (make-dict Edgesize))
+          Graph)))
+
+(defmacro graph-macro
+  \* return a graph taking optional sizes for the vertex and edge dicts *\
+  [graph] -> [make-graph 1024 1024]
+  [graph N] -> [make-graph N 1024]
+  [graph N M] -> [make-graph N M])
+
+(define vert-dict Graph -> (<-address Graph 1))
+
+(define edge-dict Graph -> (<-address Graph 2))
+
+(define vertices
+  {graph --> (list A)}
+  Graph -> (keys (vert-dict Graph)))
+
+(define edges
+  {graph --> (list (list A))}
+  Graph -> (keys (edge-dict Graph)))
+
+(define get-data
+  Value V -> (if (tuple? Value)
+                 (fst Value)
+                 (error (make-string "no data for ~S~%" V))))
+
+(define vertex-data
+  Graph V -> (get-data (<-dict (vert-dict Graph) V) V))
+
+(define edge-data
+  Graph V -> (get-data (<-dict (edge-dict Graph) V) V))
+
+(define resolve
+  {(vector (list A)) --> (@p number number) --> A}
+  Vector (@p Index Place) -> (nth (+ 1 Place) (<-vector Vector Index)))
+
+(define resolve-vert
+  {graph --> (@p number number) --> A}
+  Graph Place -> (resolve (<-address (vert-dict Graph) 2) Place))
+
+(define resolve-edge
+  {graph --> (@p number number) --> A}
+  Graph Place -> (resolve (<-address (edge-dict Graph) 2) Place))
+
+(define edges-for
+  {graph --> A --> (list (list A))}
+  Graph Vert -> (let Val (trap-error (<-dict (vert-dict Graph) Vert) (/. E []))
+                     Edges (if (tuple? Val) (snd Val) Val)
+                  (map (lambda X (fst (resolve-edge Graph X))) Val)))
+
+(define add-vertex-w-data
+  \* add a vertex to a graph *\
+  {graph --> A --> B --> A}
+  G V Data -> (do (dict-> (vert-dict G) V (@p Data (edges-for G V))) V))
+
+(define add-vertex-w/o-data
+  \* add a vertex to a graph *\
+  {graph --> A --> B --> A}
+  G V -> (do (dict-> (vert-dict G) V (edges-for G V)) V))
+
+(defmacro add-vertex-macro
+  [add-vertex G V]   -> [add-vertex-w/o-data G V]
+  [add-vertex G V D] -> [add-vertex-w-data G V D])
+
+(define update-vert
+  \* in a dict, add an edge to a vertex's edge list *\
+  {vector --> (@p number number) --> A --> number}
+  Vs Edge V -> (let Store (<-address Vs 2)
+                    N (hash V (limit Store))
+                    VertLst (trap-error (<-vector Store N) (/. E []))
+                    Contents (trap-error (<-dict Vs V) (/. E []))
+                 (do (dict-> Vs V (if (tuple? Contents)
+                                      (@p (fst Contents)
+                                          (adjoin Edge (snd Contents)))
+                                      (adjoin Edge Contents)))
+                     (@p N (length VertLst)))))
+
+(define update-edges-vertices
+  \* add an edge to a graph *\
+  {graph --> (list A) --> (list A)}
+  Graph Edge ->
+  (let Store (<-address (edge-dict Graph) 2)
+       EdgeID (hash Edge (limit Store))
+       EdgeLst (trap-error (<-vector Store EdgeID) (/. E []))
+    (map (update-vert (vert-dict Graph) (@p EdgeID (length EdgeLst))) Edge)))
+
+(define add-edge-w-data
+  G E D -> (do (dict-> (edge-dict G) E (@p D (update-edges-vertices G E))) E))
+
+(define add-edge-w/o-data
+  G E -> (do (dict-> (edge-dict G) E (update-edges-vertices G E)) E))
+
+(defmacro add-edge-macro
+  [add-edge G E]   -> [add-edge-w/o-data G E]
+  [add-edge G E V] -> [add-edge-w-data G E V])
+
+(define has-edge?
+  {graph --> (list A) --> boolean}
+  Graph Edge -> (key? (edge-dict Graph) Edge))
+
+(define has-vertex?
+  {graph --> A --> boolean}
+  Graph Vertex -> (key? (vert-dict Graph) Vertex))
+
+(define neighbors
+  \* Return the neighbors of a vertex *\
+  {graph --> A --> (list A)}
+  Graph Vert -> (unique (mapcon (remove-first Vert) (edges-for Graph Vert))))
+
+(define connected-to-
+  {graph --> (list A) --> (list A) --> (list A)}
+  Graph [] Already -> Already
+  Graph New Already ->
+  (let Reachable (unique (mapcon (neighbors Graph) New))
+       New (difference Reachable Already)
+    (connected-to- Graph New (append New Already))))
+
+(define connected-to
+  \* return all vertices connected to the given vertex, including itself *\
+  {graph --> A --> (list A)}
+  Graph V -> (connected-to- Graph [V] [V]))
+
+(define connected?
+  \* return if a graph is fully connected *\
+  {graph --> boolean}
+  Graph -> (reduce (/. V Acc
+                       (and Acc
+                            (subset? (vertices Graph) (connected-to Graph V))))
+                   true (vertices Graph)))
+
+(define connected-components-
+  \* given a graph return a list of connected components *\
+  {graph --> (list A) --> (list (list A)) --> (list graph)}
+  Graph [] _ -> []
+  Graph VS [] -> (map (/. V (let Component (graph 1 0)
+                              (do (add-vertex Component V) Component)))
+                      VS)
+  Graph [V|VS] ES ->
+    (let Con-verts (connected-to Graph V)
+         Con-edges (filter (/. E (subset? E Con-verts)) ES)
+         Component (graph (length Con-verts) (length Con-edges))
+      (do (map (add-edge-w/o-data Component) Con-edges)
+          (cons Component (connected-components- Graph
+                                                 (difference VS Con-verts)
+                                                 (difference ES Con-edges))))))
+
+(define connected-components
+  {graph --> (list graph)}
+  Graph -> (connected-components- Graph (vertices Graph) (edges Graph)))
+
+(define place-vertex
+  \* given a graph, vertex and list of partitions, partition the vertex *\
+  {graph --> A --> (list (list A)) --> (list (list A))}
+  Graph V [] -> (if (element? V (neighbors Graph V))
+                    (simple-error
+                     (make-string "self-loop ~S, no vertex partition" V))
+                    [[V]])
+  Graph V [C|CS] -> (let Neighbors (neighbors Graph V)
+                      (if (element? V Neighbors)
+                          (simple-error
+                           (make-string "self-loop ~S, no vertex partition" V))
+                          (if (empty? (intersection C Neighbors))
+                              [[V|C]|CS]
+                              [C|(place-vertex Graph V CS)]))))
+
+(define vertex-partition
+  \* partition the vertices of a graph *\
+  {graph --> (list (list A))}
+  Graph -> (reduce (place-vertex Graph) [] (vertices Graph)))
+
+(define bipartite?
+  \* check if a graph is bipartite *\
+  {graph --> boolean}
+  Graph -> (= 2 (length (vertex-partition Graph))))
+
+)
+
+\* simple tests
+
+(set g (graph))
+(add-edge (value g) [chris patton])
+(add-edge (value g) [eric chris])
+(add-vertex (value g) nobody)
+(has-edge? (value g) [patton chris])
+(edges-for (value g) chris)
+(neighbors (value g) chris)
+(neighbors (value g) nobody)
+(connected-to (value g) chris)
+(connected? (value g))
+(connected-components (value g)) <- fail when package wrapper is used
+(map (function vertices) (connected-components (value g)))
+
+*\

samples/Shen/html.shen

@@ -0,0 +1,102 @@
+\* html.shen --- html generation functions for shen
+
+Copyright (C) 2011,  Eric Schulte
+
+*** License:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*** Commentary:
+
+The standard lisp-to-html conversion tool suite.  Follows some of
+the convertions of Clojure's hiccup.
+
+  an example...
+
+(8-) (html [ul#todo1.tasks.stuff [: [title "today"]]
+          (map (lambda Str [li Str]) ["get milk" "dishes"])])
+"<ul class='tasks stuff' id='todo1' title='today'>
+ <li>get milk</li><li>dishes</li></ul>"
+
+*** Code: *\
+(trap-error
+ (require string)
+ (/. E (load "../string/string.shen")))
+
+(package string- [html
+                  \* symbols included from string *\
+                  takestr dropstr substr length-str index-str
+                  reverse-str starts-with substr? replace-str
+                  join split trim-left trim-right chomp trim]
+
+(define to-str
+  \* return argument as a string, if already a string do not change *\
+  X -> X where (string? X)
+  X -> (str X))
+
+(define gassoc
+  X Y -> (hd (tl (assoc X Y))))
+
+(define dassoc
+  X Y -> (remove (assoc X Y) Y))
+
+(define passoc
+  [] Y -> Y
+  [X XV] Y -> (let Orig (gassoc X Y)
+                   New (if (cons? Orig) [XV|Orig] XV)
+                [[X New]|(dassoc X Y)]))
+
+(define html
+  X -> X where (string? X)
+  [Tag [: |Attrs] |Body] ->
+    (let Tag-comps (css-parse-symbol Tag)
+         Tag (gassoc tag Tag-comps)
+         New-attrs (passoc (assoc class Tag-comps)
+                           (passoc (assoc id Tag-comps) Attrs))
+      (@s (make-string "<~S" Tag) (attributes New-attrs) ">"
+          (html Body)
+          (make-string "</~S>" Tag))) where (symbol? Tag)
+  [Tag|Body] -> (html [Tag [:] Body]) where (symbol? Tag)
+  [H|HS] -> (@s (html H) (html HS))
+  [] -> "")
+
+(define css-parse-symbol
+  {symbol --> [[symbol A]]}
+  Symbol -> (let String (str Symbol)
+                 Class-split (split (str .) String)
+                 Class (map (function intern) (tl Class-split))
+                 Id-split (split (str #) (hd Class-split))
+                 Tag (hd Id-split)
+                 Id (tl Id-split)
+              ((if (= [] Id) (/. X X) (cons [id (intern (hd Id))]))
+               ((if (= [] Class) (/. X X) (cons [class Class])) 
+                [[tag (intern Tag)]]))))
+
+(define attributes
+  [] -> ""
+  [[K V]|AS] -> (@s " " (to-str K) "='"
+                    (if (cons? V) (join " " (map (function str) V)) (to-str V))
+                    "'" (attributes AS)))
+
+)

samples/Shen/json.shen

@@ -0,0 +1,39 @@
+(load "grammar.shen")
+
+\*
+
+JSON Lexer
+
+1. Read a stream of characters
+2. Whitespace characters not in strings should be discarded.
+3. Whitespace characters in strings should be preserved
+4. Strings can contain escaped double quotes. e.g. "\""
+
+*\
+
+(define whitespacep
+  \* e.g. ASCII 32 == #\Space. *\
+  \* All the others are whitespace characters from an ASCII table. *\
+  Char -> (member Char ["c#9;" "c#10;" "c#11;" "c#12;" "c#13;" "c#32;"]))
+
+(define replace-whitespace
+  "" -> ""
+  (@s Whitespace Suffix) -> (@s "" (replace-whitespace Suffix)) where (whitespacep Whitespace)
+  (@s Prefix Suffix) -> (@s Prefix (replace-whitespace Suffix)))
+
+(define fetch-until-unescaped-doublequote
+  [] -> []
+  ["\" "c#34;" | Chars] -> ["\" "c#34;" | (fetch-until-unescaped-doublequote Chars)]
+  ["c#34;" | Chars] -> []
+  [Char | Chars] -> [Char | (fetch-until-unescaped-doublequote Chars)])
+
+\* (define strip-whitespace-chars *\
+\*   [] -> [] *\
+\*   ["c#34;" | Chars] -> ["c#34;" | ( *\
+\*   [WhitespaceChar | Chars] -> (strip-whitespace-chars Chars) where (whitespace? WhitespaceChar) *\
+\*   [Char | Chars] -> [Char | (strip-whitespace-chars Chars)]) *\
+
+(define tokenise
+  JSONString ->
+  (let CharList (explode JSONString)
+       CharList))

samples/Standard ML/RedBlackTree.fun

@@ -0,0 +1,254 @@
+(* From Twelf *)
+(* Red/Black Trees *)
+(* Author: Frank Pfenning *)
+
+functor RedBlackTree
+  (type key'
+   val compare : key' * key' -> order)
+  :> TABLE where type key = key' =
+struct
+  type key = key'
+  type 'a entry = key * 'a
+
+  datatype 'a dict =
+    Empty				(* considered black *)
+  | Red of 'a entry * 'a dict * 'a dict
+  | Black of 'a entry * 'a dict * 'a dict
+
+  type 'a Table = 'a dict ref
+
+  (* Representation Invariants *)
+  (*
+     1. The tree is ordered: for every node Red((key1,datum1), left, right) or
+        Black ((key1,datum1), left, right), every key in left is less than
+        key1 and every key in right is greater than key1.
+
+     2. The children of a red node are black (color invariant).
+
+     3. Every path from the root to a leaf has the same number of
+        black nodes, called the black height of the tree.
+  *)
+
+  local
+
+  fun lookup dict key =
+    let
+      fun lk (Empty) = NONE
+	| lk (Red tree) = lk' tree
+        | lk (Black tree) = lk' tree
+      and lk' ((key1, datum1), left, right) =
+	    (case compare(key,key1)
+	       of EQUAL => SOME(datum1)
+	        | LESS => lk left
+		| GREATER => lk right)
+      in
+	lk dict
+      end
+
+  (* val restore_right : 'a dict -> 'a dict *)
+  (*
+     restore_right (Black(e,l,r)) >=> dict
+     where (1) Black(e,l,r) is ordered,
+           (2) Black(e,l,r) has black height n,
+	   (3) color invariant may be violated at the root of r:
+               one of its children might be red.
+     and dict is a re-balanced red/black tree (satisfying all invariants)
+     and same black height n.
+  *)
+  fun restore_right (Black(e, Red lt, Red (rt as (_,Red _,_)))) =
+         Red(e, Black lt, Black rt)	(* re-color *)
+    | restore_right (Black(e, Red lt, Red (rt as (_,_,Red _)))) =
+         Red(e, Black lt, Black rt)	(* re-color *)
+    | restore_right (Black(e, l, Red(re, Red(rle, rll, rlr), rr))) =
+	 (* l is black, deep rotate *)
+	 Black(rle, Red(e, l, rll), Red(re, rlr, rr))
+    | restore_right (Black(e, l, Red(re, rl, rr as Red _))) =
+	 (* l is black, shallow rotate *)
+	 Black(re, Red(e, l, rl), rr)
+    | restore_right dict = dict
+
+  (* restore_left is like restore_right, except *)
+  (* the color invariant may be violated only at the root of left child *)
+  fun restore_left (Black(e, Red (lt as (_,Red _,_)), Red rt)) =
+	 Red(e, Black lt, Black rt)	(* re-color *)
+    | restore_left (Black(e, Red (lt as (_,_,Red _)), Red rt)) =
+	 Red(e, Black lt, Black rt)	(* re-color *)
+    | restore_left (Black(e, Red(le, ll as Red _, lr), r)) =
+	 (* r is black, shallow rotate *)
+	 Black(le, ll, Red(e, lr, r))
+    | restore_left (Black(e, Red(le, ll, Red(lre, lrl, lrr)), r)) =
+	 (* r is black, deep rotate *)
+	 Black(lre, Red(le, ll, lrl), Red(e, lrr, r))
+    | restore_left dict = dict
+
+  fun insert (dict, entry as (key,datum)) =
+    let
+      (* val ins : 'a dict -> 'a dict  inserts entry *)
+      (* ins (Red _) may violate color invariant at root *)
+      (* ins (Black _) or ins (Empty) will be red/black tree *)
+      (* ins preserves black height *)
+      fun ins (Empty) = Red(entry, Empty, Empty)
+	| ins (Red(entry1 as (key1, datum1), left, right)) =
+	  (case compare(key,key1)
+	     of EQUAL => Red(entry, left, right)
+	      | LESS => Red(entry1, ins left, right)
+	      | GREATER => Red(entry1, left, ins right))
+	| ins (Black(entry1 as (key1, datum1), left, right)) =
+	  (case compare(key,key1)
+	     of EQUAL => Black(entry, left, right)
+	      | LESS => restore_left (Black(entry1, ins left, right))
+	      | GREATER => restore_right (Black(entry1, left, ins right)))
+    in
+      case ins dict
+	of Red (t as (_, Red _, _)) => Black t (* re-color *)
+	 | Red (t as (_, _, Red _)) => Black t (* re-color *)
+	 | dict => dict
+    end
+
+  (* function below from .../smlnj-lib/Util/int-redblack-set.sml *)
+  (* Need to check and improve some time *)
+  (* Sun Mar 13 08:22:53 2005 -fp *)
+
+  (* Remove an item.  Returns true if old item found, false otherwise *)
+    local
+      exception NotFound
+      datatype 'a zipper
+	= TOP
+	| LEFTB of ('a entry * 'a dict * 'a zipper)
+	| LEFTR of ('a entry * 'a dict * 'a zipper)
+	| RIGHTB of ('a dict * 'a entry * 'a zipper)
+	| RIGHTR of ('a dict * 'a entry * 'a zipper)
+    in
+    fun delete t key =
+        let
+	  fun zip (TOP, t) = t
+	    | zip (LEFTB(x, b, z), a) = zip(z, Black(x, a, b))
+	    | zip (LEFTR(x, b, z), a) = zip(z, Red(x, a, b))
+	    | zip (RIGHTB(a, x, z), b) = zip(z, Black(x, a, b))
+	    | zip (RIGHTR(a, x, z), b) = zip(z, Red(x, a, b))
+	(* bbZip propagates a black deficit up the tree until either the top
+	 * is reached, or the deficit can be covered.  It returns a boolean
+	 * that is true if there is still a deficit and the zipped tree.
+	 *)
+	  fun bbZip (TOP, t) = (true, t)
+	    | bbZip (LEFTB(x, Red(y, c, d), z), a) = (* case 1L *)
+		bbZip (LEFTR(x, c, LEFTB(y, d, z)), a)
+	    | bbZip (LEFTB(x, Black(w, Red(y, c, d), e), z), a) = (* case 3L *)
+		bbZip (LEFTB(x, Black(y, c, Red(w, d, e)), z), a)
+	    | bbZip (LEFTR(x, Black(w, Red(y, c, d), e), z), a) = (* case 3L *)
+		bbZip (LEFTR(x, Black(y, c, Red(w, d, e)), z), a)
+	    | bbZip (LEFTB(x, Black(y, c, Red(w, d, e)), z), a) = (* case 4L *)
+		(false, zip (z, Black(y, Black(x, a, c), Black(w, d, e))))
+	    | bbZip (LEFTR(x, Black(y, c, Red(w, d, e)), z), a) = (* case 4L *)
+		(false, zip (z, Red(y, Black(x, a, c), Black(w, d, e))))
+	    | bbZip (LEFTR(x, Black(y, c, d), z), a) = (* case 2L *)
+		(false, zip (z, Black(x, a, Red(y, c, d))))
+	    | bbZip (LEFTB(x, Black(y, c, d), z), a) = (* case 2L *)
+		bbZip (z, Black(x, a, Red(y, c, d)))
+	    | bbZip (RIGHTB(Red(y, c, d), x, z), b) = (* case 1R *)
+		bbZip (RIGHTR(d, x, RIGHTB(c, y, z)), b)
+	    | bbZip (RIGHTR(Red(y, c, d), x, z), b) = (* case 1R *)
+		bbZip (RIGHTR(d, x, RIGHTB(c, y, z)), b)
+	    | bbZip (RIGHTB(Black(y, Red(w, c, d), e), x, z), b) = (* case 3R *)
+		bbZip (RIGHTB(Black(w, c, Red(y, d, e)), x, z), b)
+	    | bbZip (RIGHTR(Black(y, Red(w, c, d), e), x, z), b) = (* case 3R *)
+		bbZip (RIGHTR(Black(w, c, Red(y, d, e)), x, z), b)
+	    | bbZip (RIGHTB(Black(y, c, Red(w, d, e)), x, z), b) = (* case 4R *)
+		(false, zip (z, Black(y, c, Black(x, Red(w, d, e), b))))
+	    | bbZip (RIGHTR(Black(y, c, Red(w, d, e)), x, z), b) = (* case 4R *)
+		(false, zip (z, Red(y, c, Black(w, Red(w, d, e), b))))
+	    | bbZip (RIGHTR(Black(y, c, d), x, z), b) = (* case 2R *)
+		(false, zip (z, Black(x, Red(y, c, d), b)))
+	    | bbZip (RIGHTB(Black(y, c, d), x, z), b) = (* case 2R *)
+		bbZip (z, Black(x, Red(y, c, d), b))
+	    | bbZip (z, t) = (false, zip(z, t))
+	  fun delMin (Red(y, Empty, b), z) = (y, (false, zip(z, b)))
+	    | delMin (Black(y, Empty, b), z) = (y, bbZip(z, b))
+	    | delMin (Black(y, a, b), z) = delMin(a, LEFTB(y, b, z))
+	    | delMin (Red(y, a, b), z) = delMin(a, LEFTR(y, b, z))
+	    | delMin (Empty, _) = raise Match
+	  fun joinRed (Empty, Empty, z) = zip(z, Empty)
+	    | joinRed (a, b, z) = let
+		val (x, (needB, b')) = delMin(b, TOP)
+		in
+		  if needB
+		    then #2(bbZip(z, Red(x, a, b')))
+		    else zip(z, Red(x, a, b'))
+		end
+	  fun joinBlack (a, Empty, z) = #2(bbZip(z, a))
+	    | joinBlack (Empty, b, z) = #2(bbZip(z, b))
+	    | joinBlack (a, b, z) = let
+		val (x, (needB, b')) = delMin(b, TOP)
+		in
+		  if needB
+		    then #2(bbZip(z, Black(x, a, b')))
+		    else zip(z, Black(x, a, b'))
+		end
+	  fun del (Empty, z) = raise NotFound
+	    | del (Black(entry1 as (key1, datum1), a, b), z) =
+	      (case compare(key,key1)
+		 of EQUAL => joinBlack (a, b, z)
+                  | LESS => del (a, LEFTB(entry1, b, z))
+		  | GREATER => del (b, RIGHTB(a, entry1, z)))
+	    | del (Red(entry1 as (key1, datum1), a, b), z) =
+	      (case compare(key,key1)
+                 of EQUAL => joinRed (a, b, z)
+                  | LESS => del (a, LEFTR(entry1, b, z))
+                  | GREATER => del (b, RIGHTR(a, entry1, z)))
+	  in
+	    (del(t, TOP); true) handle NotFound => false
+	  end
+    end (* local *)
+
+  (* use non-imperative version? *)
+  fun insertShadow (dict, entry as (key,datum)) =
+      let val oldEntry = ref NONE (* : 'a entry option ref *)
+          fun ins (Empty) = Red(entry, Empty, Empty)
+	    | ins (Red(entry1 as (key1, datum1), left, right)) =
+	      (case compare(key,key1)
+		 of EQUAL => (oldEntry := SOME(entry1);
+			      Red(entry, left, right))
+	          | LESS => Red(entry1, ins left, right)
+	          | GREATER => Red(entry1, left, ins right))
+	    | ins (Black(entry1 as (key1, datum1), left, right)) =
+	      (case compare(key,key1)
+		 of EQUAL => (oldEntry := SOME(entry1);
+			      Black(entry, left, right))
+	          | LESS => restore_left (Black(entry1, ins left, right))
+	          | GREATER => restore_right (Black(entry1, left, ins right)))
+      in
+	(oldEntry := NONE;
+	 ((case ins dict
+	     of Red (t as (_, Red _, _)) => Black t (* re-color *)
+	      | Red (t as (_, _, Red _)) => Black t (* re-color *)
+	      | dict => dict),
+	  !oldEntry))
+      end
+  
+  fun app f dict =
+      let fun ap (Empty) = ()
+	    | ap (Red tree) = ap' tree
+	    | ap (Black tree) = ap' tree
+	  and ap' (entry1, left, right) =
+	      (ap left; f entry1; ap right)
+      in
+	ap dict
+      end
+
+  in
+    fun new (n) = ref (Empty) (* ignore size hint *)
+    val insert = (fn table => fn entry => (table := insert (!table, entry)))
+    val insertShadow =
+        (fn table => fn entry => 
+	 let
+	   val (dict, oldEntry) = insertShadow (!table, entry)
+	 in
+	   (table := dict; oldEntry)
+	 end)
+    val lookup = (fn table => fn key => lookup (!table) key)
+    val delete = (fn table => fn key => (delete (!table) key; ()))
+    val clear = (fn table => (table := Empty))
+    val app = (fn f => fn table => app f (!table))
+  end
+
+end;  (* functor RedBlackTree *)

samples/Stylus/demo.styl

@@ -0,0 +1,31 @@
+border-radius()
+  -webkit-border-radius arguments
+  -moz-border-radius arguments
+  border-radius arguments
+
+a.button
+  border-radius 5px
+
+fonts = helvetica, arial, sans-serif
+
+body {
+  padding: 50px;
+  font: 14px/1.4 fonts;
+}
+
+form
+  input[type=text]
+    padding: 5px
+    border: 1px solid #eee
+    color: #ddd
+
+textarea
+  @extends form input[type=text]
+  padding: 10px
+
+$foo
+  color: #FFF
+
+.bar
+  background: #000
+  @extends $foo

samples/SuperCollider/BCR2000.sc

@@ -1,114 +0,0 @@
-BCR2000 {
-  var controls,
-      controlBuses,
-      rangedControlBuses,
-      responders
-  ;
-
-  *new {
-    ^super.new.init;
-  }
-    
-  init {
-    controls = Dictionary.new(108);
-    controlBuses = Dictionary.new(108);
-    rangedControlBuses = Dictionary.new(108);
-
-    this.createCCResponders;
-  }
-
-  createCCResponders {
-    responders = Array.fill(108, {|i|
-      CCResponder({|src, chan, num, val|
-        [src, chan, num, val].postln;
-
-        // Write to controls 
-        controls.put(i + 1, val);
-
-        // Write to bus (converted to scalar 0..1)
-        controlBuses.put(i + 1, Bus.control(Server.default));
-        controlBuses.at(i + 1).value = val / 127;
-      },
-        // Adjust values as/if needed
-        nil, // src
-        nil, // chan
-        nil, // num
-        nil  // value    
-      )
-    });
-  }
-
-  // Value from BCR
-  at {arg controlNum;
-    ^controls.at(controlNum)
-  }
-
-  // Convert to 0..1
-  scalarAt {arg controlNum; 
-    ^controls.at(controlNum) / 127
-  }
-
-  // Get a bus
-  busAt {arg controlNum;
-    ^controlBuses.at(controlNum)
-  }
-
-  /*
-  busRangeAt(arg controlNum, lo, hi;
-    if (rangedControlBuses.at(controlNum).isNil, {
-      rangedControlBuses.put(controlNum, Bus.control(Server.default))
-    }); 
-   
-    // Left to right order of operations
-    //rangedControlBuses.put(
-    bus.value = hi - lo * controls.at(controlNum) + lo;
-
-    ^bus
-  }
-  */
-}
-
-/* Scratch
-Dictionary
-b = BCR2000();
-b.at(4);
-b.scalarAt(4);
-b.controls[5].get;
-throw
-z = Dictionary.new(2);
-z.at(\1);
-Array.fill(10, {|i| i.postln;})
-(2 + 3).asSymbol;
-
-
-SynthDef(\x, {
-  arg amp = 0.01,
-      freq = 1200,
-      modDepth = 0.7,
-      modFreq = 2
-  ;
-
-  var
-    carrier,
-    modulator   
-  ;
-
-  modulator = SinOsc.ar(modFreq, mul: modDepth);
-  carrier = Saw.ar(freq, add: modulator, mul: amp);
-
-  Out.ar([0,1], carrier)
-}).store; 
-
-
-x = Synth(\x);
-x.set(\modDepth, 1);
-x.set(\modFreq, 64); 
-
-x.map(\modFreq, b.busAt(       
-
-
-
-ControlSpec
-*/
-
-

samples/SystemVerilog/endpoint_phy_wrapper.svh

@@ -0,0 +1,216 @@
+module endpoint_phy_wrapper
+  (
+   input clk_sys_i,
+   input clk_ref_i,
+   input clk_rx_i,
+   input rst_n_i,
+
+   IWishboneMaster.master src,
+   IWishboneSlave.slave snk,
+   IWishboneMaster.master sys,
+   
+   output [9:0] td_o,
+   input [9:0] rd_i,
+
+   output txn_o,
+   output txp_o,
+
+   input rxn_i,
+   input rxp_i
+   );
+
+   wire rx_clock;
+   
+   parameter g_phy_type   = "GTP";   
+
+   wire[15:0] gtx_data;
+   wire [1:0]gtx_k;
+   wire gtx_disparity;
+   wire gtx_enc_error;
+   wire [15:0] grx_data;
+   wire grx_clk;
+   wire [1:0]grx_k;
+   wire grx_enc_error;
+   wire [3:0] grx_bitslide;
+   wire gtp_rst;
+   wire tx_clock;
+   
+   generate
+      if(g_phy_type == "TBI") begin
+
+         assign rx_clock  = clk_ref_i;
+         assign tx_clock  = clk_rx_i;
+         
+         
+         wr_tbi_phy U_Phy 
+           (
+            .serdes_rst_i (gtp_rst),
+            .serdes_loopen_i(1'b0),
+            .serdes_prbsen_i(1'b0),
+            .serdes_enable_i(1'b1), 
+            .serdes_syncen_i(1'b1),
+
+            .serdes_tx_data_i  (gtx_data[7:0]),
+            .serdes_tx_k_i     (gtx_k[0]),
+            .serdes_tx_disparity_o (gtx_disparity),
+            .serdes_tx_enc_err_o   (gtx_enc_error),
+
+            .serdes_rx_data_o      (grx_data[7:0]),
+            .serdes_rx_k_o        (grx_k[0]),
+            .serdes_rx_enc_err_o  (grx_enc_error),
+            .serdes_rx_bitslide_o (grx_bitslide),
+
+
+            .tbi_refclk_i (clk_ref_i),
+            .tbi_rbclk_i  (clk_rx_i),
+
+            .tbi_td_o     (td_o),
+            .tbi_rd_i     (rd_i),
+            .tbi_syncen_o (),
+            .tbi_loopen_o (),
+            .tbi_prbsen_o (),
+            .tbi_enable_o ()
+            );
+
+      end else if (g_phy_type == "GTX") begin // if (g_phy_type == "TBI")
+         wr_gtx_phy_virtex6
+           #(
+             .g_simulation(1)
+             ) U_PHY 
+             (
+              .clk_ref_i(clk_ref_i),
+              
+              .tx_clk_o   (tx_clock),
+              .tx_data_i (gtx_data),
+              .tx_k_i (gtx_k),
+              .tx_disparity_o (gtx_disparity),
+              .tx_enc_err_o(gtx_enc_error),
+              .rx_rbclk_o (rx_clock),
+              .rx_data_o (grx_data),
+              .rx_k_o  (grx_k),
+              .rx_enc_err_o (grx_enc_error),
+              .rx_bitslide_o  (),
+
+              .rst_i    (!rst_n_i),
+              .loopen_i (1'b0),
+
+              .pad_txn_o (txn_o),
+              .pad_txp_o (txp_o),
+
+              .pad_rxn_i (rxn_i),
+              .pad_rxp_i (rxp_i)
+    );
+                   
+      end  else if (g_phy_type == "GTP") begin // if (g_phy_type == "TBI")
+         assign #1 tx_clock  = clk_ref_i;
+         
+         wr_gtp_phy_spartan6
+           #(
+             .g_simulation(1)
+             ) U_PHY 
+             (
+              .gtp_clk_i(clk_ref_i),
+              .ch0_ref_clk_i(clk_ref_i),
+              
+              .ch0_tx_data_i (gtx_data[7:0]),
+              .ch0_tx_k_i (gtx_k[0]),
+              .ch0_tx_disparity_o (gtx_disparity),
+              .ch0_tx_enc_err_o(gtx_enc_error),
+              .ch0_rx_rbclk_o (rx_clock),
+              .ch0_rx_data_o (grx_data[7:0]),
+              .ch0_rx_k_o  (grx_k[0]),
+              .ch0_rx_enc_err_o (grx_enc_error),
+              .ch0_rx_bitslide_o  (),
+
+              .ch0_rst_i    (!rst_n_i),
+              .ch0_loopen_i (1'b0),
+
+              .pad_txn0_o (txn_o),
+              .pad_txp0_o (txp_o),
+
+              .pad_rxn0_i (rxn_i),
+              .pad_rxp0_i (rxp_i)
+              );
+         
+      end // else: !if(g_phy_type == "TBI")
+   endgenerate
+   
+   wr_endpoint
+     #(
+       .g_simulation          (1),
+       .g_pcs_16bit(g_phy_type == "GTX" ? 1: 0),
+       .g_rx_buffer_size (1024),
+       .g_with_rx_buffer(0),
+       .g_with_timestamper    (1),
+       .g_with_dmtd           (0),
+       .g_with_dpi_classifier (1),
+       .g_with_vlans          (0),
+       .g_with_rtu            (0)
+       ) DUT (
+              .clk_ref_i (clk_ref_i),
+              .clk_sys_i (clk_sys_i),
+              .clk_dmtd_i (clk_ref_i),
+              .rst_n_i  (rst_n_i),
+              .pps_csync_p1_i (1'b0),
+
+              .phy_rst_o   (),
+              .phy_loopen_o (),
+              .phy_enable_o (),
+              .phy_syncen_o (),
+
+              .phy_ref_clk_i      (tx_clock),
+              .phy_tx_data_o      (gtx_data),
+              .phy_tx_k_o         (gtx_k),
+              .phy_tx_disparity_i (gtx_disparity),
+              .phy_tx_enc_err_i   (gtx_enc_error),
+
+              .phy_rx_data_i     (grx_data),
+              .phy_rx_clk_i      (rx_clock),
+              .phy_rx_k_i        (grx_k),
+              .phy_rx_enc_err_i  (grx_enc_error),
+              .phy_rx_bitslide_i (5'b0),
+
+              .src_dat_o   (snk.dat_i),
+              .src_adr_o   (snk.adr),
+              .src_sel_o   (snk.sel),
+              .src_cyc_o   (snk.cyc),
+              .src_stb_o   (snk.stb),
+              .src_we_o    (snk.we),
+              .src_stall_i (snk.stall),
+              .src_ack_i   (snk.ack),
+              .src_err_i(1'b0),
+
+              .snk_dat_i   (src.dat_o[15:0]),
+              .snk_adr_i   (src.adr[1:0]),
+              .snk_sel_i   (src.sel[1:0]),
+              .snk_cyc_i   (src.cyc),
+              .snk_stb_i   (src.stb),
+              .snk_we_i    (src.we),
+              .snk_stall_o (src.stall),
+              .snk_ack_o   (src.ack),
+              .snk_err_o   (src.err),
+              .snk_rty_o   (src.rty),
+
+              .txtsu_ack_i (1'b1),
+
+              .rtu_full_i (1'b0),
+              .rtu_almost_full_i (1'b0),
+              .rtu_rq_strobe_p1_o  (),
+              .rtu_rq_smac_o  (),
+              .rtu_rq_dmac_o (),
+              .rtu_rq_vid_o  (),
+              .rtu_rq_has_vid_o (),
+              .rtu_rq_prio_o (),
+              .rtu_rq_has_prio_o (),
+
+              .wb_cyc_i(sys.cyc),
+              .wb_stb_i (sys.stb),
+              .wb_we_i (sys.we),
+              .wb_sel_i(sys.sel),
+              .wb_adr_i(sys.adr[7:0]),
+              .wb_dat_i(sys.dat_o),
+              .wb_dat_o(sys.dat_i),
+              .wb_ack_o (sys.ack)
+    );
+
+endmodule // endpoint_phy_wrapper

samples/SystemVerilog/fifo.sv

@@ -0,0 +1,7 @@
+module fifo (
+    input           clk_50,
+    input           clk_2,
+    input           reset_n,
+    output [7:0]    data_out,
+    output          empty
+);

samples/SystemVerilog/priority_encoder.sv

@@ -0,0 +1,18 @@
+// http://hdlsnippets.com/parameterized_priority_encoder
+module priority_encoder #(parameter INPUT_WIDTH=8,OUTPUT_WIDTH=3)
+(
+ input  logic [INPUT_WIDTH-1:0]  input_data,
+ output logic [OUTPUT_WIDTH-1:0] output_data
+);
+ 
+int ii;
+ 
+always_comb
+begin
+  output_data = 'b0;
+	for(ii=0;ii<INPUT_WIDTH;ii++)
+		if (input_data[ii])
+			output_data = ii[OUTPUT_WIDTH-1:0];
+end
+
+endmodule

samples/SystemVerilog/util.vh

@@ -0,0 +1,8 @@
+function integer log2;
+  input integer x;
+  begin
+    x = x-1;
+    for (log2 = 0; x > 0; log2 = log2 + 1)
+      x = x >> 1;
+  end
+endfunction

samples/TeX/problemset.cls

@@ -0,0 +1,380 @@
+% =====================================
+% problemset Document Style
+%   For Problem Sets
+%
+% Options:
+% final      hides to-dos
+% worksheet  hides solutions and places each problem on separate page
+% expand     places each problem on a separate page
+% =====================================
+
+\ProvidesClass{problemset}
+\DeclareOption*{\PassOptionsToClass{final}{article}}
+\DeclareOption{worksheet}{\providecommand{\@solutionvis}{0}}
+\DeclareOption{expand}{\providecommand{\@expand}{1}}
+\ProcessOptions\relax
+
+% ================== Packages and Document Options ==================
+\LoadClass[10pt,letterpaper]{article}
+\RequirePackage[%
+        top=0.85in,
+        bottom=1in,
+        left=1in,
+        right=1in
+        ]{geometry}
+\RequirePackage{pgfkeys}    % For mathtable environment.
+\RequirePackage{tabularx}   % For pset heading
+\RequirePackage{float}      % Used for floats (tables, figures, etc.)
+\RequirePackage{graphicx}   % Used for inserting images.
+\RequirePackage{enumerate}  % Used for the enumerate environment.
+\RequirePackage{mathtools}  % Required. Loads amsmath.
+\RequirePackage{amsthm}     % Required. Used for theorem environments.
+\RequirePackage{amssymb}    % Required.
+\RequirePackage{booktabs}   % Required. Used for mathtable environment.
+\RequirePackage{esdiff}     % For derivatives and partial derivatives
+\RequirePackage{mathtools}  % Optional. Used for \shortintertext.
+\RequirePackage{fancyhdr}   % Required. For customizing headers/footers.
+\RequirePackage{lastpage}   % Required. For page count in header/footer.
+\RequirePackage{xcolor}     % Required. For setting the color of hyperlinks
+\RequirePackage[%
+        obeyFinal,          % Disable todos by setting [final] option for class
+        color=@todoclr,
+        linecolor=red
+        ]{todonotes}        % For keeping track of to-dos.
+\RequirePackage[%
+        colorlinks=true,
+        linkcolor=navy,
+        urlcolor=black
+        ]{hyperref}         % For following urls and references in a document.
+\RequirePackage{url}        % Enables urls with the \url tag
+\RequirePackage[all]{hypcap}
+% hypcap: Links go to object instead of caption. [Keep as last package]
+
+% ==================   Appearance Settings   ==================
+\definecolor{@todoclr}{gray}{0.80}   % For To-Dos. 50% brightness
+\definecolor{navy}{RGB}{0,0,150}     % For coloring hyperlinks
+\setlength{\parskip}{1.5ex}          % Sets space between paragraphs.
+\setlength{\parindent}{0pt}          % Indent for first line of new paragraphs.
+
+% Smaller verbatim type size
+\let\VERBATIM\verbatim
+\def\verbatim{%
+  \def\verbatim@font{\small\ttfamily}%
+\VERBATIM}
+
+% =============   Caption Modifications   =============
+\usepackage[small]{caption}
+\usepackage[footnotesize]{subcaption}
+    % For no visible number, use: \caption*{Unnumbered figure caption.}
+\captionsetup[table]{labelformat=simple, labelsep=period, labelfont=bf}
+\captionsetup[figure]{labelformat=simple, labelsep=period, labelfont=bf}
+\captionsetup[subtable]{labelformat=parens, labelsep=space, labelfont=bf}
+\captionsetup[subfigure]{labelformat=simple, labelsep=period, labelfont=bf}
+
+% ==================     Booleans     ==================
+\def\TRUE{1}
+\def\FALSE{0}
+\def\SHOW{1}
+\def\HIDE{0}
+
+% ============= Gets Document Info, Generates Heading =============
+\providecommand{\heading}[5][]{
+  \thispagestyle{empty}
+  \listoftodos
+  \clearpage
+  \pagenumbering{arabic}
+  %
+  \providecommand{\shortname}{#1}
+  \providecommand{\authorname}{#2}
+  \providecommand{\coursename}{#3}
+  \providecommand{\assignment}{#4}
+  \providecommand{\duedate}{#5}
+  \begin{minipage}{0.5\textwidth}
+    \begin{flushleft}
+      \hypertarget{@assignment}{
+        \textbf{\assignment}
+      }\\
+      \authorname
+    \end{flushleft}
+  \end{minipage}
+  \begin{minipage}{0.5\textwidth}
+    \begin{flushright}
+      \coursename\\
+      \duedate\\
+    \end{flushright}
+  \end{minipage}
+  \thispagestyle{empty}
+}
+
+% ============= Headers and Footers =============
+\renewcommand{\headrulewidth}{0pt}
+\renewcommand{\footrulewidth}{0.5pt}
+\pagestyle{fancyplain}
+\fancyhf{}
+\lfoot{%
+\fancyplain{}{%
+  \hyperlink{@assignment}{%
+    \small{%
+      \color{black}{%
+        \assignment
+      }
+    }
+  }
+}
+}
+\cfoot{%
+\fancyplain{}{%
+    \small{%
+      \coursename
+    }
+}
+}
+\rfoot{%
+\fancyplain{}{%
+  \small{\shortname~\thepage~of~\pageref{LastPage}}
+}
+}
+
+% ============= Problem Command =============
+% INPUT: Points for question [#1] (Optional)
+\newcounter{theproblem} % Problem counter for environment
+
+\providecommand{\problem}[1][]{%
+  \addtocounter{theproblem}{1}%
+  \setcounter{table}{0}%
+  \setcounter{figure}{0}%
+  \setcounter{equation}{0}%
+  \noindent%
+  \textbf{%
+      Problem~\arabic{theproblem}.}~\textit{\small{#1}}
+
+}
+
+% ============= QED, Page Breaks After QED? =============
+\providecommand{\@expand}{\HIDE}  % Default is to omit pagebreaks after the solution
+\providecommand{\qqed}{\hfill\rule{2mm}{2mm}\ifnum\@expand=\SHOW\\\pagebreak\fi}
+
+
+% ============= Solution Command =============
+\providecommand{\@solutionvis}{1}  % Default setting is to show solutions.
+\providecommand{\solution}[2][\@solutionvis]{
+\vspace{0.5em}\noindent\textbf{Solution.}
+\ifnum#1=\SHOW%
+#2
+
+\hfill\qqed\vspace{0.1em}
+\else%
+\pagebreak%
+\fi
+}
+
+% ============= Chapter, Section, Item Commands =============
+\providecommand{\chap}[2][0]{
+\ifnum#1=0%
+\else%
+\setcounter{section}{#1}%
+\addtocounter{section}{-1}%
+\fi%
+\vspace{-1.75em}%
+\section{#2}
+}
+
+\providecommand{\sect}[2][0]{
+\ifnum#1=0%
+\else%
+\setcounter{subsection}{#1}%
+\addtocounter{subsection}{-1}%
+\fi%
+\vspace{-0.5em}%
+\subsection{#2}
+}
+
+\providecommand{\subsect}[1]{\noindent\textbf{#1.}}
+
+% ============= Insert Non-Float Image =============
+\providecommand{\insertgraphic}[2][0.5\textwidth]{
+\vspace{-1em}
+\begin{center}
+  \includegraphics[width=#1]{#2}
+\end{center}
+\vspace{-1em}
+}
+
+
+
+% ============= Object Numbering by Problem =============
+\renewcommand{\thetable}{\arabic{theproblem}.\arabic{table}}
+\renewcommand{\thefigure}{\arabic{theproblem}.\arabic{figure}}
+\renewcommand{\theequation}{\arabic{theproblem}.\arabic{equation}}
+
+
+% ============= Formula Environment =============
+\newcounter{formula}
+\newenvironment{formula}[1][Formula \arabic{formula}]
+{
+  \addtocounter{formula}{1}
+  \begin{displaymath}
+  \tag*{\parbox{5em}{\textbf{\small{#1}}}}
+}{
+  \end{displaymath}\\
+}
+
+% ============= Math Table =============
+\newif\ifcaption
+\pgfkeys
+{
+  /mypkg/title/.store in=\Caption,% Any value assigned to title will be stored in \Caption
+  /mypkg/title= ,              % Initialize so \Caption exists
+   /mypkg/label/.store in=\Label,  % Any value assigned to label will be stored in \Label
+   /mypkg/label= ,              % Initialize so \Label exists
+   /mypkg/caption/.is if=caption,  % Declare a boolean, defaults to false
+}
+\newenvironment{mathtable}[2][]{
+  \pgfkeys{/mypkg/.cd, #1}%
+  \vspace{-1em}%
+  \begin{table}[ht!]%
+  \small \begin{center}%
+  \begin{displaymath}%
+  \begin{array}{#2}%
+  \toprule
+}{
+  \bottomrule
+  \end{array}%
+  \end{displaymath}%
+  \ifcaption%
+  \vspace{-1em}\caption{\Caption}\label{\Label}%
+  \fi%
+  \end{center}%
+  \end{table}%
+  \vspace{-1em}%
+}
+
+
+% ============= Double-line Column-Heading for table =============
+\providecommand{\double}[2]{%
+  \multicolumn{1}{c}{%
+    \genfrac{}{}{0pt}{}{\text{#1}}{\text{#2}}
+  }
+}
+
+
+% ============= Theorem-Style Environments =============
+\theoremstyle{plain}          % Bold label, italic letters
+\newtheorem{thm}{Theorem}[section]    % Numbered by section
+\newtheorem{lma}[thm]{Lemma}
+\newtheorem{crl}[thm]{Corollary}
+\newtheorem{prp}[thm]{Proposition}
+\newtheorem{cnj}[thm]{Conjecture}
+\newtheorem{alg}[thm]{Algorithm}
+
+% Associated environments (for numbered theorem environments)
+\newenvironment{theorem}[2][]{\begin{thm}[#1]\label{#2}}{\end{thm}}
+\newenvironment{lemma}[2][]{\begin{lma}[#1]\label{#2}}{\end{lma}}
+\newenvironment{corollary}[2][]{\begin{crl}[#1]\label{#2}}{\end{thm}}
+\newenvironment{proposition}[2][]{\begin{prp}[#1]\label{#2}}{\end{crl}}
+\newenvironment{conjecture}[2][]{\begin{cnj}[#1]\label{#2}}{\end{cnj}}
+\newenvironment{algorithm}[2][]{\begin{alg}[#1]\label{#2}}{\end{alg}}
+
+\theoremstyle{remark}          % Italic label, roman letters
+\newtheorem{rmk}{Remark}[section]    % Numbered by section. Remarks are used to expand on and integrate material.
+\newtheorem*{note}{Note}        % Un-numbered. Notes are used to comment on specific elements of the material.
+\newtheorem*{caveat}{Caveat}      % Un-numbered. Caveats are used to guide the reader away from a common error.
+\newtheorem*{warning}{Warning}      % Un-numbered. Warnings are used to guide away from especially egregious errors.
+
+\theoremstyle{definition}        % Bold label, roman letters
+\newtheorem{dfn}{Definition}[section]  % Numbered by section. Definitions of concepts and terms.
+\newtheorem{exm}{Example}[section]    % Numbered by section. Illustrative examples.
+\newtheorem{smm}{Summary}[subsection]  % Numbered by subsection. For section summaries.
+\newtheorem*{question}{Question}    % Un-numbered. For questions to motivate further analysis.
+\newtheorem*{speculation}{Speculation}  % Un-numbered. For questions that arise but will not be immediately answered.
+
+% Associated environments (for numbered theorem environments)
+\newenvironment{remark}[2][]{\begin{rmk}[#1]\label{#2}}{\end{rmk}}
+\newenvironment{definition}[2][]{\begin{dfn}[#1]\label{#2}}{\end{dfn}}
+\newenvironment{example}[2][]{\begin{exm}[#1]\label{#2}}{\end{exm}}
+\newenvironment{summary}[2][]{\begin{smm}[#1]\label{#2}}{\end{smm}}
+
+
+% ============= Greek Letters =============
+\renewcommand{\a}{\ensuremath{\alpha}}
+\renewcommand{\b}{\ensuremath{\beta}}
+\renewcommand{\c}{\ensuremath{\gamma}}
+\newcommand{\ch}{\ensuremath{\chi}}
+\renewcommand{\d}{\ensuremath{\delta}}
+\newcommand{\ep}{\ensuremath{\epsilon}}
+\newcommand{\et}{\ensuremath{\eta}}
+\newcommand{\ve}{\ensuremath{\varepsilon}}
+\renewcommand{\r}{\ensuremath{\rho}}
+\newcommand{\s}{\ensuremath{\sigma}}
+\renewcommand{\t}{\ensuremath{\tau}}
+\newcommand{\f}{\ensuremath{\psi}}
+\newcommand{\w}{\ensuremath{\omega}}
+\newcommand{\h}{\ensuremath{\phi}}
+\newcommand{\m}{\ensuremath{\mu}}
+\renewcommand{\l}{\ensuremath{\lambda}}
+\renewcommand{\k}{\ensuremath{\kappa}}
+\renewcommand{\v}{\ensuremath{\nu}}
+\renewcommand{\i}{\ensuremath{\iota}}
+\renewcommand{\o}{\ensuremath{\theta}}
+\newcommand{\z}{\ensuremath{\zeta}}
+
+% ============= Mathematical Symbols =============
+\providecommand{\NN}{\ensuremath{\mathbb{N}}}
+\providecommand{\ZZ}{\ensuremath{\mathbb{Z}}}
+\providecommand{\QQ}{\ensuremath{\mathbb{Q}}}
+\providecommand{\RR}{\ensuremath{\mathbb{R}}}
+\providecommand{\CC}{\ensuremath{\mathbb{C}}}
+\providecommand{\pd}{\partial}    % 'dee' symbol for partial derivatives
+\providecommand{\dd}{\mathrm{d}} % 'dee' symbol for ordinary derivatives
+\providecommand{\x}{\times}
+\providecommand{\n}{\scalebox{0.6}[1.0]{\ensuremath{-}}}
+
+
+
+% ============= Mathematical Macros =============
+\providecommand{\Sum}[3][n]{\ensuremath{\sum_{{#1}={#2}}^{#3}}}     % Sum from [n]={1}to{2}.     \Sum{1}{10}
+\providecommand{\infsum}[2][n]{\ensuremath{\sum_{{#1}={#2}}^\infty}}  % Infinite sum from [n]={1}    \infsum{1}
+\providecommand{\Int}[4][x]{\ensuremath{\int_{#3}^{#4}\!{#2}\,\mathrm{d}{#1}}}   % Integrate {1} from {2} to {3} with respect to [x]
+\providecommand{\Lim}[3][\infty]{\ensuremath{\displaystyle \lim_{{#2}\to{#1}}\!\!{#3}}} % Take the limit from {1} to [infinity] of {3} \Lim{x}{f(x)}
+\providecommand{\Frac}[2]{\ensuremath{\,^{#1}\!/\!_{#2}}}            % Slanted fraction with proper spacing. Usefule for in-line display of fractions.
+\providecommand{\eval}[3]{\ensuremath{\left[ #1 \right \vert_{#2}^{#3}}}
+\renewcommand{\L}{\left}              % for left-hand right-sizing
+\providecommand{\R}{\right}            % for right-hand right-sizing
+\providecommand{\D}{\diff}            % for writing derivatives
+\providecommand{\PD}{\diffp}          % for writing partial derivatives
+\providecommand{\full}{\displaystyle}      % Forces display style in math mode
+\providecommand{\Deg}{\ensuremath{^\circ}}    % for adding a degree symbol, even if not in math mode
+\providecommand{\abs}[1]{\left\vert #1 \right\vert}   % Absolute Value
+\providecommand{\norm}[1]{\left \Vert #1 \right \Vert}  % Norm (vector magnitude)
+\providecommand{\e}[1]{\ensuremath{\times 10^{#1}}}    % Scientific Notation with times symbol
+\providecommand{\E}[1]{\ensuremath{10^{#1}}}  % Scientific Notation
+\renewcommand{\u}[1]{\text{ #1}}        % For inserting units in Roman text
+\providecommand{\mc}{\text{,}\hspace{1em}}    % For inserting comma and space into math mode
+\providecommand{\mtxt}[2][]{#1\hspace{0.5em}\text{#2}\hspace{0.5em}}  % For insterting text into math mode with space on either side. Option for preceding punctuation.
+
+% ============= Probability and Statistics =============
+\providecommand{\prob}[1]{\ensuremath{P\!\left(#1\right)} }
+\providecommand{\cndprb}[2]{\ensuremath{P\!\left(#1 \left\vert  #2 \right.  \right)} }
+\providecommand{\cov}[1]{\ensuremath{\text{Cov}\!\left(#1\right)} }
+\providecommand{\ex}[1]{\ensuremath{E\!\left[#1\right]} }
+
+% ============= Linear Algebra =============
+
+% Column vectors
+\providecommand{\twovector}[3][r]{\left(\begin{array}{#1} #2 \\ #3\end{array}\right)}
+\providecommand{\threevector}[4][r]{\left(\begin{array}{#1}  #2 \\ #3 \\ #4\end{array}\right)}
+\providecommand{\fourvector}[5][r]{\left(\begin{array}{#1}  #2 \\ #3 \\ #4 \\ #5 \end{array}\right)}
+
+% ============= Vector Calculus =============
+% ------------- Susan Lea's notation ---------------
+\providecommand{\vecs}[1]{\ensuremath{\vec{\bm{#1}}} }  % bolded symbol, arrow
+\providecommand{\vect}[1]{\ensuremath{\vec{\textbf{#1}}} }  % bolded text, arrow
+\providecommand{\unitvecs}[1]{\bm{\hat{#1}}}
+\providecommand{\unitvect}[1]{\hat{\textbf{#1}}}
+\providecommand{\Div}[1]{\vecs{\del} \cdot \vect{#1}}
+\providecommand{\Curl}[1]{\vecs{\del} \times \vect{#1}}
+\providecommand{\Grad}{\vecs{\del}}
+
+
+
+