src += $(wildcard src/*/*.c)
test_dir_all := $(wildcard tests/*)
-test_ignore = tests/benchmark tests/import
+test_ignore = tests/import
test_dir := $(filter-out $(test_ignore), $(test_dir_all))
test_dir += examples
include $(wildcard .d/*.d)
include util/intl.mk
-include docs.mk
+++ /dev/null
-ifeq (,$(wildcard docs/config.mk))
-$(shell cp docs/config.mk.orig docs/config.mk)
-endif
-include docs/config.mk
-
-mdr_list = $(filter-out docs/09_Benchmarks.mdr, $(shell find docs -type f -name "*.mdr"))
-md_list = $(mdr_list:.mdr=.md)
-
-_docserver_config = bash scripts/doc-config.sh > mkdocs.yml
-_docserver_serve = $(call _docserver_config); $(DOCTOOL) -q serve
-_docserver_launch = $(call _docserver_serve)& echo $$! > .server_pid
-_docserver_kill = [ -f .server_pid ] && (kill $$(cat .server_pid); rm .server_pid) || true
-_mdr_wait=$$(inotifywait -q -r docs --format "%w%f" | tail -n1)
-
-doc-run:
- @bash -c "trap 'trap - SIGINT SIGTERM ERR; $(MAKE) -s doc-clean; exit 1' SIGINT SIGTERM ERR; $(MAKE) -s doc-watch"
-
-doc-watch: ${md_list}
- @$(call _docserver_launch)
- @while true; do file=$(call _mdr_wait); echo $$file | grep '\.mdr$$' && mdr $$file; done
-
-doc-serve: $(md_list)
- @$(call _docserver_serve)
-
-doc-clean:
- -@$(call _docserver_kill)
- @rm -rf *.gw vlog log $(md_list) .tmp_list .mdr_list site
-
-doc-build: $(md_list)
- $(DOCTOOL) build
-
-doc-deploy: $(md_list)
- -@$(call _docserver_config)
- @$(DOCTOOL) gh-deploy
- @$(MAKE) -s doc-clean
-
-.PHONY: mdr_loop watch serve clean run
-
-.SUFFIXES: .mdr .md
-.mdr.md:
- $(info compiling $<)
- @mdr $< ||:
-
-.SUFFIXES: .gw .test
-.gw.test:
- @${VALGRIND} ${VALGRIND_OPT} gwion $< 2>&1 > log
- @[ -t 1 ] && $(call _interm) || $(call _noterm)
-
-define _test_check
- for a in $(CONTAINS); do grep "$$a" log >/dev/null; done && valgrind_parse vlog
-endef
-
-_interm_status=printf "$(INTERM_OK)\n" || printf "$(INTERM_NOT_OK)\n"
-_interm=(cat log; $(call _test_check) && $(call _interm_status))
-
-_noterm_log=sed 's/$$/\<br\/>/' log
-_noterm_status=printf "$(NOTERM_OK)\n" || printf "$(NOTERM_NOT_OK)\n"
-_noterm_test=$(call _test_check) && $(call _noterm_status)
-_noterm_header=echo '<p style=$(CSS)>'
-_noterm_footer=echo '</p>'
-_noterm=($(call _noterm_header); $(call _noterm_log); $(call _noterm_test); $(call _noterm_footer))
+++ /dev/null
-# Installing gwion
-
-## Get the sources
-
-The source is accessible on [github](https:#!github.com).
-
-Provided you have git installed, you can get it with:
-
-``` sh
-git clone https:#!github.com/fennecdjay/gwion
-```
-
-then change to the source directory
-``` sh
-cd gwion
-```
-
-### Don't forget submodules
-
-You'll need the sources for all base module
-``` sh
-git submodule update --init util ast
-```
-
-> At this point, you might want to configure the build.
- In this case, have a look at the [configuration page](Configure.md)
-
-
-## Build the libraries and program
-``` sh
-make
-```
-
-## Install the package
-
-``` sh
-make install
-```
-> You may need root privilege to do this.
+++ /dev/null
-# Configuring Gwion
-
-## util/config.mk
-
-double
-
-gettext
-
-memcheck
-
-lto
-
-coverage
-
-## ast/config.mk
-
-## config.mk
-Here are a few choices left
+++ /dev/null
-# Build / Configure Gwion
-
-## Configure
-### gwion-util
-
- * `USE_MEMCHECK`: compile with debug flags (`-g`) and enable asserts
- * `USE_COVERAGE`: add coverage instrumentation
-
-
-## Make
-Basically, all that is left to do is
-```sh
-make
-```
-The only environment variable affecting the operation is `PREFIX`
-
-Except `--(no-)double`, everything can be set when running make,
-using environment variables.
-
-Drivers can be set on using, e.g. for *alsa* : `ALSA_D=1` or `ALSA_D=on`.
-In the same way, then can be disabled with `ALSA_D=0` or `ALSA_D=off`
-
-### Running tests
-```bash
-make tests
-```
-to run all tests, or
-```bash
-bash util/test.sh my_file_or_directory (.. other files/dirs ...)
-```
-to run specific ones.
-look [here](#testing.md) for more.
-## Install
-*maybe as root*
-```sh
-make install
-```
-The only environment variable affecting the operation is `PREFIX`
+++ /dev/null
-# Keywords
-
- * fun/function
- * operator
- * return
- * goto
- * switch/case/default
- * if/else
- * break/continue
- * until/do/while/for/repeat
-
-
-
-
- * global/static
- * private/protect
- * const
-
- * new
- * spork
- * fork
- * typeof
-
- * typedef
- * class
- * dtor
- * extends
- * enum
- * union
-
- * auto
+++ /dev/null
-# Makefile
-
-## Basic operations
-
-## translations
-
-## Docs
+++ /dev/null
-# Special Values
-
- * me
- * this
- * vararg
- * maybe
+++ /dev/null
-# Tests
-[test.sh](https:#!github.com/fennecdjay/Gwion/blob/dev/util/test.sh)
-requires [valgrind](http:#!valgrind.org/)
-there are two kinds of tests:
- * [gwion](#gwion-tests)
- * [bash](#bash-tests)
-
-## Gwion tests
-those tests are just gwion (.gw) files, handling special comments:
- * `#! [skip]` (*optionally* followed by reason to skip)
- * `#! [todo]` (*optionally* followed by reason to delay testing)
- * `#! [contains]` followed by string to match
- * `#! [excludes]` followed by string not to match
-
-## Shell test
-those tests are just bash (.sh) files.
-they should start with this snippet
-```bash
-#!/bin/bash
-# [test] #5
-n=0
-[ "$1" ] && n="$1"
-[ "$n" -eq 0 ] && n=1
-source tests/sh/common.sh
-```
-
-## TODO
- [ ] `bailout` system for early exit on failure
+++ /dev/null
-# Declarations
-
-## Basics
-
-Declaring a primitive or an object is quite straight forward:
-@``` decl0.gw
-int i;
-Object o;
-<<< i, " ", o >>>;
-@```
-@exec gwion decl0.gw 2>&1
-
-## Declaring a reference
-However ...
-@``` decl1.gw
-Object @ref;
-<<< "Reference points to no object yet: ", ref >>>;
-#!Object o @=> ref;
-new Object @=> ref;
-<<< "But now it does: ", ref >>>;
-@```
-@exec make decl1.test
-
-## Arrays
-
-### array as refs
-
-@``` decl2.gw
-int ref[];
-<<< ref >>>;
-new int[2] @=> ref;
-<<< ref >>>;
-@```
-@exec make decl2.test
+++ /dev/null
-# Global Values
-
- * adc
- * blackhole
- * dac
- * pi
- * null
- * samp
- * ms
- * second
- * hour
- * me
- * this
- * \__func__
- * \__file__
- * \__line__
+++ /dev/null
-# Primitive types
+++ /dev/null
-# Enums
-
-For those who don't know about enumerated types,
-you can read about those
-[here](https://www.geeksforgeeks.org/enumeration-enum-c) and
-[here](https://en.wikipedia.org/wiki/Enumerated_type)
-
-## Enums in gwion
-You simply use an enum like this
-``` enum0.gw
-enum Optionnal_name {
- zero, one, two
-};
-<<< zero, one, two >>>;
-```
-
-When inside a class,
-Enums are automatically declared **static**,
-but they accept **private** or **protect** specifiers.
-
-When not in a class, they can be made `global`
+++ /dev/null
-# Union types
+++ /dev/null
-# Typedefs
+++ /dev/null
-# Function Pointers
+++ /dev/null
-# Lambda
-
-## Overview
-
-Simply put, *lambda*s are anonymous functions.
-
-The syntax to create them is simple:
-```
-\ variable0 variable1 ... { your code here }
-```
-You can even use it to
-### Call a function just once
-@``` lambda_call0.gw
-\ i { <<< "passed '", i, "'" >>>; }(3);
-@```
-@exec make -s CONTAINS="passed '3'" lambda_call0.test
-
-
-## Use case
-
-### Passing to a function pointer
-@``` lambda_fptr0.gw
-typedef void fptr_t(int);
-\ i { <<< "passed '", i, "'" >>>; } @=> fptr_t fptr;
-fptr(4);
-@```
-@exec make -s CONTAINS="passed '4'" lambda_fptr0.test
-
-### As Argument to Functions
-@``` lambda_args0.gw
-typedef void fptr_t(int);
-fun void test(fptr_t fptr) {
- fptr(5);
-}
-test(\ i { <<< "passed '", i, "'" >>>; });
-@```
-@exec make -s CONTAINS="passed '5'" lambda_args0.test
+++ /dev/null
-# Variadic functions
-
-> A function whoses arity is not fixed.
-
-Well, a function that takes a fixed number of arguments, and additionnal ones.
-
-## a simple example
-@``` variadic.gw
-fun void variadic_test(int i, ...) {
- <<< "first argument is ", i >>>;
- vararg.start;
- <<< "\tadditionnal argument", vararg.i >>>;
- vararg.end;
-}
-variadic_test(1);
-variadic_test(1, 2);
-variadic_test(1, 2, 3);
-@```
+++ /dev/null
-# Functions
-
-## a simple (commented example)
-
-@``` function0.gw
-#! declare function 'test_function'
-#! with return type int
-#! taking an int as argument
-fun int test_function(int arg) {
- #! return the argument + 2
- return arg + 2;
-}
-
-#! now call the function (and debug print the result)
-<<< test_function(0) >>>;
-#! or use alternate syntax
-<<< 1 => test_function >>>;
-@```
-@exec make -s function0.test
+++ /dev/null
-# Control Flow
-
-## Repeats
-let start simple ;-)
+++ /dev/null
-# the Repeat keyword
-let start simple ;-)
-The easiest way to do an action repeatidly in Gwion is, ... the **repeat** keyword!
-
-## Very basic example
-@``` repeat.gw
-repeat(3)
- <<< "Hello, world!" >>>;
-@```
-@exec make -s CONTAINS="Hello" repeat.test
-
-## Block example
-of course this also works with a block code.
-
-@``` repeat2.gw
-repeat(3) {
- maybe ? "You" : "Me" => string s;
- <<< "Hello, ", s, "!" >>>;
-}
-@```
-@exec make -s CONTAINS="Hello" repeat2.test
+++ /dev/null
-# For Loops
-**For** loops in Gwion is pretty similar to classic **C** syntax
-
-## basic loops
-@``` forloop0.gw
-for(int i; i < 3; ++i)
- <<< i >>>;
-@```
-@exec make -s forloop0.test
-
-Of course, it also works with a block of code.
-
-@``` forloop2.gw
-for(int i; i < 3; ++i) {
- i/2 => float f1;
- i/2. => float f2;
- <<< i, " " , f1, " ", f2 >>>;
-}
-@```
-@exec make -s forloop2.test
-
-## Nested Loops
-@``` forloop3.gw
-int array[3][4];
-
-for(int i; i < 3; ++i) {
- for(int j; j < 4; ++j) {
- <<< array[i][j] >>>;
- }
-}
-@```
-@exec make -s forloop3.test
-
-### Auto Loops
-
-#### Simple auto loop
-@``` forloop4.gw
-int array[2][3];
-for(auto a: array) {
- <<< a >>>;
- for(auto b: a)
- <<< b >>>;
-}
-@```
-@exec make -s forloop4.test
-
-### Auto Pointer loop
-With the simple auto loop, you only get the value in the array.
-If you want to change it, you need a pointer
-
-@``` forloop5.gw
-int array[2][3];
-int i;
-for(auto a: array) {
- for(auto @b: a)
- <<< ++i => *b >>>;
-}
-for(auto a: array) {
- for(auto @b: a)
- <<< *b >>>;
-}
-@```
-@exec make -s forloop5.test
+++ /dev/null
-# Loops
-
-@``` while0.gw
-while(true) {
- if(maybe)
- break;
- <<< "running..." >>>;
-}
-@```
-@exec make -s while0.test
-
-well this may output nothing...
-lets try
-
-@``` while1.gw
-<<< maybe >>>;
-do{
- if(maybe)
- break;
- <<< "running..." >>>;
-} while(true);
-@```
-@exec make -s while1.test
+++ /dev/null
-# Giving gwion a new driver
-
-## basics
-
-> in order to use GWION_CTL ...
-
-# concept
-
-# upd driver
+++ /dev/null
-# Writing a Gwion plugin
-
-> THIS IS OUTDATED. please look at the source code in src/lib/ instead
-
- * [getting started]
-
-## Getting started
-use the script
-
-### headers
-```
-#include "vm.h"
-#include "instr.h"
-#include "import.h
-```
-<!-- TODO: verify this -->
-
-### Class
-Define the type:
-```
-struct Type_ t_mytype = { "MyType", SZ_INT, &t_object};
-```
-> every type extending t_object should have SZ_INT
-
-### Handling Constructors and Destructors
-#### CTOR
-```
-CTOR(mytype_ctor) {
- /* constructor code here */
-}
-```
-#### DTOR
-```
-DTOR(mytype_dtor) {
- /* destructor code here */
-}
-```
-
-those macros provide two variables:
- * `o`: the *M_Object* for the (con/des)tructor
- * `shred`: the *VM_Shred* for the (con/des)tructor
-
-```
-CHECK_BB(import_class_begin(env, &t_mytpe, env->global_nspc, mytype_ctor, mytype_dtor))
-```
-#### variable
-declare a `m_int`. coding convention require
- * a leading *_o*
- * a following *_type_*
-```c
-m_int o_mytype_myvaroffset;
-```
-#### function
-```c
-/* declare a member function */
-MFUN(mytype_memberfunction) {
- /* code here */
-}
-
-SFUN(mtype_staticfunction) {
- /* code here */
-}
-```
-
-#### operator
-
-### Import function
-
+++ /dev/null
-# Gwion Preprocessor
+++ /dev/null
-# Contributing translations
-
-First off, thank you for considering translating gwion.
-
-Thanks to the build system, you're gonna get on tracks fast.
-
-
-> You might want to export TRANSLATION_TARGET,
-so you don't have to set it on the command line for commands requiring it
-`export TRANSLATION_TARGET="xxx"`
-
-## 1) Init the translation language
-
-You have to make sure there is a directory for your target language (e.g.: fr, en, es_ES ...).
-
-``` sh
-make translation-init TRANSLATION_TARGET=<xxx>
-```
-
-Where `<xxx>` is your language of choice.
-It will fail if your language already exists, but this is not a problem.
-
-## 2) Edit
-
-Next, you should adjust the translations.
-What about using your favorite editor?
-
-``` sh
-make translation-edit TRANSLATION_TARGET=<xxx>
-```
-
-## 3) Update
-
-Maybe the sources changed, and there is more message to translate?
-
-``` sh
-make translation-update
-```
-
-This will update all languages.
-You can now get back to [step 2](#2-Edit).
-
-## Add to VCS
-
-It's now time to add your changes to the package
-
-``` sh
-make translation-commit TRANSLATION_TARGET=<xxx>
-```
-
-Now please submit a pull request.
+++ /dev/null
-# Benchmarks
-
-We'll need a bash script
-
-<link rel=styleSheet href="../assets/doc.css" TYPE="text/css"><div id="org-categories"><ul class="lev1"><li><a href="#">Show the code</a></li><ul class="lev2"><a href="#">
-@``` benchmark.sh
-#!/bin/sh
-language=("gwion" "wren" "lua")
-extension=("gw" "wren" "lua")
-test_dir="tests/benchmark"
-plot_script="bench.plot"
-: "${repeats:=10}"
-
-run() {
- perf stat -r"$repeats" "$1" "$test_dir/$3.$2" 2>&1 | grep "time elapsed" |
- sed 's/ *\([0-9]*\),\([0-9]*\) .* seconds time elapsed *( +- *\([0-9]*\),\([0-9]*\)% )/\1.\2 \3.\4/'
-}
-
-get_list() {
- for file in $test_dir/*.gw
- do basename "$file" .gw
- done
-}
-
-get_test() {
- for (( i=0; i<=$(( ${#language[@]} -1 )); i++ ))
- do
- if [ -f "$test_dir/$1.${extension[$i]}" ]
- then echo "${language[$i]} $(run "${language[$i]}" "${extension[$i]}" "$1")"
- fi
- done > "docs/assets/benchmark/$1.dat"
-}
-
-plot() {
- gnuplot -e "bench='$1'" "$plot_script"
-}
-
-for bench in $(get_list)
-do
-echo $bench
- get_test "$bench"
- plot "$bench"
- echo "### $bench"
- echo '<link rel=styleSheet href="../assets/doc.css" TYPE="text/css"><div id="org-categories"><ul class="lev1"><li><a href="#">Show the code</a></li><ul class="lev2"><a href="#">'
- echo "\`\`\`"
- cat "$test_dir/$bench.gw"
- echo "\`\`\`"
- echo '</a></a></li></ul></ul></div>'
- echo ""
-done
-@```
-</a></a></li></ul></ul></div>
-
-### and a gnuplot script
-
-<link rel=styleSheet href="../assets/doc.css" TYPE="text/css"><div id="org-categories"><ul class="lev1"><li><a href="#">Show the code</a></li><ul class="lev2"><a href="#">
-@``` bench.plot
-set terminal png truecolor
-
-#if (!exists("bench"))
-# bench = 'bench'
-if (!exists("test_dir"))
- test_dir = 'tests/benchmark'
-
-dat_name = sprintf("docs/assets/benchmark/%s.dat", bench)
-
-stats dat_name using 0:2 noout
-max = STATS_max_y+(0.1*STATS_max_y)
-
-set title bench
-set output sprintf("docs/assets/benchmark/%s.png", bench)
-set xrange [-0.5:((ceil(STATS_max_x))+0.5)]
-set yrange [0:max]
-set boxwidth 0.50
-set nokey
-set xtics nomirror
-set ytics nomirror
-
-set style fill transparent solid 0.25 # partial transparency
-set style fill noborder # no separate top/bottom lines
-
-plot dat_name using 0:2:($2*($3/100.0)):xtic(2) with boxerrorbar lc "blue" notitle, \
- '' using 0:(max-(0.05*max)):1 with labels
-@```
-</a></a></li></ul></ul></div>
-
-## Show the results
-Then just run it
-@exec bash benchmark.sh; rm bench.plot benchmark.sh
+++ /dev/null
-# How this doc is build
-
-## mdr
-
-## makefile
-
-## mkdocs
+++ /dev/null
-# Benchmarks
-
-@``` benchmark.sh
-@[[shebang]]
-@[[languages]]
-@[[options]]
-@[[functions]]
-@```
-
-@``` shebang
-#!/bin/sh
-
-@```
-
-
-@``` languages
-#those must match!
-language=("gwion" "wren" "lua")
-extension=("gw" "wren" "lua")
-
-@```
-
-@``` options
-test_dir="tests/benchmark"
-plot_script=bench.plot
-
-# runtime options
-@[[runtime]]
-@```
-
-@``` runtime
-# allow this to be set by environment
-: "${repeats:=10}"
-
-@```
-
-@``` functions
-# bunch of stuff here
-@[[run]]
-@@[[get_list]]
-@@[[get_test]]
-@@[[plot]]
-@@[[print]]
-@```
-
-@``` run
-run() {
- perf stat -r"$repeats" "$1" "$test_dir/$3.$2" 2>&1 |
- grep "time elapsed" |
- sed 's/ *\([0-9]*\),\([0-9]*\) .* seconds time elapsed *( +- *\([0-9]*\),\([0-9]*\)% )/\1.\2 \3.\4/'
-}
-@```
+++ /dev/null
- GNU GENERAL PUBLIC LICENSE
- Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
- The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works. By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users. We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors. You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
- To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights. Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received. You must make sure that they, too, receive
-or can get the source code. And you must show them these terms so they
-know their rights.
-
- Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
- For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software. For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
- Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so. This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software. The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable. Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products. If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
- Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary. To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- TERMS AND CONDITIONS
-
- 0. Definitions.
-
- "This License" refers to version 3 of the GNU General Public License.
-
- "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
- "The Program" refers to any copyrightable work licensed under this
-License. Each licensee is addressed as "you". "Licensees" and
-"recipients" may be individuals or organizations.
-
- To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy. The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
- A "covered work" means either the unmodified Program or a work based
-on the Program.
-
- To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy. Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
- To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies. Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
- An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License. If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
- 1. Source Code.
-
- The "source code" for a work means the preferred form of the work
-for making modifications to it. "Object code" means any non-source
-form of a work.
-
- A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
- The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form. A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
- The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities. However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work. For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
- The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
- The Corresponding Source for a work in source code form is that
-same work.
-
- 2. Basic Permissions.
-
- All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met. This License explicitly affirms your unlimited
-permission to run the unmodified Program. The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work. This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
- You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force. You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright. Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
- Conveying under any other circumstances is permitted solely under
-the conditions stated below. Sublicensing is not allowed; section 10
-makes it unnecessary.
-
- 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
- No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
- When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
- 4. Conveying Verbatim Copies.
-
- You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
- You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
- 5. Conveying Modified Source Versions.
-
- You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
- a) The work must carry prominent notices stating that you modified
- it, and giving a relevant date.
-
- b) The work must carry prominent notices stating that it is
- released under this License and any conditions added under section
- 7. This requirement modifies the requirement in section 4 to
- "keep intact all notices".
-
- c) You must license the entire work, as a whole, under this
- License to anyone who comes into possession of a copy. This
- License will therefore apply, along with any applicable section 7
- additional terms, to the whole of the work, and all its parts,
- regardless of how they are packaged. This License gives no
- permission to license the work in any other way, but it does not
- invalidate such permission if you have separately received it.
-
- d) If the work has interactive user interfaces, each must display
- Appropriate Legal Notices; however, if the Program has interactive
- interfaces that do not display Appropriate Legal Notices, your
- work need not make them do so.
-
- A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit. Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
- 6. Conveying Non-Source Forms.
-
- You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
- a) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by the
- Corresponding Source fixed on a durable physical medium
- customarily used for software interchange.
-
- b) Convey the object code in, or embodied in, a physical product
- (including a physical distribution medium), accompanied by a
- written offer, valid for at least three years and valid for as
- long as you offer spare parts or customer support for that product
- model, to give anyone who possesses the object code either (1) a
- copy of the Corresponding Source for all the software in the
- product that is covered by this License, on a durable physical
- medium customarily used for software interchange, for a price no
- more than your reasonable cost of physically performing this
- conveying of source, or (2) access to copy the
- Corresponding Source from a network server at no charge.
-
- c) Convey individual copies of the object code with a copy of the
- written offer to provide the Corresponding Source. This
- alternative is allowed only occasionally and noncommercially, and
- only if you received the object code with such an offer, in accord
- with subsection 6b.
-
- d) Convey the object code by offering access from a designated
- place (gratis or for a charge), and offer equivalent access to the
- Corresponding Source in the same way through the same place at no
- further charge. You need not require recipients to copy the
- Corresponding Source along with the object code. If the place to
- copy the object code is a network server, the Corresponding Source
- may be on a different server (operated by you or a third party)
- that supports equivalent copying facilities, provided you maintain
- clear directions next to the object code saying where to find the
- Corresponding Source. Regardless of what server hosts the
- Corresponding Source, you remain obligated to ensure that it is
- available for as long as needed to satisfy these requirements.
-
- e) Convey the object code using peer-to-peer transmission, provided
- you inform other peers where the object code and Corresponding
- Source of the work are being offered to the general public at no
- charge under subsection 6d.
-
- A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
- A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling. In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage. For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product. A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
- "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source. The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
- If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information. But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
- The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed. Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
- Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
- 7. Additional Terms.
-
- "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law. If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
- When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it. (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.) You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
- Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
- a) Disclaiming warranty or limiting liability differently from the
- terms of sections 15 and 16 of this License; or
-
- b) Requiring preservation of specified reasonable legal notices or
- author attributions in that material or in the Appropriate Legal
- Notices displayed by works containing it; or
-
- c) Prohibiting misrepresentation of the origin of that material, or
- requiring that modified versions of such material be marked in
- reasonable ways as different from the original version; or
-
- d) Limiting the use for publicity purposes of names of licensors or
- authors of the material; or
-
- e) Declining to grant rights under trademark law for use of some
- trade names, trademarks, or service marks; or
-
- f) Requiring indemnification of licensors and authors of that
- material by anyone who conveys the material (or modified versions of
- it) with contractual assumptions of liability to the recipient, for
- any liability that these contractual assumptions directly impose on
- those licensors and authors.
-
- All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10. If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term. If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
- If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
- Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
- 8. Termination.
-
- You may not propagate or modify a covered work except as expressly
-provided under this License. Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
- However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
- Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
- Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License. If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
- 9. Acceptance Not Required for Having Copies.
-
- You are not required to accept this License in order to receive or
-run a copy of the Program. Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance. However,
-nothing other than this License grants you permission to propagate or
-modify any covered work. These actions infringe copyright if you do
-not accept this License. Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
- 10. Automatic Licensing of Downstream Recipients.
-
- Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License. You are not responsible
-for enforcing compliance by third parties with this License.
-
- An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations. If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
- You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License. For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
- 11. Patents.
-
- A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based. The
-work thus licensed is called the contributor's "contributor version".
-
- A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version. For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
- Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
- In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement). To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
- If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients. "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
- If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
- A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License. You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
- Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
- 12. No Surrender of Others' Freedom.
-
- If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all. For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
- 13. Use with the GNU Affero General Public License.
-
- Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work. The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
- 14. Revised Versions of this License.
-
- The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation. If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
- If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
- Later license versions may give you additional or different
-permissions. However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
- 15. Disclaimer of Warranty.
-
- THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. Limitation of Liability.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
- 17. Interpretation of Sections 15 and 16.
-
- If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- <one line to give the program's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- 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 <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
- If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
- <program> Copyright (C) <year> <name of author>
- This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
- This is free software, and you are welcome to redistribute it
- under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
- You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
- The GNU General Public License does not permit incorporating your program
-into proprietary programs. If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library. If this is what you want to do, use the GNU Lesser General
-Public License instead of this License. But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+++ /dev/null
-gwion 0.19427 0.91
-wren 0.234493 0.25
-lua 0.3426 6.66
+++ /dev/null
-gwion 5.5088 0.55
-wren 13.830 0.81
-lua 7.4549 0.33
-
+++ /dev/null
-gwion 0.08750 1.21
-wren 0.22008 1.21
-lua 0.22026 0.70
+++ /dev/null
-gwion 0.037861 1.04
-wren 0.085946 0.68
-lua 0.055855 0.75
+++ /dev/null
-gwion 0.098407 0.66
-wren 0.114304 0.58
-lua 0.26571 1.24
+++ /dev/null
-gwion 0.165975 0.47
-wren 0.184180 0.38
+++ /dev/null
-li + .lev2 {
- display: none;
-}
-
-li:focus-within + .lev2 {
- display: block;
-}
+++ /dev/null
-# tool to build the doc
-DOCTOOL = mkdocs -q
-DOCBUILD = build
-DOCSERVE = serve
-
-# output box css
-BACKGROUND = background-color:\#f2f2f2;
-BORDER = border: 5px solid \#546e7a;
-PADDING = padding: 10px;
-MARGIN = margin-right: 20%; margin-left: 20%;
-BORDER_RADIUS = -moz-border-radius: 15px; -webkit-border-radius: 15px;
-CSS = "$(BACKGROUND) $(BORDER) $(PADDING) $(MARGIN) $(BORDER_RADIUS)"
-
-# output box status
-NOTERM_OK= &\#10004;
-NOTERM_NOT_OK= &\#10008;
-
-# terminal status
-INTERM_OK = \033[32mOK\033[0m
-INTERM_NOT_OK = \033[31mNOT OK\033[0m
-
-# valgrind
-VALGRIND ?= valgrind
-VALGRIND_LOG ?= vlog
-VALGRIND_OPT += --leak-check=yes --log-file=${VALGRIND_LOG}
-
-## ensure no valgrind if requested
-ifeq ($(VALGRIND), NO_VALGRIND)
-VALGRIND =
-VALGRIND_OPT =
-endif
-
+++ /dev/null
-# Welcome to Gwion
-
-gwion is a easy yet powerful, strongly-timed programming language,
-
-## And now for the hello world
-
-So, as it is mandatory, here is the piece of code you're waiting
-for:
-
-@``` helloworld.gw
-<<< "Hello, World!", "" >>>;
-@```
-@exec make -s CONTAINS="Hello, World!" helloworld.test
-
-## (Bag of) Features
- * [single inheritance](https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Design_constraints)
- * typedef (function pointers and type aliases)
- * enums and unions
- * templates (both class and functions)
- * easy concurrency/async
- * [lambdas](Functions/Lambdas)
- * memoization
- * [variadic](Functions/Variadic) functions
+++ /dev/null
-// Ported from the Python version.
-
-class Tree {
- construct new(item, depth) {
- _item = item
- if (depth > 0) {
- var item2 = item + item
- depth = depth - 1
- _left = Tree.new(item2 - 1, depth)
- _right = Tree.new(item2, depth)
- }
- }
-
- check {
- if (_left == null) {
- return _item
- }
-
- return _item + _left.check - _right.check
- }
-}
-
-var minDepth = 4
-var maxDepth = 12
-var stretchDepth = maxDepth + 1
-
-System.print("stretch tree of depth %(stretchDepth) check: " +
- "%(Tree.new(0, stretchDepth).check)")
-for (i in 1...1000) System.gc()
-
-var longLivedTree = Tree.new(0, maxDepth)
-
-// iterations = 2 ** maxDepth
-var iterations = 1
-for (d in 0...maxDepth) {
- iterations = iterations * 2
-}
-
-var depth = minDepth
-while (depth < stretchDepth) {
- var check = 0
- for (i in 1..iterations) {
- check = check + Tree.new(i, depth).check + Tree.new(-i, depth).check
- }
-
- System.print("%(iterations * 2) trees of depth %(depth) check: %(check)")
- for (i in 1...1000) System.gc()
-
- iterations = iterations / 4
- depth = depth + 2
-}
-
-System.print(
- "long lived tree of depth %(maxDepth) check: %(longLivedTree.check)")
-for (i in 1...1000) System.gc()
+++ /dev/null
-// Ported from the Wren version.
-
-class Tree {
- var _item;
- var _left;
- var _right;
-
- Tree(item, depth) {
- _item = item;
- if (depth > 0) {
- var item2 = item + item;
- depth--;
- _left = new Tree(item2 - 1, depth);
- _right = new Tree(item2, depth);
- }
- }
-
- get check {
- if (_left == null) {
- return _item;
- }
-
- return _item + _left.check - _right.check;
- }
-}
-
-main() {
- var minDepth = 4;
- var maxDepth = 12;
- var stretchDepth = maxDepth + 1;
-
- print("stretch tree of depth ${stretchDepth} check: "
- "${new Tree(0, stretchDepth).check}");
-
- var longLivedTree = new Tree(0, maxDepth);
-
- // iterations = 2 ** maxDepth
- var iterations = 1;
- for (var d = 0; d < maxDepth; d++) {
- iterations = iterations * 2;
- }
-
- var depth = minDepth;
- while (depth < stretchDepth) {
- var check = 0;
- for (var i = 1; i <= iterations; i++) {
- check += new Tree(i, depth).check + new Tree(-i, depth).check;
- }
-
- print("${iterations * 2} trees of depth ${depth} check: ${check}");
- iterations ~/= 4;
- depth += 2;
- }
-
- print("long lived tree of depth ${maxDepth} check: ${longLivedTree.check}");
-}
+++ /dev/null
-#! Ported from the Wren version.
-
-class Tree {
- int item;
- Tree @left, right;
-
- fun static Tree new_Tree(int it, int depth) {
- Tree t;
- it => t.item;
- if (depth > 0) {
- it + it => int item2;
- --depth;
- Tree.new_Tree(item2 - 1, depth) @=> t.left;
- Tree.new_Tree(item2, depth) @=> t.right;
- }
- return t;
- }
-
- fun int check() {
- if (!left)
- return item;
- return item + left.check() - right.check();
- }
-}
-
-4 => int minDepth;
-12 => int maxDepth;
-maxDepth + 1 => int stretchDepth;
-
-<<< "stretch tree of depth ", stretchDepth, " check: ",
- Tree.new_Tree(0, stretchDepth).check() >>>;
-
-Tree.new_Tree(0, maxDepth) @=> Tree@ longLivedTree;
-
-#! iterations = 2 ** maxDepth
-1 => int iterations;
-for (int d; d < maxDepth; ++d)
- 2 *=> iterations;
-
-minDepth => int depth;
-while (depth < stretchDepth) {
- int check;
- for (int i; i < iterations; ++i)
- Tree.new_Tree(i, depth).check() + Tree.new_Tree(-i, depth).check() +=> check;
-
- <<< iterations * 2, " trees of depth ", depth, " check: ", check >>>;
- 4 /=> iterations;
- 2 +=> depth;
-}
-
-<<< "long lived tree of depth ", maxDepth, " check: ", longLivedTree.check() >>>;
+++ /dev/null
--- The Computer Language Benchmarks Game
--- http://shootout.alioth.debian.org/
--- contributed by Mike Pall
-
-local function BottomUpTree(item, depth)
- if depth > 0 then
- local i = item + item
- depth = depth - 1
- local left, right = BottomUpTree(i-1, depth), BottomUpTree(i, depth)
- return { item, left, right }
- else
- return { item }
- end
-end
-
-local function ItemCheck(tree)
- if tree[2] then
- return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
- else
- return tree[1]
- end
-end
-
-local N = 12
-local mindepth = 4
-local maxdepth = mindepth + 2
-if maxdepth < N then maxdepth = N end
-
-do
- local stretchdepth = maxdepth + 1
- local stretchtree = BottomUpTree(0, stretchdepth)
- io.write(string.format("stretch tree of depth %d check: %d\n",
- stretchdepth, ItemCheck(stretchtree)))
-end
-
-local longlivedtree = BottomUpTree(0, maxdepth)
-
-for depth=mindepth,maxdepth,2 do
- local iterations = 2 ^ (maxdepth - depth + mindepth)
- local check = 0
- for i=1,iterations do
- check = check + ItemCheck(BottomUpTree(1, depth)) +
- ItemCheck(BottomUpTree(-1, depth))
- end
- io.write(string.format("%d trees of depth %d check: %d\n",
- iterations*2, depth, check))
-end
-
-io.write(string.format("long lived tree of depth %d check: %d\n",
- maxdepth, ItemCheck(longlivedtree)))
+++ /dev/null
-# The Computer Language Benchmarks Game
-# http://shootout.alioth.debian.org/
-#
-# contributed by Antoine Pitrou
-# modified by Dominique Wahli
-# modified by Heinrich Acker
-from __future__ import print_function
-
-# Map "range" to an efficient range in both Python 2 and 3.
-try:
- range = xrange
-except NameError:
- pass
-
-def make_tree(item, depth):
- if not depth: return item, None, None
- item2 = item + item
- depth -= 1
- return item, make_tree(item2 - 1, depth), make_tree(item2, depth)
-
-def check_tree(node):
- item, left, right = node
- if not left: return item
- return item + check_tree(left) - check_tree(right)
-
-min_depth = 4
-max_depth = 12
-stretch_depth = max_depth + 1
-
-print("stretch tree of depth %d check:" % stretch_depth, check_tree(make_tree(0, stretch_depth)))
-
-long_lived_tree = make_tree(0, max_depth)
-
-iterations = 2 ** max_depth
-for depth in range(min_depth, stretch_depth, 2):
-
- check = 0
- for i in range(1, iterations + 1):
- check += check_tree(make_tree(i, depth)) + check_tree(make_tree(-i, depth))
-
- print("%d trees of depth %d check:" % (iterations * 2, depth), check)
- iterations //= 4
-
-print("long lived tree of depth %d check:" % max_depth, check_tree(long_lived_tree))
+++ /dev/null
-# The Computer Language Shootout Benchmarks
-# http://shootout.alioth.debian.org
-#
-# contributed by Jesse Millikan
-# Modified by Wesley Moxam
-
-
-def item_check(left, item, right)
- return item if left.nil?
- item + item_check(*left) - item_check(*right)
-end
-
-def bottom_up_tree(item, depth)
- return [nil, item, nil] unless depth > 0
- item_item = 2 * item
- depth -= 1
- [bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
-end
-
-max_depth = 12
-min_depth = 4
-
-max_depth = min_depth + 2 if min_depth + 2 > max_depth
-
-stretch_depth = max_depth + 1
-stretch_tree = bottom_up_tree(0, stretch_depth)
-
-puts "stretch tree of depth #{stretch_depth} check: #{item_check(*stretch_tree)}"
-stretch_tree = nil
-
-long_lived_tree = bottom_up_tree(0, max_depth)
-
-min_depth.step(max_depth + 1, 2) do |depth|
- iterations = 2**(max_depth - depth + min_depth)
-
- check = 0
-
- for i in 1..iterations
- temp_tree = bottom_up_tree(i, depth)
- check += item_check(*temp_tree)
-
- temp_tree = bottom_up_tree(-i, depth)
- check += item_check(*temp_tree)
- end
-
- puts "#{iterations * 2} trees of depth #{depth} check: #{check}"
-end
-
-puts "long lived tree of depth #{max_depth} check: #{item_check(*long_lived_tree)}"
+++ /dev/null
-// Ported from the Python version.
-
-class Tree {
- construct new(item, depth) {
- _item = item
- if (depth > 0) {
- var item2 = item + item
- depth = depth - 1
- _left = Tree.new(item2 - 1, depth)
- _right = Tree.new(item2, depth)
- }
- }
-
- check {
- if (_left == null) {
- return _item
- }
-
- return _item + _left.check - _right.check
- }
-}
-
-var minDepth = 4
-var maxDepth = 12
-var stretchDepth = maxDepth + 1
-
-System.print("stretch tree of depth %(stretchDepth) check: " +
- "%(Tree.new(0, stretchDepth).check)")
-
-var longLivedTree = Tree.new(0, maxDepth)
-
-// iterations = 2 ** maxDepth
-var iterations = 1
-for (d in 0...maxDepth) {
- iterations = iterations * 2
-}
-
-var depth = minDepth
-while (depth < stretchDepth) {
- var check = 0
- for (i in 1..iterations) {
- check = check + Tree.new(i, depth).check + Tree.new(-i, depth).check
- }
-
- System.print("%(iterations * 2) trees of depth %(depth) check: %(check)")
- iterations = iterations / 4
- depth = depth + 2
-}
-
-System.print(
- "long lived tree of depth %(maxDepth) check: %(longLivedTree.check)")
+++ /dev/null
-//int count = 0;
-fun int recursive_fib(int n)
-{
-// ++count;
- if (n < 2)
- return n;
- else
- return recursive_fib(n - 2) + recursive_fib(n - 1);
-}
-<<<recursive_fib(40)>>>;
+++ /dev/null
-fun int recursive_fib(int n) {
- if (n < 2)
- return n;
- else
- return recursive_fib(n - 2) + recursive_fib(n - 1);
-}
-#!<<< 5 => recursive_fib >>>;
-<<< 40 => recursive_fib >>>;
+++ /dev/null
-fib :: Int -> Int
-fib n
- | n < 2 = n
- | otherwise = (fib (n-2)) + (fib (n-1))
-
-main = print $ fib 40
+++ /dev/null
-local function fib(n)
- if n <= 2 then return 1 end
- return fib(n - 1) + fib(n - 2)
-end
-
-print(fib(40))
+++ /dev/null
-sub fibonacci_recurs {
- my ($number) = @_;
- if ($number < 2) { # base case
- return $number;
- }
- return fibonacci_recurs($number-1) + fibonacci_recurs($number-2);
-}
-
-print fibonacci_recurs(40) , "\n";
+++ /dev/null
-def fibonacci_recurs(n):
- if n < 2:
- return n;
- else:
- return (fibonacci_recurs(n-1) + fibonacci_recurs(n-2))
-
-print(fibonacci_recurs(40))
+++ /dev/null
-def fibonacci_recurs( n )
- if n < 2 then return n end
- return ( fibonacci_recurs( n - 1 ) + fibonacci_recurs( n - 2 ) )
-end
-puts fibonacci_recurs(40)
+++ /dev/null
-class Fib {
- static get(n) {
- if (n < 2) return n
- return get(n - 1) + get(n - 2)
- }
-}
-
-System.print(Fib.get(40))
+++ /dev/null
-fib(n) {
- if (n < 2) return n;
- return fib(n - 1) + fib(n - 2);
-}
-
-main() {
- for (var i = 0; i < 5; i++) {
- print(fib(28));
- }
-}
+++ /dev/null
-class Fib {
- fun static int get(int n) {
- if (n < 2) return n;
- return get(n - 1) + get(n - 2);
- }
-}
-repeat(5)
- <<< Fib.get(28) >>>;
+++ /dev/null
-function fib(n)
- if n < 2 then return n end
- return fib(n - 2) + fib(n - 1)
-end
-
-for i = 1, 5 do
- io.write(fib(28) .. "\n")
-end
+++ /dev/null
-from __future__ import print_function
-
-def fib(n):
- if n < 2: return n
- return fib(n - 1) + fib(n - 2)
-
-for i in range(0, 5):
- print(fib(28))
+++ /dev/null
-def fib(n)
- if n < 2 then
- n
- else
- fib(n - 1) + fib(n - 2)
- end
-end
-
-for i in 0...5
- puts fib(28)
-end
+++ /dev/null
-class Fib {
- static get(n) {
- if (n < 2) return n
- return get(n - 1) + get(n - 2)
- }
-}
-
-for (i in 1..5) {
- System.print(Fib.get(28))
-}
+++ /dev/null
-main() {
- var list = [];
-
- for (var i = 0; i < 1000000; i++) list.add(i);
-
- var sum = 0;
- for (i in list) sum += i;
-
- print(sum);
-}
+++ /dev/null
-int list[0];
-
-for (int i; i < 1000000; ++i)
- list << i;
-
-int sum;
-for(auto i : list)
- i +=> sum;
-
-<<< sum >>>;
+++ /dev/null
-local list = {}
-for i = 0, 999999 do
- list[i] = i
-end
-
-local sum = 0
-for k, i in pairs(list) do
- sum = sum + i
-end
-io.write(sum .. "\n")
+++ /dev/null
-from __future__ import print_function
-
-# Map "range" to an efficient range in both Python 2 and 3.
-try:
- range = xrange
-except NameError:
- pass
-
-list = []
-for i in range(0, 1000000):
- list.append(i)
-
-sum = 0
-for i in list:
- sum += i
-print(sum)
+++ /dev/null
-list = []
-1000000.times {|i| list << i}
-
-sum = 0
-list.each {|i| sum += i}
-puts sum
+++ /dev/null
-var list = []
-
-for (i in 0...1000000) list.add(i)
-
-var sum = 0
-for (i in list) sum = sum + i
-
-System.print(sum)
+++ /dev/null
-class Toggle {
- int state;
- fun int value() { return state; }
- fun Toggle activate() {
- !state => state;
- return this;
- }
-}
-
-class NthToggle extends Toggle {
- int count, countMax;
- fun Toggle activate() {
- if(++count >= countMax) {
- (this $ Toggle).activate();
- 0 => count;
- }
- return this;
- }
-}
-
-100000 => int n;
-
-Toggle toggle;
-true => int val => toggle.state;
-
-repeat(n) {
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
-}
-
-<<< toggle.value() >>>;
-
-NthToggle ntoggle;
-true => val => ntoggle.state;
-3 => ntoggle.countMax;
-
-repeat(n) {
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
-}
-
-<<< ntoggle.value() >>>;
+++ /dev/null
-class Toggle {
- var _state;
-
- Toggle(startState) {
- _state = startState;
- }
-
- get value => _state;
-
- activate() {
- _state = !_state;
- return this;
- }
-}
-
-class NthToggle extends Toggle {
- var _count;
- var _countMax;
-
- NthToggle(startState, maxCounter)
- : super(startState) {
- _countMax = maxCounter;
- _count = 0;
- }
-
- activate() {
- _count = _count + 1;
- if (_count >= _countMax) {
- super.activate();
- _count = 0;
- }
-
- return this;
- }
-}
-
-main() {
- Stopwatch watch = new Stopwatch();
- watch.start();
-
- var n = 100000;
- var val = true;
- var toggle = new Toggle(val);
-
- for (var i = 0; i < n; i++) {
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- val = toggle.activate().value;
- }
-
- print(toggle.value);
-
- val = true;
- var ntoggle = new NthToggle(val, 3);
-
- for (var i = 0; i < n; i++) {
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- val = ntoggle.activate().value;
- }
-
- print(ntoggle.value);
- print("elapsed: ${watch.elapsedMilliseconds / 1000}");
-}
+++ /dev/null
-class Toggle {
- bool state;
- fun bool value() { return state; }
- fun Toggle activate() {
- !state => state;
- return this;
- }
-}
-
-class NthToggle extends Toggle {
- int count, countMax;
- fun Toggle activate() {
- if(++count >= countMax) {
- (this $ Toggle).activate();
- 0 => count;
- }
- return this;
- }
-}
-
-100000 => int n;
-
-Toggle toggle;
-true => bool val => toggle.state;
-
-repeat(n) {
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
- toggle.activate().value() => val;
-}
-
-<<< toggle.value() >>>;
-
-NthToggle ntoggle;
-true => val => ntoggle.state;
-3 => ntoggle.countMax;
-
-repeat(n) {
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
- ntoggle.activate().value() => val;
-}
-
-<<< ntoggle.value() >>>;
+++ /dev/null
--- $Id: methcall.lua,v 1.2 2004-06-12 16:19:43 bfulgham Exp $
--- http://shootout.alioth.debian.org
--- contributed by Roberto Ierusalimschy
-
---------------------------------------------------------------
--- Toggle class
---------------------------------------------------------------
-
-Toggle = {}
-
-function Toggle:value ()
- return self.state
-end
-
-function Toggle:activate ()
- self.state = not self.state
- return self
-end
-
-function Toggle:new (start_state)
- local o = {state = start_state}
- self.__index =self
- setmetatable(o, self)
- return o
-end
-
-
---------------------------------------------------------------
--- NthToggle class
---------------------------------------------------------------
-
-NthToggle = Toggle:new()
-
-function NthToggle:activate ()
- self.counter = self.counter + 1
- if self.counter >= self.count_max then
- Toggle.activate(self)
- self.counter = 0
- end
- return self
-end
-
-function NthToggle:new (start_state, max_counter)
- local o = Toggle.new(self, start_state)
- o.count_max = max_counter
- o.counter = 0
- return o
-end
-
-
------------------------------------------------------------
--- main
------------------------------------------------------------
-
-function main ()
- local N = 100000
-
- local val = 1
- local toggle = Toggle:new(val)
- for i=1,N do
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- val = toggle:activate():value()
- end
- print(val and "true" or "false")
-
- val = 1
- local ntoggle = NthToggle:new(val, 3)
- for i=1,N do
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- val = ntoggle:activate():value()
- end
- print(val and "true" or "false")
-end
-
-main()
-
+++ /dev/null
-#!/usr/bin/python
-# http://www.bagley.org/~doug/shootout/
-from __future__ import print_function
-
-# Map "range" to an efficient range in both Python 2 and 3.
-try:
- range = xrange
-except NameError:
- pass
-
-class Toggle(object):
- def __init__(self, start_state):
- self.bool = start_state
- def value(self):
- return(self.bool)
- def activate(self):
- self.bool = not self.bool
- return(self)
-
-class NthToggle(Toggle):
- def __init__(self, start_state, max_counter):
- Toggle.__init__(self, start_state)
- self.count_max = max_counter
- self.counter = 0
- def activate(self):
- self.counter += 1
- if (self.counter >= self.count_max):
- super(NthToggle, self).activate()
- self.counter = 0
- return(self)
-
-
-def main():
- NUM = 100000
-
- val = 1
- toggle = Toggle(val)
- for i in range(0,NUM):
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- if val:
- print("true")
- else:
- print("false")
-
- val = 1
- ntoggle = NthToggle(val, 3)
- for i in range(0,NUM):
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- if val:
- print("true")
- else:
- print("false")
-
-main()
+++ /dev/null
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: methcall.ruby,v 1.1 2004-05-19 18:10:41 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# with help from Aristarkh Zagorodnikov
-
-class Toggle
- def initialize(start_state)
- @bool = start_state
- end
-
- def value
- @bool
- end
-
- def activate
- @bool = !@bool
- self
- end
-end
-
-class NthToggle < Toggle
- def initialize(start_state, max_counter)
- super start_state
- @count_max = max_counter
- @counter = 0
- end
-
- def activate
- @counter += 1
- if @counter >= @count_max
- super
- @counter = 0
- end
- self
- end
-end
-
-def main()
- start = Time.now
-
- n = 100000
-
- val = 1
- toggle = Toggle.new(val)
- n.times do
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- val = toggle.activate().value()
- end
- if val then puts "true" else puts "false" end
-
- val = 1
- ntoggle = NthToggle.new(val, 3)
- n.times do
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- val = ntoggle.activate().value()
- end
- if val then puts "true" else puts "false" end
-
- puts "elapsed: " + (Time.now - start).to_s
-end
-
-main()
+++ /dev/null
-class Toggle {
- construct new(startState) {
- _state = startState
- }
-
- value { _state }
- activate {
- _state = !_state
- return this
- }
-}
-
-class NthToggle is Toggle {
- construct new(startState, maxCounter) {
- super(startState)
- _countMax = maxCounter
- _count = 0
- }
-
- activate {
- _count = _count + 1
- if (_count >= _countMax) {
- super.activate
- _count = 0
- }
-
- return this
- }
-}
-
-var start = System.clock
-var n = 100000
-var val = true
-var toggle = Toggle.new(val)
-
-for (i in 0...n) {
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
- val = toggle.activate.value
-}
-
-System.print(toggle.value)
-
-val = true
-var ntoggle = NthToggle.new(val, 3)
-
-for (i in 0...n) {
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
- val = ntoggle.activate.value
-}
-
-System.print(ntoggle.value)
-System.print("elapsed: %(System.clock - start)")
+++ /dev/null
-int count;
-for (int i; i < 1000000; ++i) {
- if ("abc" == "abc") ++count;
- if ("a slightly longer string" ==
- "a slightly longer string") ++count;
- if ("a significantly longer string but still not overwhelmingly long string" ==
- "a significantly longer string but still not overwhelmingly long string") ++count;
-
- if ("" == "abc") ++count;
- if ("abc" == "abcd") ++count;
- if ("changed one character" == "changed !ne character") ++count;
-#! if ("123" == 123) ++count
- if ("a slightly longer string" ==
- "a slightly longer string!") ++count;
- if ("a slightly longer string" ==
- "a slightly longer strinh") ++count;
- if ("a significantly longer string but still not overwhelmingly long string" ==
- "another") ++count;
-}
-
-<<< count >>>;
+++ /dev/null
-from __future__ import print_function
-
-import time
-start = time.clock()
-
-count = 0
-for i in range(0, 1000000):
- if "abc" == "abc":
- count = count + 1
- if "a slightly longer string" == \
- "a slightly longer string":
- count = count + 1
- if "a significantly longer string but still not overwhelmingly long string" == \
- "a significantly longer string but still not overwhelmingly long string":
- count = count + 1
-
- if "" == "abc":
- count = count + 1
- if "abc" == "abcd":
- count = count + 1
- if "changed one character" == "changed !ne character":
- count = count + 1
- if "123" == 123: count = count + 1
- if "a slightly longer string" == \
- "a slightly longer string!":
- count = count + 1
- if "a slightly longer string" == \
- "a slightly longer strinh":
- count = count + 1
- if "a significantly longer string but still not overwhelmingly long string" == \
- "another":
- count = count + 1
-
-print(count)
-print("elapsed: " + str(time.clock() - start))
+++ /dev/null
-var start = System.clock
-
-var count = 0
-for (i in 1..1000000) {
- if ("abc" == "abc") count = count + 1
- if ("a slightly longer string" ==
- "a slightly longer string") count = count + 1
- if ("a significantly longer string but still not overwhelmingly long string" ==
- "a significantly longer string but still not overwhelmingly long string") count = count + 1
-
- if ("" == "abc") count = count + 1
- if ("abc" == "abcd") count = count + 1
- if ("changed one character" == "changed !ne character") count = count + 1
- if ("123" == 123) count = count + 1
- if ("a slightly longer string" ==
- "a slightly longer string!") count = count + 1
- if ("a slightly longer string" ==
- "a slightly longer strinh") count = count + 1
- if ("a significantly longer string but still not overwhelmingly long string" ==
- "another") count = count + 1
-}
-
-System.print(count)
-System.print("elapsed: %(System.clock - start)")
projects / gwion.git / commitdiff
