Merge branch 'master' into 820-local

Conflicts:
	lib/linguist/samples.json

.gitignore

@@ -1 +1,3 @@
 Gemfile.lock
+.bundle/
+vendor/

.travis.yml

@@ -1,9 +1,9 @@
-before_install: sudo apt-get install libicu-dev -y
+before_install: 
+  - sudo apt-get install libicu-dev -y
+  - gem update --system 2.1.11
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
-  - ree
+  - 2.1.1
 notifications:
   disabled: true

Gemfile

@@ -1,7 +1,2 @@
 source 'https://rubygems.org'
 gemspec
-
-if RUBY_VERSION < "1.9.3"
-  # escape_utils 1.0.0 requires 1.9.3 and above
-  gem "escape_utils", "0.3.2"
-end

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2013 GitHub, Inc.
+Copyright (c) 2011-2014 GitHub, Inc.
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

README.md

@@ -1,18 +1,17 @@
 # Linguist
 
-We use this library at GitHub to detect blob languages, highlight code, ignore binary files, suppress generated files in diffs and generate language breakdown graphs.
+We use this library at GitHub to detect blob languages, highlight code, ignore binary files, suppress generated files in diffs, and generate language breakdown graphs.
 
 ## Features
 
 ### Language detection
 
-Linguist defines the list of all languages known to GitHub in a [yaml file](https://github.com/github/linguist/blob/master/lib/linguist/languages.yml). In order for a file to be highlighted, a language and lexer must be defined there.
+Linguist defines a list of all languages known to GitHub in a [yaml file](https://github.com/github/linguist/blob/master/lib/linguist/languages.yml). In order for a file to be highlighted, a language and a lexer must be defined there.
 
-Most languages are detected by their file extension. This is the fastest and most common situation.
-
-For disambiguating between files with common extensions, we use a [Bayesian classifier](https://github.com/github/linguist/blob/master/lib/linguist/classifier.rb). For an example, this helps us tell the difference between `.h` files which could be either C, C++, or Obj-C.
-
-In the actual GitHub app we deal with `Grit::Blob` objects. For testing, there is a simple `FileBlob` API.
+Most languages are detected by their file extension. For disambiguating between files with common extensions, we first apply some common-sense heuristics to pick out obvious languages. After that, we use a
+[statistical
+classifier](https://github.com/github/linguist/blob/master/lib/linguist/classifier.rb).
+This process can help us tell the difference between, for example, `.h` files which could be either C, C++, or Obj-C.
 
 ```ruby
 
@@ -27,12 +26,9 @@ See [lib/linguist/language.rb](https://github.com/github/linguist/blob/master/li
 
 The actual syntax highlighting is handled by our Pygments wrapper, [pygments.rb](https://github.com/tmm1/pygments.rb). It also provides a [Lexer abstraction](https://github.com/tmm1/pygments.rb/blob/master/lib/pygments/lexer.rb) that determines which highlighter should be used on a file.
 
-We typically run on a pre-release version of Pygments, [pygments.rb](https://github.com/tmm1/pygments.rb), to get early access to new lexers. The [languages.yml](https://github.com/github/linguist/blob/master/lib/linguist/languages.yml) file is a dump of the lexers we have available on our server.
-
 ### Stats
 
-The Language Graph you see on every repository is built by aggregating the languages of each file in that repository. 
-The top language in the graph determines the project's primary language. Collectively, these stats make up the [Top Languages](https://github.com/languages) page.
+The Language stats bar that you see on every repository is built by aggregating the languages of each file in that repository. The top language in the graph determines the project's primary language.
 
 The repository stats API, accessed through `#languages`, can be used on a directory:
 
@@ -42,10 +38,27 @@ project.language.name  #=> "Ruby"
 project.languages      #=> { "Ruby" => 0.98, "Shell" => 0.02 }
 ```
 
-These stats are also printed out by the `linguist` binary. Try running `linguist` on itself:
+These stats are also printed out by the `linguist` binary. You can use the
+`--breakdown` flag, and the binary will also output the breakdown of files by language.
 
-    $ bundle exec linguist lib/
-    100%  Ruby
+You can try running `linguist` on the `lib/` directory in this repository itself:
+
+    $ bundle exec linguist lib/ --breakdown
+
+    100.00% Ruby
+
+    Ruby:
+    linguist/blob_helper.rb
+    linguist/classifier.rb
+    linguist/file_blob.rb
+    linguist/generated.rb
+    linguist/heuristics.rb
+    linguist/language.rb
+    linguist/md5.rb
+    linguist/repository.rb
+    linguist/samples.rb
+    linguist/tokenizer.rb
+    linguist.rb
 
 #### Ignore vendored files
 
@@ -93,8 +106,50 @@ To update the `samples.json` after adding new files to [`samples/`](https://gith
 
     bundle exec rake samples
 
+### A note on language extensions
+
+Linguist has a number of methods available to it for identifying the language of a particular file. The initial lookup is based upon the extension of the file, possible file extensions are defined in an array called `extensions`. Take a look at this example for example for `Perl`:
+
+```
+Perl:
+  type: programming
+  ace_mode: perl
+  color: "#0298c3"
+  extensions:
+  - .pl
+  - .PL
+  - .perl
+  - .ph
+  - .plx
+  - .pm
+  - .pod
+  - .psgi
+  interpreters:
+  - perl
+```
+Any of the extensions defined are valid but the first in this array should be the most popular.
+
 ### Testing
 
 Sometimes getting the tests running can be too much work, especially if you don't have much Ruby experience. It's okay: be lazy and let our build bot [Travis](http://travis-ci.org/#!/github/linguist) run the tests for you. Just open a pull request and the bot will start cranking away.
 
 Here's our current build status, which is hopefully green: [![Build Status](https://secure.travis-ci.org/github/linguist.png?branch=master)](http://travis-ci.org/github/linguist)
+
+### Releasing
+
+If you are the current maintainer of this gem:
+
+ 0. Create a branch for the release: `git checkout -b cut-release-vxx.xx.xx`
+ 0. Make sure your local dependencies are up to date: `bundle install`
+ 0. Ensure that samples are updated: `bundle exec rake samples`
+ 0. Ensure that tests are green: `bundle exec rake test`
+ 0. Bump gem version in `lib/linguist/version.rb`.  For example, [like this](https://github.com/github/linguist/commit/8d2ea90a5ba3b2fe6e1508b7155aa4632eea2985).
+ 0. Make a PR to github/linguist.  For example, [#1238](https://github.com/github/linguist/pull/1238).
+ 0. Build a local gem: `gem build github-linguist.gemspec`
+ 0. Testing:
+   0. Bump the Gemfile and Gemfile.lock versions for an app which relies on this gem
+   0. Install the new gem locally
+   0. Test behavior locally, branch deploy, whatever needs to happen
+ 0. Merge github/linguist PR
+ 0. Tag and push: `git tag vx.xx.xx; git push --tags`
+ 0. Push to rubygems.org -- `gem push github-linguist-2.10.12.gem`

Rakefile

@@ -1,7 +1,7 @@
+require 'json'
 require 'rake/clean'
 require 'rake/testtask'
 require 'yaml'
-require 'json'
 
 task :default => :test
 

bin/linguist

@@ -1,14 +1,22 @@
 #!/usr/bin/env ruby
 
 # linguist — detect language type for a file, or, given a directory, determine language breakdown
-#
-# usage: linguist <path>
+#     usage: linguist <path> [<--breakdown>]
 
 require 'linguist/file_blob'
 require 'linguist/repository'
 
 path = ARGV[0] || Dir.pwd
 
+# special case if not given a directory but still given the --breakdown option
+if path == "--breakdown"
+  path = Dir.pwd
+  breakdown = true
+end
+
+ARGV.shift
+breakdown = true if ARGV[0] == "--breakdown"
+
 if File.directory?(path)
   repo = Linguist::Repository.from_directory(path)
   repo.languages.sort_by { |_, size| size }.reverse.each do |language, size|
@@ -16,6 +24,17 @@ if File.directory?(path)
     percentage = sprintf '%.2f' % percentage
     puts "%-7s %s" % ["#{percentage}%", language]
   end
+  if breakdown
+    puts
+    file_breakdown = repo.breakdown_by_file
+    file_breakdown.each do |lang, files|
+      puts "#{lang}:" 
+      files.each do |file|
+        puts file
+      end
+      puts
+    end
+  end
 elsif File.file?(path)
   blob = Linguist::FileBlob.new(path, Dir.pwd)
   type = if blob.text?

github-linguist.gemspec

@@ -1,18 +1,22 @@
+require File.expand_path('../lib/linguist/version', __FILE__)
+
 Gem::Specification.new do |s|
   s.name    = 'github-linguist'
-  s.version = '2.10.2'
+  s.version = Linguist::VERSION
   s.summary = "GitHub Language detection"
+  s.description = 'We use this library at GitHub to detect blob languages, highlight code, ignore binary files, suppress generated files in diffs, and generate language breakdown graphs.'
 
   s.authors  = "GitHub"
   s.homepage = "https://github.com/github/linguist"
+  s.license  = "MIT"
 
   s.files = Dir['lib/**/*']
   s.executables << 'linguist'
 
-  s.add_dependency 'charlock_holmes', '~> 0.6.6'
-  s.add_dependency 'escape_utils',    '>= 0.3.1'
+  s.add_dependency 'charlock_holmes', '~> 0.7.3'
+  s.add_dependency 'escape_utils',    '~> 1.0.1'
   s.add_dependency 'mime-types',      '~> 1.19'
-  s.add_dependency 'pygments.rb',     '~> 0.5.4'
+  s.add_dependency 'pygments.rb',     '~> 0.6.0'
 
   s.add_development_dependency 'json'
   s.add_development_dependency 'mocha'

lib/linguist.rb

@@ -1,5 +1,7 @@
 require 'linguist/blob_helper'
 require 'linguist/generated'
+require 'linguist/heuristics'
 require 'linguist/language'
 require 'linguist/repository'
 require 'linguist/samples'
+require 'linguist/version'

lib/linguist/blob_helper.rb

@@ -112,6 +112,12 @@ module Linguist
       end
     end
 
+    def ruby_encoding
+      if hash = detect_encoding
+        hash[:ruby_encoding]
+      end
+    end
+
     # Try to guess the encoding
     #
     # Returns: a Hash, with :encoding, :confidence, :type
@@ -241,7 +247,31 @@ module Linguist
     def lines
       @lines ||=
         if viewable? && data
-          data.split(/\r\n|\r|\n/, -1)
+          # `data` is usually encoded as ASCII-8BIT even when the content has
+          # been detected as a different encoding. However, we are not allowed
+          # to change the encoding of `data` because we've made the implicit
+          # guarantee that each entry in `lines` is encoded the same way as
+          # `data`.
+          #
+          # Instead, we re-encode each possible newline sequence as the
+          # detected encoding, then force them back to the encoding of `data`
+          # (usually a binary encoding like ASCII-8BIT). This means that the
+          # byte sequence will match how newlines are likely encoded in the
+          # file, but we don't have to change the encoding of `data` as far as
+          # Ruby is concerned. This allows us to correctly parse out each line
+          # without changing the encoding of `data`, and
+          # also--importantly--without having to duplicate many (potentially
+          # large) strings.
+          begin
+            encoded_newlines = ["\r\n", "\r", "\n"].
+              map { |nl| nl.encode(ruby_encoding, "ASCII-8BIT").force_encoding(data.encoding) }
+
+            data.split(Regexp.union(encoded_newlines), -1)
+          rescue Encoding::ConverterNotFoundError
+            # The data is not splittable in the detected encoding.  Assume it's
+            # one big line.
+            [data]
+          end
         else
           []
         end

lib/linguist/classifier.rb

@@ -78,18 +78,13 @@ module Linguist
     def classify(tokens, languages)
       return [] if tokens.nil?
       tokens = Tokenizer.tokenize(tokens) if tokens.is_a?(String)
-
       scores = {}
-      if verbosity >= 2
-        dump_all_tokens(tokens, languages)
-      end
+
+      debug_dump_all_tokens(tokens, languages) if verbosity >= 2
+
       languages.each do |language|
-        scores[language] = tokens_probability(tokens, language) +
-                                   language_probability(language)
-        if verbosity >= 1
-          printf "%10s = %10.3f + %7.3f = %10.3f\n",
-            language, tokens_probability(tokens, language), language_probability(language), scores[language]
-        end
+        scores[language] = tokens_probability(tokens, language) + language_probability(language)
+        debug_dump_probabilities(tokens, language, scores[language]) if verbosity >= 1
       end
 
       scores.sort { |a, b| b[1] <=> a[1] }.map { |score| [score[0], score[1]] }
@@ -135,6 +130,11 @@ module Linguist
         @verbosity ||= (ENV['LINGUIST_DEBUG'] || 0).to_i
       end
 
+      def debug_dump_probabilities(tokens, language, score)
+        printf("%10s = %10.3f + %7.3f = %10.3f\n",
+            language, tokens_probability(tokens, language), language_probability(language), score)
+      end
+
       # Internal: show a table of probabilities for each <token,language> pair.
       #
       # The number in each table entry is the number of "points" that each
@@ -145,22 +145,22 @@ module Linguist
       # how much more likely (log of probability ratio) that token is to
       # appear in one language vs. the least-likely language.  Dashes
       # indicate the least-likely language (and zero points) for each token.
-      def dump_all_tokens(tokens, languages)
+      def debug_dump_all_tokens(tokens, languages)
         maxlen = tokens.map { |tok| tok.size }.max
-        
+
         printf "%#{maxlen}s", ""
         puts "    #" + languages.map { |lang| sprintf("%10s", lang) }.join
-        
+
         token_map = Hash.new(0)
         tokens.each { |tok| token_map[tok] += 1 }
-        
+
         token_map.sort.each { |tok, count|
           arr = languages.map { |lang| [lang, token_probability(tok, lang)] }
           min = arr.map { |a,b| b }.min
           minlog = Math.log(min)
           if !arr.inject(true) { |result, n| result && n[1] == arr[0][1] }
             printf "%#{maxlen}s%5d", tok, count
-            
+
             puts arr.map { |ent|
               ent[1] == min ? "         -" : sprintf("%10.3f", count * (Math.log(ent[1]) - minlog))
             }.join

lib/linguist/generated.rb

@@ -58,10 +58,13 @@ module Linguist
         generated_parser? ||
         generated_net_docfile? ||
         generated_net_designer_file? ||
+        generated_postscript? ||
         generated_protocol_buffer? ||
         generated_jni_header? ||
         composer_lock? ||
-        node_modules?
+        node_modules? ||
+        vcr_cassette? ||
+        generated_by_zephir?
     end
 
     # Internal: Is the blob an XCode project file?
@@ -176,6 +179,29 @@ module Linguist
       false
     end
 
+    # Internal: Is the blob of PostScript generated?
+    #
+    # PostScript files are often generated by other programs. If they tell us so,
+    # we can detect them.
+    #
+    # Returns true or false.
+    def generated_postscript?
+      return false unless ['.ps', '.eps'].include? extname
+
+      # We analyze the "%%Creator:" comment, which contains the author/generator
+      # of the file. If there is one, it should be in one of the first few lines.
+      creator = lines[0..9].find {|line| line =~ /^%%Creator: /}
+      return false if creator.nil?
+
+      # Most generators write their version number, while human authors' or companies'
+      # names don't contain numbers. So look if the line contains digits. Also
+      # look for some special cases without version numbers.
+      return creator =~ /[0-9]/ ||
+        creator.include?("mpage") ||
+        creator.include?("draw") ||
+        creator.include?("ImageMagick")
+    end
+
     # Internal: Is the blob a C++, Java or Python source file generated by the
     # Protocol Buffer compiler?
     #
@@ -198,20 +224,35 @@ module Linguist
                lines[1].include?("#include <jni.h>")
     end
 
-    # node_modules/ can contain large amounts of files, in general not meant
-    # for humans in pull requests.
+    # Internal: Is the blob part of node_modules/, which are not meant for humans in pull requests.
     #
     # Returns true or false.
     def node_modules?
       !!name.match(/node_modules\//)
     end
 
-    # the php composer tool generates a lock file to represent a specific dependency state.
-    # In general not meant for humans in pull requests.
+    # Internal: Is the blob a generated php composer lock file?
     #
     # Returns true or false.
     def composer_lock?
       !!name.match(/composer.lock/)
     end
+
+    # Internal: Is the blob a generated by Zephir
+    #
+    # Returns true or false.
+    def generated_by_zephir?
+      !!name.match(/.\.zep\.(?:c|h|php)$/)
+    end
+
+    # Is the blob a VCR Cassette file?
+    #
+    # Returns true or false
+    def vcr_cassette?
+      return false unless extname == '.yml'
+      return false unless lines.count > 2
+      # VCR Cassettes have "recorded_with: VCR" in the second last line.
+      return lines[-2].include?("recorded_with: VCR")
+    end
   end
 end

lib/linguist/heuristics.rb

@@ -0,0 +1,90 @@
+module Linguist
+  # A collection of simple heuristics that can be used to better analyze languages.
+  class Heuristics
+    ACTIVE = false
+
+    # Public: Given an array of String language names,
+    # apply heuristics against the given data and return an array
+    # of matching languages, or nil.
+    #
+    # data      - Array of tokens or String data to analyze.
+    # languages - Array of language name Strings to restrict to.
+    #
+    # Returns an array of Languages or []
+    def self.find_by_heuristics(data, languages)
+      if active?
+        if languages.all? { |l| ["Objective-C", "C++"].include?(l) }
+          disambiguate_c(data, languages)
+        end
+        if languages.all? { |l| ["Perl", "Prolog"].include?(l) }
+          disambiguate_pl(data, languages)
+        end
+        if languages.all? { |l| ["ECL", "Prolog"].include?(l) }
+          disambiguate_ecl(data, languages)
+        end
+        if languages.all? { |l| ["TypeScript", "XML"].include?(l) }
+          disambiguate_ts(data, languages)
+        end
+        if languages.all? { |l| ["Common Lisp", "OpenCL"].include?(l) }
+          disambiguate_cl(data, languages)
+        end
+        if languages.all? { |l| ["Rebol", "R"].include?(l) }
+          disambiguate_r(data, languages)
+        end
+      end
+    end
+
+    # .h extensions are ambigious between C, C++, and Objective-C.
+    # We want to shortcut look for Objective-C _and_ now C++ too!
+    #
+    # Returns an array of Languages or []
+    def self.disambiguate_c(data, languages)
+      matches = []
+      matches << Language["Objective-C"] if data.include?("@interface")
+      matches << Language["C++"] if data.include?("#include <cstdint>")
+      matches
+    end
+
+    def self.disambiguate_pl(data, languages)
+      matches = []
+      matches << Language["Prolog"] if data.include?(":-")
+      matches << Language["Perl"] if data.include?("use strict")
+      matches
+    end
+
+    def self.disambiguate_ecl(data, languages)
+      matches = []
+      matches << Language["Prolog"] if data.include?(":-")
+      matches << Language["ECL"] if data.include?(":=")
+      matches
+    end
+
+    def self.disambiguate_ts(data, languages)
+      matches = []
+      if (data.include?("</translation>"))
+        matches << Language["XML"]
+      else
+        matches << Language["TypeScript"]
+      end
+      matches
+    end
+
+    def self.disambiguate_cl(data, languages)
+      matches = []
+      matches << Language["Common Lisp"] if data.include?("(defun ")
+      matches << Language["OpenCL"] if /\/\* |\/\/ |^\}/.match(data)
+      matches
+    end
+
+    def self.disambiguate_r(data, languages)
+      matches = []
+      matches << Language["Rebol"] if /\bRebol\b/i.match(data)
+      matches << Language["R"] if data.include?("<-")
+      matches
+    end
+
+    def self.active?
+      !!ACTIVE
+    end
+  end
+end

lib/linguist/language.rb

@@ -7,6 +7,7 @@ rescue LoadError
 end
 
 require 'linguist/classifier'
+require 'linguist/heuristics'
 require 'linguist/samples'
 
 module Linguist
@@ -23,7 +24,6 @@ module Linguist
     @extension_index          = Hash.new { |h,k| h[k] = [] }
     @interpreter_index        = Hash.new { |h,k| h[k] = [] }
     @filename_index           = Hash.new { |h,k| h[k] = [] }
-    @primary_extension_index  = {}
 
     # Valid Languages types
     TYPES = [:data, :markup, :programming, :prose]
@@ -32,7 +32,7 @@ module Linguist
     #
     # Returns an array
     def self.detectable_markup
-      ["CSS", "Less", "Sass", "TeX"]
+      ["CSS", "Less", "Sass", "SCSS", "Stylus", "TeX"]
     end
 
     # Detect languages by a specific type
@@ -79,12 +79,6 @@ module Linguist
         @extension_index[extension] << language
       end
 
-      if @primary_extension_index.key?(language.primary_extension)
-        raise ArgumentError, "Duplicate primary extension: #{language.primary_extension}"
-      end
-
-      @primary_extension_index[language.primary_extension] = language
-
       language.interpreters.each do |interpreter|
         @interpreter_index[interpreter] << language
       end
@@ -113,18 +107,32 @@ module Linguist
         name += ".script!"
       end
 
+      # First try to find languages that match based on filename.
       possible_languages = find_by_filename(name)
 
+      # If there is more than one possible language with that extension (or no
+      # extension at all, in the case of extensionless scripts), we need to continue
+      # our detection work
       if possible_languages.length > 1
         data = data.call() if data.respond_to?(:call)
+        possible_language_names = possible_languages.map(&:name)
+
+        # Don't bother with emptiness
         if data.nil? || data == ""
           nil
+        # Check if there's a shebang line and use that as authoritative
         elsif (result = find_by_shebang(data)) && !result.empty?
           result.first
-        elsif classified = Classifier.classify(Samples::DATA, data, possible_languages.map(&:name)).first
+        # No shebang. Still more work to do. Try to find it with our heuristics.
+        elsif (determined = Heuristics.find_by_heuristics(data, possible_language_names)) && !determined.empty?
+          determined.first
+        # Lastly, fall back to the probablistic classifier.
+        elsif classified = Classifier.classify(Samples::DATA, data, possible_language_names ).first
+          # Return the actual Language object based of the string language name (i.e., first element of `#classify`)
           Language[classified[0]]
         end
       else
+        # Simplest and most common case, we can just return the one match based on extension
         possible_languages.first
       end
     end
@@ -176,8 +184,7 @@ module Linguist
     # Returns all matching Languages or [] if none were found.
     def self.find_by_filename(filename)
       basename, extname = File.basename(filename), File.extname(filename)
-      langs = [@primary_extension_index[extname]] +
-              @filename_index[basename] +
+      langs = @filename_index[basename] +
               @extension_index[extname]
       langs.compact.uniq
     end
@@ -284,15 +291,6 @@ module Linguist
       @interpreters = attributes[:interpreters]   || []
       @filenames  = attributes[:filenames]  || []
 
-      unless @primary_extension = attributes[:primary_extension]
-        raise ArgumentError, "#{@name} is missing primary extension"
-      end
-
-      # Prepend primary extension unless its already included
-      if primary_extension && !extensions.include?(primary_extension)
-        @extensions = [primary_extension] + extensions
-      end
-
       # Set popular, and searchable flags
       @popular    = attributes.key?(:popular)    ? attributes[:popular]    : false
       @searchable = attributes.key?(:searchable) ? attributes[:searchable] : true
@@ -380,20 +378,6 @@ module Linguist
     # Returns the extensions Array
     attr_reader :extensions
 
-    # Deprecated: Get primary extension
-    #
-    # Defaults to the first extension but can be overridden
-    # in the languages.yml.
-    #
-    # The primary extension can not be nil. Tests should verify this.
-    #
-    # This attribute is only used by app/helpers/gists_helper.rb for
-    # creating the language dropdown. It really should be using `name`
-    # instead. Would like to drop primary extension.
-    #
-    # Returns the extension String.
-    attr_reader :primary_extension
-
     # Public: Get interpreters
     #
     # Examples
@@ -411,6 +395,27 @@ module Linguist
     #
     # Returns the extensions Array
     attr_reader :filenames
+    
+    # Public: Return all possible extensions for language
+    def all_extensions
+      (extensions + [primary_extension]).uniq
+    end
+
+    # Deprecated: Get primary extension
+    #
+    # Defaults to the first extension but can be overridden
+    # in the languages.yml.
+    #
+    # The primary extension can not be nil. Tests should verify this.
+    #
+    # This method is only used by app/helpers/gists_helper.rb for creating
+    # the language dropdown. It really should be using `name` instead.
+    # Would like to drop primary extension.
+    #
+    # Returns the extension String.
+    def primary_extension
+      extensions.first
+    end
 
     # Public: Get URL escaped name.
     #
@@ -470,7 +475,7 @@ module Linguist
     #
     # Returns html String
     def colorize(text, options = {})
-      lexer.highlight(text, options = {})
+      lexer.highlight(text, options)
     end
 
     # Public: Return name as String representation
@@ -553,9 +558,8 @@ module Linguist
       :group_name        => options['group'],
       :searchable        => options.key?('searchable') ? options['searchable'] : true,
       :search_term       => options['search_term'],
-      :extensions        => options['extensions'].sort,
+      :extensions        => [options['extensions'].first] + options['extensions'][1..-1].sort,
       :interpreters      => options['interpreters'].sort,
-      :primary_extension => options['primary_extension'],
       :filenames         => options['filenames'],
       :popular           => popular.include?(name)
     )

lib/linguist/repository.rb

@@ -29,6 +29,7 @@ module Linguist
       @computed_stats = false
       @language = @size = nil
       @sizes = Hash.new { 0 }
+      @file_breakdown = Hash.new { |h,k| h[k] = Array.new }
     end
 
     # Public: Returns a breakdown of language stats.
@@ -60,6 +61,12 @@ module Linguist
       @size
     end
 
+    # Public: Return the language breakdown of this repository by file
+    def breakdown_by_file
+      compute_stats
+      @file_breakdown
+    end
+
     # Internal: Compute language breakdown for each blob in the Repository.
     #
     # Returns nothing
@@ -75,6 +82,10 @@ module Linguist
 
         # Only include programming languages and acceptable markup languages
         if blob.language.type == :programming || Language.detectable_markup.include?(blob.language.name)
+
+          # Build up the per-file breakdown stats
+          @file_breakdown[blob.language.group.name] << blob.name
+
           @sizes[blob.language.group] += blob.size
         end
       end

lib/linguist/vendor.yml

@@ -10,7 +10,7 @@
 ## Vendor Conventions ##
 
 # Caches
-- cache/
+- (^|/)cache/
 
 # Dependencies
 - ^[Dd]ependencies/
@@ -27,11 +27,18 @@
 # Node dependencies
 - node_modules/
 
+# Bower Components
+- bower_components/
+
 # Erlang bundles
 - ^rebar$
 
 # Bootstrap minified css and js
-- (^|/)bootstrap([^.]*)(\.min)\.(js|css)$
+- (^|/)bootstrap([^.]*)(\.min)?\.(js|css)$
+
+# Foundation css
+- foundation.min.css
+- foundation.css
 
 # Vendored dependencies
 - thirdparty/
@@ -40,6 +47,9 @@
 # Debian packaging
 - ^debian/
 
+# Haxelib projects often contain a neko bytecode file named run.n
+- run.n$
+
 ## Commonly Bundled JavaScript frameworks ##
 
 # jQuery
@@ -56,6 +66,9 @@
 - (^|/)controls\.js$
 - (^|/)dragdrop\.js$
 
+# Typescript definition files
+- (.*?)\.d\.ts$
+
 # MooTools
 - (^|/)mootools([^.]*)\d+\.\d+.\d+([^.]*)\.js$
 
@@ -82,6 +95,19 @@
 - (^|/)shCore\.js$
 - (^|/)shLegacy\.js$
 
+# AngularJS
+- (^|/)angular([^.]*)(\.min)?\.js$
+
+# D3.js
+- (^|\/)d3(\.v\d+)?([^.]*)(\.min)?\.js$
+
+# React
+- (^|/)react(-[^.]*)?(\.min)?\.js$
+
+# Modernizr
+- (^|/)modernizr\-\d\.\d+(\.\d+)?(\.min)?\.js$
+- (^|/)modernizr\.custom\.\d+\.js$
+
 ## Python ##
 
 # django
@@ -101,10 +127,18 @@
 # Sparkle
 - (^|/)Sparkle/
 
+## Groovy ##
+
+# Gradle
+- (^|/)gradlew$
+- (^|/)gradlew\.bat$
+- (^|/)gradle/wrapper/
+
 ## .NET ##
 
 # Visual Studio IntelliSense
 - -vsdoc\.js$
+- \.intellisense\.js$
 
 # jQuery validation plugin (MS bundles this with asp.net mvc)
 - (^|/)jquery([^.]*)\.validate(\.unobtrusive)?(\.min)?\.js$
@@ -114,7 +148,7 @@
 - (^|/)[Mm]icrosoft([Mm]vc)?([Aa]jax|[Vv]alidation)(\.debug)?\.js$
 
 # NuGet
-- ^[Pp]ackages/
+- ^[Pp]ackages\/.+\.\d+\/
 
 # ExtJS
 - (^|/)extjs/.*?\.js$
@@ -134,12 +168,16 @@
 - (^|/)extjs/src/
 - (^|/)extjs/welcome/
 
+# Html5shiv
+- (^|/)html5shiv(\.min)?\.js$
+
 # Samples folders
 - ^[Ss]amples/
 
 # LICENSE, README, git config files
 - ^COPYING$
 - LICENSE$
+- License$
 - gitattributes$
 - gitignore$
 - gitmodules$
@@ -158,3 +196,15 @@
 
 # .DS_Store's
 - .[Dd][Ss]_[Ss]tore$
+
+# Mercury --use-subdirs
+- Mercury/
+
+# R packages
+- ^vignettes/
+- ^inst/extdata/
+
+# Octicons
+- octicons.css
+- octicons.min.css
+- sprockets-octicons.scss

lib/linguist/version.rb

@@ -0,0 +1,3 @@
+module Linguist
+  VERSION = "2.12.0"
+end

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/Alloy/file_system.als

@@ -0,0 +1,59 @@
+module examples/systems/file_system
+
+/*
+ * Model of a generic file system.
+ */
+
+abstract sig Object {}
+
+sig Name {}
+
+sig File extends Object {} { some d: Dir | this in d.entries.contents }
+
+sig Dir extends Object {
+  entries: set DirEntry,
+  parent: lone Dir
+} {
+  parent = this.~@contents.~@entries
+  all e1, e2 : entries | e1.name = e2.name => e1 = e2
+  this !in this.^@parent
+  this != Root => Root in this.^@parent
+}
+
+one sig Root extends Dir {} { no parent }
+
+lone sig Cur extends Dir {}
+
+sig DirEntry {
+  name: Name,
+  contents: Object
+} {
+  one this.~entries
+}
+
+
+/**
+ * all directories besides root have one parent
+ */
+pred OneParent_buggyVersion {
+    all d: Dir - Root | one d.parent
+}
+
+/**
+ * all directories besides root have one parent
+ */
+pred OneParent_correctVersion {
+    all d: Dir - Root | (one d.parent && one contents.d)
+}
+
+/**
+ * Only files may be linked (that is, have more than one entry)
+ * That is, all directories are the contents of at most one directory entry
+ */
+pred NoDirAliases {
+    all o: Dir | lone o.~contents
+}
+
+check { OneParent_buggyVersion => NoDirAliases } for 5 expect 1
+
+check { OneParent_correctVersion => NoDirAliases } for 5 expect 0

samples/Alloy/marksweepgc.als

@@ -0,0 +1,83 @@
+module examples/systems/marksweepgc
+
+/*
+ * Model of mark and sweep garbage collection.
+ */
+
+// a node in the heap
+sig Node {}
+
+sig HeapState {
+  left, right : Node -> lone Node,
+  marked : set Node,
+  freeList : lone Node
+}
+
+pred clearMarks[hs, hs' : HeapState] {
+  // clear marked set
+  no hs'.marked
+  // left and right fields are unchanged
+  hs'.left = hs.left
+  hs'.right = hs.right
+}
+
+/**
+ * simulate the recursion of the mark() function using transitive closure
+ */
+fun reachable[hs: HeapState, n: Node] : set Node {
+  n + n.^(hs.left + hs.right)
+}
+
+pred mark[hs: HeapState, from : Node, hs': HeapState] {
+  hs'.marked = hs.reachable[from]
+  hs'.left = hs.left
+  hs'.right = hs.right
+}
+
+/**
+ * complete hack to simulate behavior of code to set freeList
+ */
+pred setFreeList[hs, hs': HeapState] {
+  // especially hackish
+  hs'.freeList.*(hs'.left) in (Node - hs.marked)
+  all n: Node |
+    (n !in hs.marked) => {
+      no hs'.right[n]
+      hs'.left[n] in (hs'.freeList.*(hs'.left))
+      n in hs'.freeList.*(hs'.left)
+    } else {
+      hs'.left[n] = hs.left[n]
+      hs'.right[n] = hs.right[n]
+    }
+  hs'.marked = hs.marked
+}
+
+pred GC[hs: HeapState, root : Node, hs': HeapState] {
+  some hs1, hs2: HeapState |
+    hs.clearMarks[hs1] && hs1.mark[root, hs2] && hs2.setFreeList[hs']
+}
+
+assert Soundness1 {
+  all h, h' : HeapState, root : Node |
+    h.GC[root, h'] =>
+      (all live : h.reachable[root] | {
+        h'.left[live] = h.left[live]
+        h'.right[live] = h.right[live]
+      })
+}
+
+assert Soundness2 {
+  all h, h' : HeapState, root : Node |
+    h.GC[root, h'] =>
+      no h'.reachable[root] & h'.reachable[h'.freeList]
+}
+
+assert Completeness {
+  all h, h' : HeapState, root : Node |
+    h.GC[root, h'] =>
+      (Node - h'.reachable[root]) in h'.reachable[h'.freeList]
+}
+
+check Soundness1 for 3 expect 0
+check Soundness2 for 3 expect 0
+check Completeness for 3 expect 0

samples/Alloy/views.als

@@ -0,0 +1,217 @@
+module examples/systems/views
+
+/*
+ * Model of views in object-oriented programming.
+ *
+ * Two object references, called the view and the backing,
+ * are related by a view mechanism when changes to the
+ * backing are automatically propagated to the view. Note
+ * that the state of a view need not be a projection of the
+ * state of the backing; the keySet method of Map, for
+ * example, produces two view relationships, and for the
+ * one in which the map is modified by changes to the key
+ * set, the value of the new map cannot be determined from
+ * the key set. Note that in the iterator view mechanism,
+ * the iterator is by this definition the backing object,
+ * since changes are propagated from iterator to collection
+ * and not vice versa. Oddly, a reference may be a view of
+ * more than one backing: there can be two iterators on the
+ * same collection, eg. A reference cannot be a view under
+ * more than one view type.
+ *
+ * A reference is made dirty when it is a backing for a view
+ * with which it is no longer related by the view invariant.
+ * This usually happens when a view is modified, either
+ * directly or via another backing. For example, changing a
+ * collection directly when it has an iterator invalidates
+ * it, as does changing the collection through one iterator
+ * when there are others.
+ *
+ * More work is needed if we want to model more closely the
+ * failure of an iterator when its collection is invalidated.
+ *
+ * As a terminological convention, when there are two
+ * complementary view relationships, we will give them types
+ * t and t'. For example, KeySetView propagates from map to
+ * set, and KeySetView' propagates from set to map.
+ *
+ * author: Daniel Jackson
+ */
+
+open util/ordering[State] as so
+open util/relation as rel
+
+sig Ref {}
+sig Object {}
+
+-- t->b->v in views when v is view of type t of backing b
+-- dirty contains refs that have been invalidated
+sig State {
+  refs: set Ref,
+  obj: refs -> one Object,
+  views: ViewType -> refs -> refs,
+  dirty: set refs
+--  , anyviews: Ref -> Ref -- for visualization
+  }
+-- {anyviews = ViewType.views}
+
+sig Map extends Object {
+  keys: set Ref,
+  map: keys -> one Ref
+  }{all s: State |  keys + Ref.map in s.refs}
+sig MapRef extends Ref {}
+fact {State.obj[MapRef] in Map}
+
+sig Iterator extends Object {
+  left, done: set Ref,
+  lastRef: lone done
+  }{all s: State | done + left + lastRef in s.refs}
+sig IteratorRef extends Ref {}
+fact {State.obj[IteratorRef] in Iterator}
+
+sig Set extends Object {
+  elts: set Ref
+  }{all s: State | elts in s.refs}
+sig SetRef extends Ref {}
+fact {State.obj[SetRef] in Set}
+
+abstract sig ViewType {}
+one sig KeySetView, KeySetView', IteratorView extends ViewType {}
+fact ViewTypes {
+  State.views[KeySetView] in MapRef -> SetRef
+  State.views[KeySetView'] in SetRef -> MapRef
+  State.views[IteratorView] in IteratorRef -> SetRef
+  all s: State | s.views[KeySetView] = ~(s.views[KeySetView'])
+  }
+
+/**
+ * mods is refs modified directly or by view mechanism
+ * doesn't handle possibility of modifying an object and its view at once?
+ * should we limit frame conds to non-dirty refs?
+ */
+pred modifies [pre, post: State, rs: set Ref] {
+  let vr = pre.views[ViewType], mods = rs.*vr {
+    all r: pre.refs - mods | pre.obj[r] = post.obj[r]
+    all b: mods, v: pre.refs, t: ViewType |
+      b->v in pre.views[t] => viewFrame [t, pre.obj[v], post.obj[v], post.obj[b]]
+    post.dirty = pre.dirty +
+      {b: pre.refs | some v: Ref, t: ViewType |
+          b->v in pre.views[t] && !viewFrame [t, pre.obj[v], post.obj[v], post.obj[b]]
+      }
+    }
+  }
+
+pred allocates [pre, post: State, rs: set Ref] {
+  no rs & pre.refs
+  post.refs = pre.refs + rs
+  }
+
+/** 
+ * models frame condition that limits change to view object from v to v' when backing object changes to b'
+ */
+pred viewFrame [t: ViewType, v, v', b': Object] {
+  t in KeySetView => v'.elts = dom [b'.map]
+  t in KeySetView' => b'.elts = dom [v'.map]
+  t in KeySetView' => (b'.elts) <: (v.map) = (b'.elts) <: (v'.map)
+  t in IteratorView => v'.elts = b'.left + b'.done
+  }
+
+pred MapRef.keySet [pre, post: State, setRefs: SetRef] {
+  post.obj[setRefs].elts = dom [pre.obj[this].map]
+  modifies [pre, post, none]
+  allocates [pre, post, setRefs]
+  post.views = pre.views + KeySetView->this->setRefs + KeySetView'->setRefs->this
+  }
+
+pred MapRef.put [pre, post: State, k, v: Ref] {
+  post.obj[this].map = pre.obj[this].map ++ k->v
+  modifies [pre, post, this]
+  allocates [pre, post, none]
+  post.views = pre.views
+  }
+
+pred SetRef.iterator [pre, post: State, iterRef: IteratorRef] {
+  let i = post.obj[iterRef] {
+    i.left = pre.obj[this].elts
+    no i.done + i.lastRef
+    }
+  modifies [pre,post,none]
+  allocates [pre, post, iterRef]
+  post.views = pre.views + IteratorView->iterRef->this
+  }
+
+pred IteratorRef.remove [pre, post: State] {
+  let i = pre.obj[this], i' = post.obj[this] {
+    i'.left = i.left
+    i'.done = i.done - i.lastRef
+    no i'.lastRef
+    }
+  modifies [pre,post,this]
+  allocates [pre, post, none]
+  pre.views = post.views
+  }
+
+pred IteratorRef.next [pre, post: State, ref: Ref] {
+  let i = pre.obj[this], i' = post.obj[this] {
+    ref in i.left
+    i'.left = i.left - ref
+    i'.done = i.done + ref
+    i'.lastRef = ref
+    }
+  modifies [pre, post, this]
+  allocates [pre, post, none]
+  pre.views = post.views
+  }
+
+pred IteratorRef.hasNext [s: State] {
+  some s.obj[this].left
+  }
+
+assert zippishOK {
+  all
+    ks, vs: SetRef,
+    m: MapRef,
+    ki, vi: IteratorRef,
+    k, v: Ref |
+    let s0=so/first,
+    s1=so/next[s0],
+    s2=so/next[s1],
+    s3=so/next[s2],
+    s4=so/next[s3],
+    s5=so/next[s4],
+    s6=so/next[s5],
+    s7=so/next[s6] |
+  ({
+    precondition [s0, ks, vs, m]
+    no s0.dirty
+    ks.iterator [s0, s1, ki]
+    vs.iterator [s1, s2, vi]
+    ki.hasNext [s2]
+    vi.hasNext [s2]
+    ki.this/next [s2, s3, k]
+    vi.this/next [s3, s4, v]
+    m.put [s4, s5, k, v]
+    ki.remove [s5, s6]
+    vi.remove [s6, s7]
+  } => no State.dirty)
+  }
+
+pred precondition [pre: State, ks, vs, m: Ref] {
+  // all these conditions and other errors discovered in scope of 6 but 8,3
+  // in initial state, must have view invariants hold
+  (all t: ViewType, b, v: pre.refs |
+    b->v in pre.views[t] => viewFrame [t, pre.obj[v], pre.obj[v], pre.obj[b]])
+  // sets are not aliases
+--  ks != vs
+  // sets are not views of map
+--  no (ks+vs)->m & ViewType.pre.views
+  // no iterator currently on either set
+--  no Ref->(ks+vs) & ViewType.pre.views
+  }
+
+check zippishOK for 6 but 8 State, 3 ViewType expect 1
+
+/** 
+ * experiment with controlling heap size
+ */
+fact {all s: State | #s.obj < 5}

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/Assembly/FASM.asm

@@ -0,0 +1,350 @@
+
+; flat assembler interface for Win32
+; Copyright (c) 1999-2014, Tomasz Grysztar.
+; All rights reserved.
+
+	format	PE console
+
+section '.text' code readable executable
+
+start:
+
+	mov	[con_handle],STD_OUTPUT_HANDLE
+	mov	esi,_logo
+	call	display_string
+
+	call	get_params
+	jc	information
+
+	call	init_memory
+
+	mov	esi,_memory_prefix
+	call	display_string
+	mov	eax,[memory_end]
+	sub	eax,[memory_start]
+	add	eax,[additional_memory_end]
+	sub	eax,[additional_memory]
+	shr	eax,10
+	call	display_number
+	mov	esi,_memory_suffix
+	call	display_string
+
+	call	[GetTickCount]
+	mov	[start_time],eax
+
+	call	preprocessor
+	call	parser
+	call	assembler
+	call	formatter
+
+	call	display_user_messages
+	movzx	eax,[current_pass]
+	inc	eax
+	call	display_number
+	mov	esi,_passes_suffix
+	call	display_string
+	call	[GetTickCount]
+	sub	eax,[start_time]
+	xor	edx,edx
+	mov	ebx,100
+	div	ebx
+	or	eax,eax
+	jz	display_bytes_count
+	xor	edx,edx
+	mov	ebx,10
+	div	ebx
+	push	edx
+	call	display_number
+	mov	dl,'.'
+	call	display_character
+	pop	eax
+	call	display_number
+	mov	esi,_seconds_suffix
+	call	display_string
+      display_bytes_count:
+	mov	eax,[written_size]
+	call	display_number
+	mov	esi,_bytes_suffix
+	call	display_string
+	xor	al,al
+	jmp	exit_program
+
+information:
+	mov	esi,_usage
+	call	display_string
+	mov	al,1
+	jmp	exit_program
+
+get_params:
+	mov	[input_file],0
+	mov	[output_file],0
+	mov	[symbols_file],0
+	mov	[memory_setting],0
+	mov	[passes_limit],100
+	call	[GetCommandLine]
+	mov	esi,eax
+	mov	edi,params
+    find_command_start:
+	lodsb
+	cmp	al,20h
+	je	find_command_start
+	cmp	al,22h
+	je	skip_quoted_name
+    skip_name:
+	lodsb
+	cmp	al,20h
+	je	find_param
+	or	al,al
+	jz	all_params
+	jmp	skip_name
+    skip_quoted_name:
+	lodsb
+	cmp	al,22h
+	je	find_param
+	or	al,al
+	jz	all_params
+	jmp	skip_quoted_name
+    find_param:
+	lodsb
+	cmp	al,20h
+	je	find_param
+	cmp	al,'-'
+	je	option_param
+	cmp	al,0Dh
+	je	all_params
+	or	al,al
+	jz	all_params
+	cmp	[input_file],0
+	jne	get_output_file
+	mov	[input_file],edi
+	jmp	process_param
+      get_output_file:
+	cmp	[output_file],0
+	jne	bad_params
+	mov	[output_file],edi
+    process_param:
+	cmp	al,22h
+	je	string_param
+    copy_param:
+	stosb
+	lodsb
+	cmp	al,20h
+	je	param_end
+	cmp	al,0Dh
+	je	param_end
+	or	al,al
+	jz	param_end
+	jmp	copy_param
+    string_param:
+	lodsb
+	cmp	al,22h
+	je	string_param_end
+	cmp	al,0Dh
+	je	param_end
+	or	al,al
+	jz	param_end
+	stosb
+	jmp	string_param
+    option_param:
+	lodsb
+	cmp	al,'m'
+	je	memory_option
+	cmp	al,'M'
+	je	memory_option
+	cmp	al,'p'
+	je	passes_option
+	cmp	al,'P'
+	je	passes_option
+	cmp	al,'s'
+	je	symbols_option
+	cmp	al,'S'
+	je	symbols_option
+    bad_params:
+	stc
+	ret
+    get_option_value:
+	xor	eax,eax
+	mov	edx,eax
+    get_option_digit:
+	lodsb
+	cmp	al,20h
+	je	option_value_ok
+	cmp	al,0Dh
+	je	option_value_ok
+	or	al,al
+	jz	option_value_ok
+	sub	al,30h
+	jc	invalid_option_value
+	cmp	al,9
+	ja	invalid_option_value
+	imul	edx,10
+	jo	invalid_option_value
+	add	edx,eax
+	jc	invalid_option_value
+	jmp	get_option_digit
+    option_value_ok:
+	dec	esi
+	clc
+	ret
+    invalid_option_value:
+	stc
+	ret
+    memory_option:
+	lodsb
+	cmp	al,20h
+	je	memory_option
+	cmp	al,0Dh
+	je	bad_params
+	or	al,al
+	jz	bad_params
+	dec	esi
+	call	get_option_value
+	or	edx,edx
+	jz	bad_params
+	cmp	edx,1 shl (32-10)
+	jae	bad_params
+	mov	[memory_setting],edx
+	jmp	find_param
+    passes_option:
+	lodsb
+	cmp	al,20h
+	je	passes_option
+	cmp	al,0Dh
+	je	bad_params
+	or	al,al
+	jz	bad_params
+	dec	esi
+	call	get_option_value
+	or	edx,edx
+	jz	bad_params
+	cmp	edx,10000h
+	ja	bad_params
+	mov	[passes_limit],dx
+	jmp	find_param
+    symbols_option:
+	mov	[symbols_file],edi
+      find_symbols_file_name:
+	lodsb
+	cmp	al,20h
+	jne	process_param
+	jmp	find_symbols_file_name
+    param_end:
+	dec	esi
+    string_param_end:
+	xor	al,al
+	stosb
+	jmp	find_param
+    all_params:
+	cmp	[input_file],0
+	je	bad_params
+	clc
+	ret
+
+include 'system.inc'
+
+include '..\errors.inc'
+include '..\symbdump.inc'
+include '..\preproce.inc'
+include '..\parser.inc'
+include '..\exprpars.inc'
+include '..\assemble.inc'
+include '..\exprcalc.inc'
+include '..\formats.inc'
+include '..\x86_64.inc'
+include '..\avx.inc'
+
+include '..\tables.inc'
+include '..\messages.inc'
+
+section '.data' data readable writeable
+
+include '..\version.inc'
+
+_copyright db 'Copyright (c) 1999-2014, Tomasz Grysztar',0Dh,0Ah,0
+
+_logo db 'flat assembler  version ',VERSION_STRING,0
+_usage db 0Dh,0Ah
+       db 'usage: fasm <source> [output]',0Dh,0Ah
+       db 'optional settings:',0Dh,0Ah
+       db ' -m <limit>    set the limit in kilobytes for the available memory',0Dh,0Ah
+       db ' -p <limit>    set the maximum allowed number of passes',0Dh,0Ah
+       db ' -s <file>     dump symbolic information for debugging',0Dh,0Ah
+       db 0
+_memory_prefix db '  (',0
+_memory_suffix db ' kilobytes memory)',0Dh,0Ah,0
+_passes_suffix db ' passes, ',0
+_seconds_suffix db ' seconds, ',0
+_bytes_suffix db ' bytes.',0Dh,0Ah,0
+
+align 4
+
+include '..\variable.inc'
+
+con_handle dd ?
+memory_setting dd ?
+start_time dd ?
+bytes_count dd ?
+displayed_count dd ?
+character db ?
+last_displayed rb 2
+
+params rb 1000h
+options rb 1000h
+buffer rb 4000h
+
+stack 10000h
+
+section '.idata' import data readable writeable
+
+  dd 0,0,0,rva kernel_name,rva kernel_table
+  dd 0,0,0,0,0
+
+  kernel_table:
+    ExitProcess dd rva _ExitProcess
+    CreateFile dd rva _CreateFileA
+    ReadFile dd rva _ReadFile
+    WriteFile dd rva _WriteFile
+    CloseHandle dd rva _CloseHandle
+    SetFilePointer dd rva _SetFilePointer
+    GetCommandLine dd rva _GetCommandLineA
+    GetEnvironmentVariable dd rva _GetEnvironmentVariable
+    GetStdHandle dd rva _GetStdHandle
+    VirtualAlloc dd rva _VirtualAlloc
+    VirtualFree dd rva _VirtualFree
+    GetTickCount dd rva _GetTickCount
+    GetSystemTime dd rva _GetSystemTime
+    GlobalMemoryStatus dd rva _GlobalMemoryStatus
+    dd 0
+
+  kernel_name db 'KERNEL32.DLL',0
+
+  _ExitProcess dw 0
+    db 'ExitProcess',0
+  _CreateFileA dw 0
+    db 'CreateFileA',0
+  _ReadFile dw 0
+    db 'ReadFile',0
+  _WriteFile dw 0
+    db 'WriteFile',0
+  _CloseHandle dw 0
+    db 'CloseHandle',0
+  _SetFilePointer dw 0
+    db 'SetFilePointer',0
+  _GetCommandLineA dw 0
+    db 'GetCommandLineA',0
+  _GetEnvironmentVariable dw 0
+    db 'GetEnvironmentVariableA',0
+  _GetStdHandle dw 0
+    db 'GetStdHandle',0
+  _VirtualAlloc dw 0
+    db 'VirtualAlloc',0
+  _VirtualFree dw 0
+    db 'VirtualFree',0
+  _GetTickCount dw 0
+    db 'GetTickCount',0
+  _GetSystemTime dw 0
+    db 'GetSystemTime',0
+  _GlobalMemoryStatus dw 0
+    db 'GlobalMemoryStatus',0
+
+section '.reloc' fixups data readable discardable

samples/Assembly/SYSTEM.inc

@@ -0,0 +1,503 @@
+
+; flat assembler interface for Win32
+; Copyright (c) 1999-2014, Tomasz Grysztar.
+; All rights reserved.
+
+CREATE_NEW	       = 1
+CREATE_ALWAYS	       = 2
+OPEN_EXISTING	       = 3
+OPEN_ALWAYS	       = 4
+TRUNCATE_EXISTING      = 5
+
+FILE_SHARE_READ        = 1
+FILE_SHARE_WRITE       = 2
+FILE_SHARE_DELETE      = 4
+
+GENERIC_READ	       = 80000000h
+GENERIC_WRITE	       = 40000000h
+
+STD_INPUT_HANDLE       = 0FFFFFFF6h
+STD_OUTPUT_HANDLE      = 0FFFFFFF5h
+STD_ERROR_HANDLE       = 0FFFFFFF4h
+
+MEM_COMMIT	       = 1000h
+MEM_RESERVE	       = 2000h
+MEM_DECOMMIT	       = 4000h
+MEM_RELEASE	       = 8000h
+MEM_FREE	       = 10000h
+MEM_PRIVATE	       = 20000h
+MEM_MAPPED	       = 40000h
+MEM_RESET	       = 80000h
+MEM_TOP_DOWN	       = 100000h
+
+PAGE_NOACCESS	       = 1
+PAGE_READONLY	       = 2
+PAGE_READWRITE	       = 4
+PAGE_WRITECOPY	       = 8
+PAGE_EXECUTE	       = 10h
+PAGE_EXECUTE_READ      = 20h
+PAGE_EXECUTE_READWRITE = 40h
+PAGE_EXECUTE_WRITECOPY = 80h
+PAGE_GUARD	       = 100h
+PAGE_NOCACHE	       = 200h
+
+init_memory:
+	xor	eax,eax
+	mov	[memory_start],eax
+	mov	eax,esp
+	and	eax,not 0FFFh
+	add	eax,1000h-10000h
+	mov	[stack_limit],eax
+	mov	eax,[memory_setting]
+	shl	eax,10
+	jnz	allocate_memory
+	push	buffer
+	call	[GlobalMemoryStatus]
+	mov	eax,dword [buffer+20]
+	mov	edx,dword [buffer+12]
+	cmp	eax,0
+	jl	large_memory
+	cmp	edx,0
+	jl	large_memory
+	shr	eax,2
+	add	eax,edx
+	jmp	allocate_memory
+    large_memory:
+	mov	eax,80000000h
+    allocate_memory:
+	mov	edx,eax
+	shr	edx,2
+	mov	ecx,eax
+	sub	ecx,edx
+	mov	[memory_end],ecx
+	mov	[additional_memory_end],edx
+	push	PAGE_READWRITE
+	push	MEM_COMMIT
+	push	eax
+	push	0
+	call	[VirtualAlloc]
+	or	eax,eax
+	jz	not_enough_memory
+	mov	[memory_start],eax
+	add	eax,[memory_end]
+	mov	[memory_end],eax
+	mov	[additional_memory],eax
+	add	[additional_memory_end],eax
+	ret
+    not_enough_memory:
+	mov	eax,[additional_memory_end]
+	shl	eax,1
+	cmp	eax,4000h
+	jb	out_of_memory
+	jmp	allocate_memory
+
+exit_program:
+	movzx	eax,al
+	push	eax
+	mov	eax,[memory_start]
+	test	eax,eax
+	jz	do_exit
+	push	MEM_RELEASE
+	push	0
+	push	eax
+	call	[VirtualFree]
+    do_exit:
+	call	[ExitProcess]
+
+get_environment_variable:
+	mov	ecx,[memory_end]
+	sub	ecx,edi
+	cmp	ecx,4000h
+	jbe	buffer_for_variable_ok
+	mov	ecx,4000h
+    buffer_for_variable_ok:
+	push	ecx
+	push	edi
+	push	esi
+	call	[GetEnvironmentVariable]
+	add	edi,eax
+	cmp	edi,[memory_end]
+	jae	out_of_memory
+	ret
+
+open:
+	push	0
+	push	0
+	push	OPEN_EXISTING
+	push	0
+	push	FILE_SHARE_READ
+	push	GENERIC_READ
+	push	edx
+	call	[CreateFile]
+	cmp	eax,-1
+	je	file_error
+	mov	ebx,eax
+	clc
+	ret
+    file_error:
+	stc
+	ret
+create:
+	push	0
+	push	0
+	push	CREATE_ALWAYS
+	push	0
+	push	FILE_SHARE_READ
+	push	GENERIC_WRITE
+	push	edx
+	call	[CreateFile]
+	cmp	eax,-1
+	je	file_error
+	mov	ebx,eax
+	clc
+	ret
+write:
+	push	0
+	push	bytes_count
+	push	ecx
+	push	edx
+	push	ebx
+	call	[WriteFile]
+	or	eax,eax
+	jz	file_error
+	clc
+	ret
+read:
+	mov	ebp,ecx
+	push	0
+	push	bytes_count
+	push	ecx
+	push	edx
+	push	ebx
+	call	[ReadFile]
+	or	eax,eax
+	jz	file_error
+	cmp	ebp,[bytes_count]
+	jne	file_error
+	clc
+	ret
+close:
+	push	ebx
+	call	[CloseHandle]
+	ret
+lseek:
+	movzx	eax,al
+	push	eax
+	push	0
+	push	edx
+	push	ebx
+	call	[SetFilePointer]
+	ret
+
+display_string:
+	push	[con_handle]
+	call	[GetStdHandle]
+	mov	ebp,eax
+	mov	edi,esi
+	or	ecx,-1
+	xor	al,al
+	repne	scasb
+	neg	ecx
+	sub	ecx,2
+	push	0
+	push	bytes_count
+	push	ecx
+	push	esi
+	push	ebp
+	call	[WriteFile]
+	ret
+display_character:
+	push	ebx
+	mov	[character],dl
+	push	[con_handle]
+	call	[GetStdHandle]
+	mov	ebx,eax
+	push	0
+	push	bytes_count
+	push	1
+	push	character
+	push	ebx
+	call	[WriteFile]
+	pop	ebx
+	ret
+display_number:
+	push	ebx
+	mov	ecx,1000000000
+	xor	edx,edx
+	xor	bl,bl
+      display_loop:
+	div	ecx
+	push	edx
+	cmp	ecx,1
+	je	display_digit
+	or	bl,bl
+	jnz	display_digit
+	or	al,al
+	jz	digit_ok
+	not	bl
+      display_digit:
+	mov	dl,al
+	add	dl,30h
+	push	ecx
+	call	display_character
+	pop	ecx
+      digit_ok:
+	mov	eax,ecx
+	xor	edx,edx
+	mov	ecx,10
+	div	ecx
+	mov	ecx,eax
+	pop	eax
+	or	ecx,ecx
+	jnz	display_loop
+	pop	ebx
+	ret
+
+display_user_messages:
+	mov	[displayed_count],0
+	call	show_display_buffer
+	cmp	[displayed_count],1
+	jb	line_break_ok
+	je	make_line_break
+	mov	ax,word [last_displayed]
+	cmp	ax,0A0Dh
+	je	line_break_ok
+	cmp	ax,0D0Ah
+	je	line_break_ok
+      make_line_break:
+	mov	word [buffer],0A0Dh
+	push	[con_handle]
+	call	[GetStdHandle]
+	push	0
+	push	bytes_count
+	push	2
+	push	buffer
+	push	eax
+	call	[WriteFile]
+      line_break_ok:
+	ret
+display_block:
+	add	[displayed_count],ecx
+	cmp	ecx,1
+	ja	take_last_two_characters
+	jb	block_displayed
+	mov	al,[last_displayed+1]
+	mov	ah,[esi]
+	mov	word [last_displayed],ax
+	jmp	block_ok
+      take_last_two_characters:
+	mov	ax,[esi+ecx-2]
+	mov	word [last_displayed],ax
+      block_ok:
+	push	ecx
+	push	[con_handle]
+	call	[GetStdHandle]
+	pop	ecx
+	push	0
+	push	bytes_count
+	push	ecx
+	push	esi
+	push	eax
+	call	[WriteFile]
+      block_displayed:
+	ret
+
+fatal_error:
+	mov	[con_handle],STD_ERROR_HANDLE
+	mov	esi,error_prefix
+	call	display_string
+	pop	esi
+	call	display_string
+	mov	esi,error_suffix
+	call	display_string
+	mov	al,0FFh
+	jmp	exit_program
+assembler_error:
+	mov	[con_handle],STD_ERROR_HANDLE
+	call	display_user_messages
+	push	dword 0
+	mov	ebx,[current_line]
+      get_error_lines:
+	mov	eax,[ebx]
+	cmp	byte [eax],0
+	je	get_next_error_line
+	push	ebx
+	test	byte [ebx+7],80h
+	jz	display_error_line
+	mov	edx,ebx
+      find_definition_origin:
+	mov	edx,[edx+12]
+	test	byte [edx+7],80h
+	jnz	find_definition_origin
+	push	edx
+      get_next_error_line:
+	mov	ebx,[ebx+8]
+	jmp	get_error_lines
+      display_error_line:
+	mov	esi,[ebx]
+	call	display_string
+	mov	esi,line_number_start
+	call	display_string
+	mov	eax,[ebx+4]
+	and	eax,7FFFFFFFh
+	call	display_number
+	mov	dl,']'
+	call	display_character
+	pop	esi
+	cmp	ebx,esi
+	je	line_number_ok
+	mov	dl,20h
+	call	display_character
+	push	esi
+	mov	esi,[esi]
+	movzx	ecx,byte [esi]
+	inc	esi
+	call	display_block
+	mov	esi,line_number_start
+	call	display_string
+	pop	esi
+	mov	eax,[esi+4]
+	and	eax,7FFFFFFFh
+	call	display_number
+	mov	dl,']'
+	call	display_character
+      line_number_ok:
+	mov	esi,line_data_start
+	call	display_string
+	mov	esi,ebx
+	mov	edx,[esi]
+	call	open
+	mov	al,2
+	xor	edx,edx
+	call	lseek
+	mov	edx,[esi+8]
+	sub	eax,edx
+	jz	line_data_displayed
+	push	eax
+	xor	al,al
+	call	lseek
+	mov	ecx,[esp]
+	mov	edx,[additional_memory]
+	lea	eax,[edx+ecx]
+	cmp	eax,[additional_memory_end]
+	ja	out_of_memory
+	call	read
+	call	close
+	pop	ecx
+	mov	esi,[additional_memory]
+      get_line_data:
+	mov	al,[esi]
+	cmp	al,0Ah
+	je	display_line_data
+	cmp	al,0Dh
+	je	display_line_data
+	cmp	al,1Ah
+	je	display_line_data
+	or	al,al
+	jz	display_line_data
+	inc	esi
+	loop	get_line_data
+      display_line_data:
+	mov	ecx,esi
+	mov	esi,[additional_memory]
+	sub	ecx,esi
+	call	display_block
+      line_data_displayed:
+	mov	esi,cr_lf
+	call	display_string
+	pop	ebx
+	or	ebx,ebx
+	jnz	display_error_line
+	mov	esi,error_prefix
+	call	display_string
+	pop	esi
+	call	display_string
+	mov	esi,error_suffix
+	call	display_string
+	mov	al,2
+	jmp	exit_program
+
+make_timestamp:
+	push	buffer
+	call	[GetSystemTime]
+	movzx	ecx,word [buffer]
+	mov	eax,ecx
+	sub	eax,1970
+	mov	ebx,365
+	mul	ebx
+	mov	ebp,eax
+	mov	eax,ecx
+	sub	eax,1969
+	shr	eax,2
+	add	ebp,eax
+	mov	eax,ecx
+	sub	eax,1901
+	mov	ebx,100
+	div	ebx
+	sub	ebp,eax
+	mov	eax,ecx
+	xor	edx,edx
+	sub	eax,1601
+	mov	ebx,400
+	div	ebx
+	add	ebp,eax
+	movzx	ecx,word [buffer+2]
+	mov	eax,ecx
+	dec	eax
+	mov	ebx,30
+	mul	ebx
+	add	ebp,eax
+	cmp	ecx,8
+	jbe	months_correction
+	mov	eax,ecx
+	sub	eax,7
+	shr	eax,1
+	add	ebp,eax
+	mov	ecx,8
+      months_correction:
+	mov	eax,ecx
+	shr	eax,1
+	add	ebp,eax
+	cmp	ecx,2
+	jbe	day_correction_ok
+	sub	ebp,2
+	movzx	ecx,word [buffer]
+	test	ecx,11b
+	jnz	day_correction_ok
+	xor	edx,edx
+	mov	eax,ecx
+	mov	ebx,100
+	div	ebx
+	or	edx,edx
+	jnz	day_correction
+	mov	eax,ecx
+	mov	ebx,400
+	div	ebx
+	or	edx,edx
+	jnz	day_correction_ok
+      day_correction:
+	inc	ebp
+      day_correction_ok:
+	movzx	eax,word [buffer+6]
+	dec	eax
+	add	eax,ebp
+	mov	ebx,24
+	mul	ebx
+	movzx	ecx,word [buffer+8]
+	add	eax,ecx
+	mov	ebx,60
+	mul	ebx
+	movzx	ecx,word [buffer+10]
+	add	eax,ecx
+	mov	ebx,60
+	mul	ebx
+	movzx	ecx,word [buffer+12]
+	add	eax,ecx
+	adc	edx,0
+	ret
+
+error_prefix db 'error: ',0
+error_suffix db '.'
+cr_lf db 0Dh,0Ah,0
+line_number_start db ' [',0
+line_data_start db ':',0Dh,0Ah,0

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++/Math.inl

@@ -0,0 +1,530 @@
+/*
+===========================================================================
+The Open Game Libraries.
+Copyright (C) 2007-2010 Lusito Software
+
+Author:  Santo Pfingsten (TTK-Bandit)
+Purpose: Math namespace
+-----------------------------------------
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source distribution.
+===========================================================================
+*/
+
+#ifndef __OG_MATH_INL__
+#define __OG_MATH_INL__
+
+namespace og {
+
+/*
+==============================================================================
+
+  Math
+
+==============================================================================
+*/
+
+/*
+================
+Math::Abs
+================
+*/
+OG_INLINE int Math::Abs( int i ) {
+#if 1
+	if ( i & 0x80000000 )
+		return 0x80000000 - (i & MASK_SIGNED);
+	return i;
+#else
+   int y = x >> 31;
+   return ( ( x ^ y ) - y );
+#endif
+}
+
+/*
+================
+Math::Fabs
+================
+*/
+OG_INLINE float Math::Fabs( float f ) {
+#if 1
+	uInt *pf = reinterpret_cast<uInt*>(&f);
+	*(pf) &= MASK_SIGNED;
+	return f;
+#else
+	return fabsf( f );
+#endif
+}
+
+/*
+================
+Math::Round
+================
+*/
+OG_INLINE float Math::Round( float f ) {
+	return floorf( f + 0.5f );
+}
+
+/*
+================
+Math::Floor
+================
+*/
+OG_INLINE float Math::Floor( float f ) {
+	return floorf( f );
+}
+
+/*
+================
+Math::Ceil
+================
+*/
+OG_INLINE float Math::Ceil( float f ) {
+	return ceilf( f );
+}
+
+/*
+================
+Math::Ftoi
+
+ok since this is SSE, why should the other ftoi be the faster one ?
+and: we might need to add a check for SSE extensions..
+because sse isn't *really* faster (I actually read that GCC does not handle
+SSE extensions perfectly. I'll find the link and send it to you when you're online)
+================
+*/
+OG_INLINE int Math::Ftoi( float f ) {
+	//! @todo	needs testing
+	// note: sse function cvttss2si
+#if OG_ASM_MSVC
+	int i;
+#if defined(OG_FTOI_USE_SSE)
+	if( SysInfo::cpu.general.SSE ) {
+		__asm cvttss2si	eax, f
+		__asm mov		i, eax
+		return i;
+	} else
+#endif
+	{
+		__asm fld		f
+		__asm fistp		i
+		//__asm mov eax, i // do we need this ? O_o
+	}
+	return i;
+#elif OG_ASM_GNU
+	int i;
+#if defined(OG_FTOI_USE_SSE)
+	if( SysInfo::cpu.general.SSE ) {
+		__asm__ __volatile__( "cvttss2si %1    \n\t"
+			: "=m" (i)
+			: "m" (f)
+		);
+	} else
+#endif
+	{
+		__asm__ __volatile__( "flds %1    \n\t"
+							  "fistpl %0  \n\t"
+			: "=m" (i)
+			: "m" (f)
+		);
+	}
+	return i;
+#else
+	// we use c++ cast instead of c cast (not sure why id did that)
+	return static_cast<int>(f);
+#endif
+}
+
+/*
+================
+Math::FtoiFast
+================
+*/
+OG_INLINE int Math::FtoiFast( float f ) {
+#if OG_ASM_MSVC
+	int i;
+	__asm fld		f
+	__asm fistp		i
+	//__asm mov eax, i // do we need this ? O_o
+	return i;
+#elif OG_ASM_GNU
+	int i;
+	__asm__ __volatile__( "flds %1    \n\t"
+						  "fistpl %0  \n\t"
+		: "=m" (i)
+		: "m" (f)
+	);
+	return i;
+#else
+	// we use c++ cast instead of c cast (not sure why id did that)
+	return static_cast<int>(f);
+#endif
+}
+
+/*
+================
+Math::Ftol
+================
+*/
+OG_INLINE long Math::Ftol( float f ) {
+#if OG_ASM_MSVC
+	long i;
+	__asm fld		f
+	__asm fistp		i
+	//__asm mov eax, i // do we need this ? O_o
+	return i;
+#elif OG_ASM_GNU
+	long i;
+	__asm__ __volatile__( "flds %1    \n\t"
+						  "fistpl %0  \n\t"
+		: "=m" (i)
+		: "m" (f)
+	);
+	return i;
+#else
+	// we use c++ cast instead of c cast (not sure why id did that)
+	return static_cast<long>(f);
+#endif
+}
+
+/*
+================
+Math::Sign
+================
+*/
+OG_INLINE float Math::Sign( float f )	{
+	if ( f > 0.0f )
+		return 1.0f;
+	if ( f < 0.0f )
+		return -1.0f;
+	return 0.0f;
+}
+
+/*
+================
+Math::Fmod
+================
+*/
+OG_INLINE float Math::Fmod( float numerator, float denominator ) {
+	return fmodf( numerator, denominator );
+}
+
+/*
+================
+Math::Modf
+================
+*/
+OG_INLINE float Math::Modf( float f, float& i ) {
+	return modff( f, &i );
+}
+OG_INLINE float Math::Modf( float f ) {
+	float i;
+	return modff( f, &i );
+}
+
+/*
+================
+Math::Sqrt
+================
+*/
+OG_INLINE float Math::Sqrt( float f ) {
+	return sqrtf( f );
+}
+
+/*
+================
+Math::InvSqrt
+
+Cannot be 0.0f
+================
+*/
+OG_INLINE float Math::InvSqrt( float f ) {
+	OG_ASSERT( f != 0.0f );
+	return 1.0f / sqrtf( f );
+}
+
+/*
+================
+Math::RSqrt
+
+Can be 0.0f
+================
+*/
+OG_INLINE float Math::RSqrt( float f ) {
+	float g = 0.5f * f;
+	int i = *reinterpret_cast<int *>(&f);
+
+	// do a guess
+	i = 0x5f375a86 - ( i>>1 );
+	f = *reinterpret_cast<float *>(&i);
+
+	// Newtons calculation
+	f = f * ( 1.5f - g * f * f );
+	return f;
+}
+
+/*
+================
+Math::Log/Log2/Log10
+
+Log of 0 is bad.
+I've also heard you're not really
+supposed to do log of negatives, yet
+they work fine.
+================
+*/
+OG_INLINE float Math::Log( float f ) {
+	OG_ASSERT( f != 0.0f );
+	return logf( f );
+}
+OG_INLINE float Math::Log2( float f ) {
+	OG_ASSERT( f != 0.0f );
+	return INV_LN_2 * logf( f );
+}
+OG_INLINE float Math::Log10( float f ) {
+	OG_ASSERT( f != 0.0f );
+	return INV_LN_10 * logf( f );
+}
+
+/*
+================
+Math::Pow
+================
+*/
+OG_INLINE float Math::Pow( float base, float exp ) {
+	return powf( base, exp );
+}
+
+/*
+================
+Math::Exp
+================
+*/
+OG_INLINE float Math::Exp( float f ) {
+	return expf( f );
+}
+
+/*
+================
+Math::IsPowerOfTwo
+================
+*/
+OG_INLINE bool Math::IsPowerOfTwo( int x ) {
+	// This is the faster of the two known methods
+	// with the x > 0 check moved to the beginning
+	return x > 0 && ( x & ( x - 1 ) ) == 0;
+}
+
+/*
+================
+Math::HigherPowerOfTwo
+================
+*/
+OG_INLINE int Math::HigherPowerOfTwo( int x ) {
+	x--;
+	x |= x >> 1;
+	x |= x >> 2;
+	x |= x >> 4;
+	x |= x >> 8;
+	x |= x >> 16;
+	return x + 1;
+}
+
+/*
+================
+Math::LowerPowerOfTwo
+================
+*/
+OG_INLINE int Math::LowerPowerOfTwo( int x ) {
+	return HigherPowerOfTwo( x ) >> 1;
+}
+
+/*
+================
+Math::FloorPowerOfTwo
+================
+*/
+OG_INLINE int Math::FloorPowerOfTwo( int x ) {
+	return IsPowerOfTwo( x ) ? x : LowerPowerOfTwo( x );
+}
+
+/*
+================
+Math::CeilPowerOfTwo
+================
+*/
+OG_INLINE int Math::CeilPowerOfTwo( int x ) {
+	return IsPowerOfTwo( x ) ? x : HigherPowerOfTwo( x );
+}
+
+/*
+================
+Math::ClosestPowerOfTwo
+================
+*/
+OG_INLINE int Math::ClosestPowerOfTwo( int x ) {
+	if ( IsPowerOfTwo( x ) )
+		return x;
+	int high = HigherPowerOfTwo( x );
+	int low = high >> 1;
+	return ((high-x) < (x-low)) ? high : low;
+}
+
+/*
+================
+Math::Digits
+================
+*/
+OG_INLINE int Math::Digits( int x ) {
+	int digits = 1;
+	int step = 10;
+	while (step <= x) {
+		digits++;
+		step *= 10;
+	}
+	return digits;
+}
+
+/*
+================
+Math::Sin/ASin
+================
+*/
+OG_INLINE float Math::Sin( float f ) {
+	return sinf( f );
+}
+OG_INLINE float Math::ASin( float f ) {
+	if ( f <= -1.0f )
+		return -HALF_PI;
+	if ( f >= 1.0f )
+		return HALF_PI;
+	return asinf( f );
+}
+
+/*
+================
+Math::Cos/ACos
+================
+*/
+OG_INLINE float Math::Cos( float f ) {
+	return cosf( f );
+}
+OG_INLINE float Math::ACos( float f ) {
+	if ( f <= -1.0f )
+		return PI;
+	if ( f >= 1.0f )
+		return 0.0f;
+	return acosf( f );
+}
+
+/*
+================
+Math::Tan/ATan
+================
+*/
+OG_INLINE float Math::Tan( float f ) {
+	return tanf( f );
+}
+OG_INLINE float Math::ATan( float f ) {
+	return atanf( f );
+}
+OG_INLINE float Math::ATan( float f1, float f2 ) {
+	return atan2f( f1, f2 );
+}
+
+/*
+================
+Math::SinCos
+================
+*/
+OG_INLINE void Math::SinCos( float f, float &s, float &c ) {
+#if OG_ASM_MSVC
+	// sometimes assembler is just waaayy faster
+	_asm {
+		fld		f
+		fsincos
+		mov		ecx, c
+		mov		edx, s
+		fstp	dword ptr [ecx]
+		fstp	dword ptr [edx]
+	}
+#elif OG_ASM_GNU
+	asm ("fsincos" : "=t" (c), "=u" (s) : "0" (f));
+#else
+	s = Sin(f);
+	c = Sqrt( 1.0f - s * s ); // faster than calling Cos(f)
+#endif
+}
+
+/*
+================
+Math::Deg2Rad
+================
+*/
+OG_INLINE float Math::Deg2Rad( float f ) {
+	return f * DEG_TO_RAD;
+}
+
+/*
+================
+Math::Rad2Deg
+================
+*/
+OG_INLINE float Math::Rad2Deg( float f ) {
+	return f * RAD_TO_DEG;
+}
+
+/*
+================
+Math::Square
+================
+*/
+OG_INLINE float Math::Square( float v ) {
+	return v * v;
+}
+
+/*
+================
+Math::Cube
+================
+*/
+OG_INLINE float Math::Cube( float v ) {
+	return v * v * v;
+}
+
+/*
+================
+Math::Sec2Ms
+================
+*/
+OG_INLINE int Math::Sec2Ms( int sec ) {
+	return sec * 1000;
+}
+
+/*
+================
+Math::Ms2Sec
+================
+*/
+OG_INLINE int Math::Ms2Sec( int ms ) {
+	return FtoiFast( ms * 0.001f );
+}
+
+}
+
+#endif

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++/epoll_reactor.ipp

@@ -0,0 +1,664 @@
+//
+// detail/impl/epoll_reactor.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
+#define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_EPOLL)
+
+#include <cstddef>
+#include <sys/epoll.h>
+#include <boost/asio/detail/epoll_reactor.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+# include <sys/timerfd.h>
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+epoll_reactor::epoll_reactor(boost::asio::io_service& io_service)
+  : boost::asio::detail::service_base<epoll_reactor>(io_service),
+    io_service_(use_service<io_service_impl>(io_service)),
+    mutex_(),
+    interrupter_(),
+    epoll_fd_(do_epoll_create()),
+    timer_fd_(do_timerfd_create()),
+    shutdown_(false)
+{
+  // Add the interrupter's descriptor to epoll.
+  epoll_event ev = { 0, { 0 } };
+  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
+  ev.data.ptr = &interrupter_;
+  epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
+  interrupter_.interrupt();
+
+  // Add the timer descriptor to epoll.
+  if (timer_fd_ != -1)
+  {
+    ev.events = EPOLLIN | EPOLLERR;
+    ev.data.ptr = &timer_fd_;
+    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
+  }
+}
+
+epoll_reactor::~epoll_reactor()
+{
+  if (epoll_fd_ != -1)
+    close(epoll_fd_);
+  if (timer_fd_ != -1)
+    close(timer_fd_);
+}
+
+void epoll_reactor::shutdown_service()
+{
+  mutex::scoped_lock lock(mutex_);
+  shutdown_ = true;
+  lock.unlock();
+
+  op_queue<operation> ops;
+
+  while (descriptor_state* state = registered_descriptors_.first())
+  {
+    for (int i = 0; i < max_ops; ++i)
+      ops.push(state->op_queue_[i]);
+    state->shutdown_ = true;
+    registered_descriptors_.free(state);
+  }
+
+  timer_queues_.get_all_timers(ops);
+
+  io_service_.abandon_operations(ops);
+}
+
+void epoll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
+{
+  if (fork_ev == boost::asio::io_service::fork_child)
+  {
+    if (epoll_fd_ != -1)
+      ::close(epoll_fd_);
+    epoll_fd_ = -1;
+    epoll_fd_ = do_epoll_create();
+
+    if (timer_fd_ != -1)
+      ::close(timer_fd_);
+    timer_fd_ = -1;
+    timer_fd_ = do_timerfd_create();
+
+    interrupter_.recreate();
+
+    // Add the interrupter's descriptor to epoll.
+    epoll_event ev = { 0, { 0 } };
+    ev.events = EPOLLIN | EPOLLERR | EPOLLET;
+    ev.data.ptr = &interrupter_;
+    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
+    interrupter_.interrupt();
+
+    // Add the timer descriptor to epoll.
+    if (timer_fd_ != -1)
+    {
+      ev.events = EPOLLIN | EPOLLERR;
+      ev.data.ptr = &timer_fd_;
+      epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
+    }
+
+    update_timeout();
+
+    // Re-register all descriptors with epoll.
+    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+    for (descriptor_state* state = registered_descriptors_.first();
+        state != 0; state = state->next_)
+    {
+      ev.events = state->registered_events_;
+      ev.data.ptr = state;
+      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev);
+      if (result != 0)
+      {
+        boost::system::error_code ec(errno,
+            boost::asio::error::get_system_category());
+        boost::asio::detail::throw_error(ec, "epoll re-registration");
+      }
+    }
+  }
+}
+
+void epoll_reactor::init_task()
+{
+  io_service_.init_task();
+}
+
+int epoll_reactor::register_descriptor(socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data)
+{
+  descriptor_data = allocate_descriptor_state();
+
+  {
+    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+    descriptor_data->reactor_ = this;
+    descriptor_data->descriptor_ = descriptor;
+    descriptor_data->shutdown_ = false;
+  }
+
+  epoll_event ev = { 0, { 0 } };
+  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
+  descriptor_data->registered_events_ = ev.events;
+  ev.data.ptr = descriptor_data;
+  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
+  if (result != 0)
+    return errno;
+
+  return 0;
+}
+
+int epoll_reactor::register_internal_descriptor(
+    int op_type, socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
+{
+  descriptor_data = allocate_descriptor_state();
+
+  {
+    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+    descriptor_data->reactor_ = this;
+    descriptor_data->descriptor_ = descriptor;
+    descriptor_data->shutdown_ = false;
+    descriptor_data->op_queue_[op_type].push(op);
+  }
+
+  epoll_event ev = { 0, { 0 } };
+  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
+  descriptor_data->registered_events_ = ev.events;
+  ev.data.ptr = descriptor_data;
+  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
+  if (result != 0)
+    return errno;
+
+  return 0;
+}
+
+void epoll_reactor::move_descriptor(socket_type,
+    epoll_reactor::per_descriptor_data& target_descriptor_data,
+    epoll_reactor::per_descriptor_data& source_descriptor_data)
+{
+  target_descriptor_data = source_descriptor_data;
+  source_descriptor_data = 0;
+}
+
+void epoll_reactor::start_op(int op_type, socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
+    bool is_continuation, bool allow_speculative)
+{
+  if (!descriptor_data)
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  if (descriptor_data->shutdown_)
+  {
+    post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (descriptor_data->op_queue_[op_type].empty())
+  {
+    if (allow_speculative
+        && (op_type != read_op
+          || descriptor_data->op_queue_[except_op].empty()))
+    {
+      if (op->perform())
+      {
+        descriptor_lock.unlock();
+        io_service_.post_immediate_completion(op, is_continuation);
+        return;
+      }
+
+      if (op_type == write_op)
+      {
+        if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
+        {
+          epoll_event ev = { 0, { 0 } };
+          ev.events = descriptor_data->registered_events_ | EPOLLOUT;
+          ev.data.ptr = descriptor_data;
+          if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev) == 0)
+          {
+            descriptor_data->registered_events_ |= ev.events;
+          }
+          else
+          {
+            op->ec_ = boost::system::error_code(errno,
+                boost::asio::error::get_system_category());
+            io_service_.post_immediate_completion(op, is_continuation);
+            return;
+          }
+        }
+      }
+    }
+    else
+    {
+      if (op_type == write_op)
+      {
+        descriptor_data->registered_events_ |= EPOLLOUT;
+      }
+
+      epoll_event ev = { 0, { 0 } };
+      ev.events = descriptor_data->registered_events_;
+      ev.data.ptr = descriptor_data;
+      epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
+    }
+  }
+
+  descriptor_data->op_queue_[op_type].push(op);
+  io_service_.work_started();
+}
+
+void epoll_reactor::cancel_ops(socket_type,
+    epoll_reactor::per_descriptor_data& descriptor_data)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  op_queue<operation> ops;
+  for (int i = 0; i < max_ops; ++i)
+  {
+    while (reactor_op* op = descriptor_data->op_queue_[i].front())
+    {
+      op->ec_ = boost::asio::error::operation_aborted;
+      descriptor_data->op_queue_[i].pop();
+      ops.push(op);
+    }
+  }
+
+  descriptor_lock.unlock();
+
+  io_service_.post_deferred_completions(ops);
+}
+
+void epoll_reactor::deregister_descriptor(socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  if (!descriptor_data->shutdown_)
+  {
+    if (closing)
+    {
+      // The descriptor will be automatically removed from the epoll set when
+      // it is closed.
+    }
+    else
+    {
+      epoll_event ev = { 0, { 0 } };
+      epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
+    }
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
+    {
+      while (reactor_op* op = descriptor_data->op_queue_[i].front())
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        descriptor_data->op_queue_[i].pop();
+        ops.push(op);
+      }
+    }
+
+    descriptor_data->descriptor_ = -1;
+    descriptor_data->shutdown_ = true;
+
+    descriptor_lock.unlock();
+
+    free_descriptor_state(descriptor_data);
+    descriptor_data = 0;
+
+    io_service_.post_deferred_completions(ops);
+  }
+}
+
+void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
+    epoll_reactor::per_descriptor_data& descriptor_data)
+{
+  if (!descriptor_data)
+    return;
+
+  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+  if (!descriptor_data->shutdown_)
+  {
+    epoll_event ev = { 0, { 0 } };
+    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
+
+    op_queue<operation> ops;
+    for (int i = 0; i < max_ops; ++i)
+      ops.push(descriptor_data->op_queue_[i]);
+
+    descriptor_data->descriptor_ = -1;
+    descriptor_data->shutdown_ = true;
+
+    descriptor_lock.unlock();
+
+    free_descriptor_state(descriptor_data);
+    descriptor_data = 0;
+  }
+}
+
+void epoll_reactor::run(bool block, op_queue<operation>& ops)
+{
+  // This code relies on the fact that the task_io_service queues the reactor
+  // task behind all descriptor operations generated by this function. This
+  // means, that by the time we reach this point, any previously returned
+  // descriptor operations have already been dequeued. Therefore it is now safe
+  // for us to reuse and return them for the task_io_service to queue again.
+
+  // Calculate a timeout only if timerfd is not used.
+  int timeout;
+  if (timer_fd_ != -1)
+    timeout = block ? -1 : 0;
+  else
+  {
+    mutex::scoped_lock lock(mutex_);
+    timeout = block ? get_timeout() : 0;
+  }
+
+  // Block on the epoll descriptor.
+  epoll_event events[128];
+  int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
+
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+  bool check_timers = (timer_fd_ == -1);
+#else // defined(BOOST_ASIO_HAS_TIMERFD)
+  bool check_timers = true;
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+
+  // Dispatch the waiting events.
+  for (int i = 0; i < num_events; ++i)
+  {
+    void* ptr = events[i].data.ptr;
+    if (ptr == &interrupter_)
+    {
+      // No need to reset the interrupter since we're leaving the descriptor
+      // in a ready-to-read state and relying on edge-triggered notifications
+      // to make it so that we only get woken up when the descriptor's epoll
+      // registration is updated.
+
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+      if (timer_fd_ == -1)
+        check_timers = true;
+#else // defined(BOOST_ASIO_HAS_TIMERFD)
+      check_timers = true;
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+    }
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+    else if (ptr == &timer_fd_)
+    {
+      check_timers = true;
+    }
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+    else
+    {
+      // The descriptor operation doesn't count as work in and of itself, so we
+      // don't call work_started() here. This still allows the io_service to
+      // stop if the only remaining operations are descriptor operations.
+      descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
+      descriptor_data->set_ready_events(events[i].events);
+      ops.push(descriptor_data);
+    }
+  }
+
+  if (check_timers)
+  {
+    mutex::scoped_lock common_lock(mutex_);
+    timer_queues_.get_ready_timers(ops);
+
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+    if (timer_fd_ != -1)
+    {
+      itimerspec new_timeout;
+      itimerspec old_timeout;
+      int flags = get_timeout(new_timeout);
+      timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
+    }
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+  }
+}
+
+void epoll_reactor::interrupt()
+{
+  epoll_event ev = { 0, { 0 } };
+  ev.events = EPOLLIN | EPOLLERR | EPOLLET;
+  ev.data.ptr = &interrupter_;
+  epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev);
+}
+
+int epoll_reactor::do_epoll_create()
+{
+#if defined(EPOLL_CLOEXEC)
+  int fd = epoll_create1(EPOLL_CLOEXEC);
+#else // defined(EPOLL_CLOEXEC)
+  int fd = -1;
+  errno = EINVAL;
+#endif // defined(EPOLL_CLOEXEC)
+
+  if (fd == -1 && (errno == EINVAL || errno == ENOSYS))
+  {
+    fd = epoll_create(epoll_size);
+    if (fd != -1)
+      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+  }
+
+  if (fd == -1)
+  {
+    boost::system::error_code ec(errno,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "epoll");
+  }
+
+  return fd;
+}
+
+int epoll_reactor::do_timerfd_create()
+{
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+# if defined(TFD_CLOEXEC)
+  int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
+# else // defined(TFD_CLOEXEC)
+  int fd = -1;
+  errno = EINVAL;
+# endif // defined(TFD_CLOEXEC)
+
+  if (fd == -1 && errno == EINVAL)
+  {
+    fd = timerfd_create(CLOCK_MONOTONIC, 0);
+    if (fd != -1)
+      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
+  }
+
+  return fd;
+#else // defined(BOOST_ASIO_HAS_TIMERFD)
+  return -1;
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+}
+
+epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
+{
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+  return registered_descriptors_.alloc();
+}
+
+void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
+{
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
+  registered_descriptors_.free(s);
+}
+
+void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.insert(&queue);
+}
+
+void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.erase(&queue);
+}
+
+void epoll_reactor::update_timeout()
+{
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+  if (timer_fd_ != -1)
+  {
+    itimerspec new_timeout;
+    itimerspec old_timeout;
+    int flags = get_timeout(new_timeout);
+    timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
+    return;
+  }
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+  interrupt();
+}
+
+int epoll_reactor::get_timeout()
+{
+  // By default we will wait no longer than 5 minutes. This will ensure that
+  // any changes to the system clock are detected after no longer than this.
+  return timer_queues_.wait_duration_msec(5 * 60 * 1000);
+}
+
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+int epoll_reactor::get_timeout(itimerspec& ts)
+{
+  ts.it_interval.tv_sec = 0;
+  ts.it_interval.tv_nsec = 0;
+
+  long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
+  ts.it_value.tv_sec = usec / 1000000;
+  ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
+
+  return usec ? 0 : TFD_TIMER_ABSTIME;
+}
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+
+struct epoll_reactor::perform_io_cleanup_on_block_exit
+{
+  explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
+    : reactor_(r), first_op_(0)
+  {
+  }
+
+  ~perform_io_cleanup_on_block_exit()
+  {
+    if (first_op_)
+    {
+      // Post the remaining completed operations for invocation.
+      if (!ops_.empty())
+        reactor_->io_service_.post_deferred_completions(ops_);
+
+      // A user-initiated operation has completed, but there's no need to
+      // explicitly call work_finished() here. Instead, we'll take advantage of
+      // the fact that the task_io_service will call work_finished() once we
+      // return.
+    }
+    else
+    {
+      // No user-initiated operations have completed, so we need to compensate
+      // for the work_finished() call that the task_io_service will make once
+      // this operation returns.
+      reactor_->io_service_.work_started();
+    }
+  }
+
+  epoll_reactor* reactor_;
+  op_queue<operation> ops_;
+  operation* first_op_;
+};
+
+epoll_reactor::descriptor_state::descriptor_state()
+  : operation(&epoll_reactor::descriptor_state::do_complete)
+{
+}
+
+operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
+{
+  mutex_.lock();
+  perform_io_cleanup_on_block_exit io_cleanup(reactor_);
+  mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
+
+  // Exception operations must be processed first to ensure that any
+  // out-of-band data is read before normal data.
+  static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
+  for (int j = max_ops - 1; j >= 0; --j)
+  {
+    if (events & (flag[j] | EPOLLERR | EPOLLHUP))
+    {
+      while (reactor_op* op = op_queue_[j].front())
+      {
+        if (op->perform())
+        {
+          op_queue_[j].pop();
+          io_cleanup.ops_.push(op);
+        }
+        else
+          break;
+      }
+    }
+  }
+
+  // The first operation will be returned for completion now. The others will
+  // be posted for later by the io_cleanup object's destructor.
+  io_cleanup.first_op_ = io_cleanup.ops_.front();
+  io_cleanup.ops_.pop();
+  return io_cleanup.first_op_;
+}
+
+void epoll_reactor::descriptor_state::do_complete(
+    io_service_impl* owner, operation* base,
+    const boost::system::error_code& ec, std::size_t bytes_transferred)
+{
+  if (owner)
+  {
+    descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
+    uint32_t events = static_cast<uint32_t>(bytes_transferred);
+    if (operation* op = descriptor_data->perform_io(events))
+    {
+      op->complete(*owner, ec, 0);
+    }
+  }
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_EPOLL)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP

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/Common Lisp/macros-advanced.cl

@@ -0,0 +1,82 @@
+;; @file macros-advanced.cl
+;;
+;; @breif Advanced macro practices - defining your own macros
+;;
+;; Macro definition skeleton:
+;; (defmacro name (parameter*)
+;;   "Optional documentation string"
+;;   body-form*)
+;;
+;; Note that backquote expression is most often used in the `body-form`
+;;
+
+; `primep` test a number for prime
+(defun primep (n)
+  "test a number for prime"
+  (if (< n 2) (return-from primep))
+  (do ((i 2 (1+ i)) (p t (not (zerop (mod n i)))))
+      ((> i (sqrt n)) p)
+    (when (not p) (return))))
+; `next-prime` return the next prime bigger than the specified number
+(defun next-prime (n)
+  "return the next prime bigger than the speicified number"
+  (do ((i (1+ n) (1+ i)))
+      ((primep i) i)))
+;
+; The recommended procedures to writting a new macro are as follows:
+; 1. Write a sample call to the macro and the code it should expand into
+(do-primes (p 0 19)
+  (format t "~d " p))
+; Expected expanded codes
+(do ((p (next-prime (- 0 1)) (next-prime p)))
+    ((> p 19))
+  (format t "~d " p))
+; 2. Write code that generate the hardwritten expansion from the arguments in
+; the sample call
+(defmacro do-primes (var-and-range &rest body)
+  (let ((var (first var-and-range))
+        (start (second var-and-range))
+        (end (third var-and-range)))
+    `(do ((,var (next-prime (- ,start 1)) (next-prime ,var)))
+         ((> ,var ,end))
+      ,@body)))
+; 2-1. More concise implementations with the 'parameter list destructuring' and
+; '&body' synonym, it also emits more friendly messages on incorrent input.
+(defmacro do-primes ((var start end) &body body)
+  `(do ((,var (next-prime (- ,start 1)) (next-prime ,var)))
+       ((> ,var ,end))
+    ,@body))
+; 2-2. Test the result of macro expansion with the `macroexpand-1` function
+(macroexpand-1 '(do-primes (p 0 19) (format t "~d " p)))
+; 3. Make sure the macro abstraction does not "leak"
+(defmacro do-primes ((var start end) &body body)
+  (let ((end-value-name (gensym)))
+    `(do ((,var (next-prime (- ,start 1)) (next-prime ,var))
+          (,end-value-name ,end))
+         ((> ,var ,end-value-name))
+      ,@body)))
+; 3-1. Rules to observe to avoid common and possible leaks
+;   a. include any subforms in the expansion in positions that will be evaluated
+;      in the same order as the subforms appear in the macro call
+;   b. make sure subforms are evaluated only once by creating a variable in the
+;      expansion to hold the value of evaluating the argument form, and then
+;      using that variable anywhere else the value is needed in the expansion
+;   c. use `gensym` at macro expansion time to create variable names used in the
+;      expansion
+;
+; Appendix I. Macro-writting macros, 'with-gensyms', to guranttee that rule c
+; gets observed.
+; Example usage of `with-gensyms`
+(defmacro do-primes-a ((var start end) &body body)
+  "do-primes implementation with macro-writting macro 'with-gensyms'"
+  (with-gensyms (end-value-name)
+    `(do ((,var (next-prime (- ,start 1)) (next-prime ,var))
+          (,end-value-name ,end))
+         ((> ,var ,end-value-name))
+      ,@body)))
+; Define the macro, note how comma is used to interpolate the value of the loop
+; expression
+(defmacro with-gensyms ((&rest names) &body body)
+  `(let ,(loop for n in names collect `(,n (gensym)))
+    ,@body)
+)

samples/Common Lisp/motor-inferencia.cl

@@ -0,0 +1,475 @@
+#|
+ESCUELA POLITECNICA SUPERIOR - UNIVERSIDAD AUTONOMA DE MADRID
+INTELIGENCIA ARTIFICIAL
+
+Motor de inferencia
+Basado en parte en "Paradigms of AI Programming: Case Studies
+in Common Lisp", de Peter Norvig, 1992
+|#
+
+
+;;;;;;;;;;;;;;;;;;;;;
+;;;; Global variables
+;;;;;;;;;;;;;;;;;;;;;
+
+
+(defvar *hypothesis-list*)
+(defvar *rule-list*)
+(defvar *fact-list*)
+
+;;;;;;;;;;;;;;;;;;;;;
+;;;; Constants
+;;;;;;;;;;;;;;;;;;;;;
+
+(defconstant +fail+ nil "Indicates unification failure")
+
+(defconstant +no-bindings+ '((nil))
+  "Indicates unification success, with no variables.")
+
+(defconstant *mundo-abierto* nil)
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Functions for the user
+;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; Resets *fact-list* to NIL
+(defun erase-facts () (setq *fact-list* nil))
+
+(defun set-hypothesis-list (h) (setq *hypothesis-list* h))
+
+
+;; Returns a list of solutions, each one satisfying all the hypothesis contained
+;; in *hypothesis-list*
+(defun motor-inferencia ()
+  (consulta *hypothesis-list*))
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Auxiliary functions
+;;;;;;;;;;;;;;;;;;;;;;;;
+
+#|____________________________________________________________________________
+FUNCTION: CONSULTA
+
+COMMENTS:
+CONSULTA receives a list of hypothesis (variable <hypotheses>), and returns
+a list of binding lists (each binding list being a solution).
+
+EXAMPLES:
+hypotheses is:
+((brothers ?x ?y) (neighbours juan ?x)).
+
+That is, we are searching the brothers of the possible neighbors of Juan.
+
+The function can return in this case:
+ 
+(((?x . sergio) (?y . javier)) ((?x . julian) (?y . mario)) ((?x . julian) (?y . pedro))).
+That is, the neighbors of Juan (Sergio and Julian) have 3 brothers in total(Javier, Mario, Pedro)
+____________________________________________________________________________|#
+
+(defun consulta (hypotheses)
+  (if (null hypotheses) (list +no-bindings+)
+    (mapcan #'(lambda (b)
+                (mapcar #'(lambda (x) (une-bindings-con-bindings b x))
+                  (consulta (subst-bindings b (rest hypotheses)))))
+      (find-hypothesis-value (first hypotheses)))))
+
+
+
+#|____________________________________________________________________________
+FUNCTION: FIND-HYPOTHESIS-VALUE
+
+COMMENTS:
+This function manages the query a single query (only one hypothesis) given a binding list.
+It tries (in the following order) to:
+- Answer the query from *fact-list*
+- Answer the query from the rules in *rule-list*
+- Ask the user
+
+The function returns a list of solutions (list of binding lists).
+
+EXAMPLES:
+If hypothesis is (brothers ?x ?y)
+and the function returns:
+(((?x . sergio) (?y . javier)) ((?x . julian) (?y . maria)) ((?x . alberto) (?y . pedro))).
+
+Means that Sergio and Javier and brothers, Julian and Mario are brothers, and Alberto and Pedro are brothers.
+____________________________________________________________________________|#
+
+(defun find-hypothesis-value (hypothesis)
+  (let (rules)
+   (cond
+    ((equality? hypothesis) 
+     (value-from-equality hypothesis))
+    ((value-from-facts hypothesis))
+    ((setq good-rules (find-rules hypothesis)) 
+     (value-from-rules hypothesis good-rules))
+    (t (ask-user hypothesis)))))
+
+
+
+; une-bindings-con-bindings takes two binding lists and returns a binding list
+; Assumes that b1 and b2 are not +fail+
+(defun une-bindings-con-bindings (b1 b2)
+  (cond
+   ((equal b1 +no-bindings+) b2)
+   ((equal b2 +no-bindings+) b1)
+   (T (append b1 b2))))
+
+
+
+#|____________________________________________________________________________
+FUNCTION: VALUE-FROM-FACTS
+
+COMMENTS:
+Returns all the solutions of <hypothesis> obtained directly from *fact-list*
+
+EXAMPLES:
+> (setf *fact-list* '((man luis) (man pedro)(woman mart)(man daniel)(woman laura)))
+
+> (value-from-facts '(man ?x))
+returns:
+
+(((?X . LUIS)) ((?X . PEDRO)) ((?X . DANIEL)))
+____________________________________________________________________________|#
+
+(defun value-from-facts (hypothesis)
+  (mapcan #'(lambda(x) (let ((aux (unify hypothesis x)))
+                         (when aux (list aux)))) *fact-list*))
+
+
+
+
+#|____________________________________________________________________________
+FUNCTION: FIND-RULES
+
+COMMENTS:
+Returns the rules in *rule-list* whose THENs unify with the term given in <hypothesis>
+The variables in the rules that satisfy this requirement are renamed.
+
+EXAMPLES:
+> (setq *rule-list*
+      '((R1 (pertenece ?E (?E . ?_)))
+        (R2 (pertenece ?E (?_ . ?Xs)) :- ((pertenece ?E ?Xs)))))
+
+Then:
+> (FIND-RULES (PERTENECE 1 (2 5)))
+returns:
+((R2 (PERTENECE ?E.1 (?_ . ?XS.2)) :- ((PERTENECE ?E.1 ?XS.2))))
+That is, only the THEN of rule R2 unify with <hypothesis>
+
+However,
+> (FIND-RULES (PERTENECE 1 (1 6 7)))
+
+returns:
+((R1 (PERTENECE ?E.6 (?E.6 . ?_)))
+ (R2 (PERTENECE ?E.7 (?_ . ?XS.8)) :- ((PERTENECE ?E.7 ?XS.8))))
+So the THEN of both rules unify with <hypothesis>
+____________________________________________________________________________|#
+
+(defun find-rules (hypothesis)
+  (mapcan #'(lambda(b) (let ((renamed-rule (rename-variables b)))
+                         (when (in-then? hypothesis renamed-rule)
+                           (list renamed-rule)))) *rule-list*))
+
+(defun in-then? (hypothesis rule)
+  (unless (null (rule-then rule))
+    (not (equal +fail+ (unify hypothesis (rule-then rule))))))
+
+
+
+#|____________________________________________________________________________
+FUNCTION: VALUE-FROM-RULES
+
+COMMENTS:
+Returns all the solutions to <hypothesis> found using all the rules given in
+the list <rules>. Note that a single rule can have multiple solutions.
+____________________________________________________________________________|#
+(defun value-from-rules (hypothesis rules)
+  (mapcan #'(lambda (r) (eval-rule hypothesis r)) rules))
+
+(defun limpia-vinculos (termino bindings)
+  (unify termino (subst-bindings bindings termino)))
+
+
+#|____________________________________________________________________________
+FUNCTION: EVAL-RULE
+
+COMMENTS:
+Returns all the solutions found using the rule given as input argument.
+
+EXAMPLES:
+> (setq *rule-list*
+      '((R1 (pertenece ?E (?E . ?_)))
+        (R2 (pertenece ?E (?_ . ?Xs)) :- ((pertenece ?E ?Xs)))))
+Then:
+> (EVAL-RULE 
+   (PERTENECE 1 (1 6 7)) 
+   (R1 (PERTENECE ?E.42 (?E.42 . ?_))))
+returns:
+(((NIL)))
+That is, the query (PERTENECE 1 (1 6 7)) can be proven from the given rule, and
+no binding in the variables in the query is necessary (in fact, the query has no variables).
+On the other hand:
+> (EVAL-RULE 
+   (PERTENECE 1 (7)) 
+   (R2 (PERTENECE ?E.49 (?_ . ?XS.50)) :- ((PERTENECE ?E.49 ?XS.50))))
+returns:
+NIL
+That is, the query can not be proven from the rule R2.
+____________________________________________________________________________|#
+
+(defun eval-rule (hypothesis rule)
+  (let ((bindings-then 
+          (unify (rule-then rule) hypothesis)))
+    (unless (equal +fail+ bindings-then)
+      (if (rule-ifs rule)
+          (mapcar #'(lambda(b) (limpia-vinculos hypothesis (append bindings-then b)))
+            (consulta (subst-bindings bindings-then (rule-ifs rule))))
+        (list (limpia-vinculos hypothesis bindings-then))))))
+
+
+(defun ask-user (hypothesis)
+  (let ((question hypothesis))
+    (cond
+     ((variables-in question) +fail+)
+     ((not-in-fact-list? question) +fail+)
+     (*mundo-abierto*
+      (format t "~%Es cierto el hecho ~S? (T/nil)" question)
+      (cond
+       ((read) (add-fact question) +no-bindings+)
+       (T (add-fact (list 'NOT question)) +fail+)))
+     (T +fail+))))
+
+
+; value-from-equality:
+(defun value-from-equality (hypothesis)
+  (let ((new-bindings (unify (second hypothesis) (third hypothesis))))
+    (if (not (equal +fail+ new-bindings)) 
+	(list new-bindings))))
+
+
+
+#|____________________________________________________________________________
+FUNCTION: UNIFY
+
+COMMENTS:
+Finds the most general unifier of two input expressions, taking into account the
+bindings specified in the input <bingings>
+In case the two expressions can unify, the function returns the total bindings necessary
+for that unification. Otherwise, returns +fail+
+
+EXAMPLES:
+> (unify '1 '1)
+((NIL)) ;; which is the constant +no-bindings+
+> (unify 1 '2)
+nil     ;; which is the constant +fail+
+> (unify '?x 1)
+((?x . 1))
+> (unify '(1 1) ?x)
+((? x 1 1))
+> (unify '?_ '?x)
+((NIL))
+> (unify '(p ?x 1 2) '(p ?y ?_ ?_))
+((?x . ?y))
+> (unify '(?a . ?_) '(1 2 3)) 
+((?a . 1)) 
+> (unify '(?_ ?_) '(1 2))
+((nil))
+> (unify '(?a . ?b) '(1 2 3)) 
+((?b 2 3) (?a . 1)) 
+> (unify '(?a . ?b) '(?v . ?d)) 
+((?b . ?d) (?a . ?v)) 
+> (unify '(?eval (+ 1 1)) '1) 
+nil
+> (unify '(?eval (+ 1 1)) '2) 
+(nil)) 
+____________________________________________________________________________|#
+
+(defun unify (x y &optional (bindings +no-bindings+))
+  "See if x and y match with given bindings.  If they do,
+  return a binding list that would make them equal [p 303]."
+  (cond ((eq bindings +fail+) +fail+)
+        ((eql x y) bindings)
+        ((eval? x) (unify-eval x y bindings))
+        ((eval? y) (unify-eval y x bindings))
+        ((variable? x) (unify-var x y bindings))
+        ((variable? y) (unify-var y x bindings))
+        ((and (consp x) (consp y))
+         (unify (rest x) (rest y) 
+                (unify (first x) (first y) bindings)))
+        (t +fail+)))
+
+
+;; rename-variables: renombra ?X por ?X.1, ?Y por ?Y.2 etc. salvo ?_ que no se renombra
+(defun rename-variables (x)
+  "Replace all variables in x with new ones. Excepto ?_"
+  (sublis (mapcar #'(lambda (var) 
+		      (if (anonymous-var? var)
+			  (make-binding var var)
+			(make-binding var (new-variable var))))
+		  (variables-in x))
+	  x))
+
+
+
+;;;; Auxiliary Functions
+
+(defun unify-var (var x bindings)
+  "Unify var with x, using (and maybe extending) bindings [p 303]."
+  (cond ((or (anonymous-var? var)(anonymous-var? x)) bindings)
+	((get-binding var bindings)
+	 (unify (lookup var bindings) x bindings))
+	((and (variable? x) (get-binding x bindings))
+	 (unify var (lookup x bindings) bindings))
+	((occurs-in? var x bindings)
+	 +fail+)
+	(t (extend-bindings var x bindings))))
+
+(defun variable? (x)
+  "Is x a variable (a symbol starting with ?)?"
+  (and (symbolp x) (eql (char (symbol-name x) 0) #\?)))
+
+(defun get-binding (var bindings)
+  "Find a (variable . value) pair in a binding list."
+  (assoc var bindings))
+
+(defun binding-var (binding)
+  "Get the variable part of a single binding."
+  (car binding))
+
+(defun binding-val (binding)
+  "Get the value part of a single binding."
+  (cdr binding))
+
+(defun make-binding (var val) (cons var val))
+
+(defun lookup (var bindings)
+  "Get the value part (for var) from a binding list."
+  (binding-val (get-binding var bindings)))
+
+(defun extend-bindings (var val bindings)
+  "Add a (var . value) pair to a binding list."
+  (append 
+   (unless (eq bindings +no-bindings+) bindings)
+   (list (make-binding var val))))
+
+(defun occurs-in? (var x bindings)
+  "Does var occur anywhere inside x?"
+  (cond ((eq var x) t)
+        ((and (variable? x) (get-binding x bindings))
+         (occurs-in? var (lookup x bindings) bindings))
+        ((consp x) (or (occurs-in? var (first x) bindings)
+                       (occurs-in? var (rest x) bindings)))
+        (t nil)))
+
+(defun subst-bindings (bindings x)
+  "Substitute the value of variables in bindings into x,
+  taking recursively bound variables into account."
+  (cond ((eq bindings +fail+) +fail+)
+        ((eq bindings +no-bindings+) x)
+        ((and (listp x) (eq '?eval (car x)))
+         (subst-bindings-quote bindings x))
+        ((and (variable? x) (get-binding x bindings))
+         (subst-bindings bindings (lookup x bindings)))
+        ((atom x) x)
+        (t (cons (subst-bindings bindings (car x)) ;; s/reuse-cons/cons
+		 (subst-bindings bindings (cdr x))))))
+
+(defun unifier (x y)
+ "Return something that unifies with both x and y (or fail)."
+ (subst-bindings (unify x y) x))
+
+(defun variables-in (exp)
+  "Return a list of all the variables in EXP."
+  (unique-find-anywhere-if #'variable? exp))
+
+(defun unique-find-anywhere-if (predicate tree &optional found-so-far)
+  "Return a list of leaves of tree satisfying predicate,
+  with duplicates removed."
+  (if (atom tree)
+      (if (funcall predicate tree)
+          (pushnew tree found-so-far)
+          found-so-far)
+    (unique-find-anywhere-if
+        predicate
+        (first tree)
+        (unique-find-anywhere-if predicate (rest tree)
+                                 found-so-far))))
+
+(defun find-anywhere-if (predicate tree)
+  "Does predicate apply to any atom in the tree?"  
+  (if (atom tree)
+      (funcall predicate tree)
+      (or (find-anywhere-if predicate (first tree))
+          (find-anywhere-if predicate (rest tree)))))
+
+(defun new-variable (var)
+  "Create a new variable.  Assumes user never types variables of form ?X.9"
+  (gentemp (format nil "~S." var)))
+;  (gentemp "?") )
+;;;
+
+(defun anonymous-var? (x)
+  (eq x '?_))
+
+(defun subst-bindings-quote (bindings x)
+  "Substitute the value of variables in bindings into x,
+  taking recursively bound variables into account."
+  (cond ((eq bindings +fail+) +fail+)
+        ((eq bindings +no-bindings+) x)
+        ((and (variable? x) (get-binding x bindings))
+         (if (variable? (lookup x bindings))
+             (subst-bindings-quote bindings (lookup x bindings))
+             (subst-bindings-quote bindings (list 'quote (lookup x bindings)))
+         )
+        )     
+        ((atom x) x)
+        (t (cons (subst-bindings-quote bindings (car x)) ;; s/reuse-cons/cons
+		 (subst-bindings-quote bindings (cdr x))))))
+
+(defun eval? (x)
+  (and (consp x) (eq (first x) '?eval)))
+
+(defun unify-eval (x y bindings)
+  (let ((exp (subst-bindings-quote bindings (second x))))
+    (if (variables-in exp)
+	+fail+
+      (unify (eval exp) y bindings))))
+
+
+
+(defun rule-ifs (rule) (fourth rule))
+(defun rule-then (rule) (second rule))
+
+
+(defun equality? (term)
+  (and (consp term) (eql (first term) '?=)))
+
+
+(defun in-fact-list? (expresion)
+  (some #'(lambda(x) (equal x expresion)) *fact-list*))
+                     
+(defun not-in-fact-list? (expresion)
+  (if (eq (car expresion) 'NOT)
+      (in-fact-list? (second expresion))
+    (in-fact-list? (list 'NOT expresion))))
+
+
+;; add-fact:
+
+(defun add-fact (fact)
+  (setq *fact-list* (cons fact *fact-list*)))
+
+
+(defun variable? (x)
+  "Is x a variable (a symbol starting with ?) except ?eval and ?="
+  (and (not (equal x '?eval)) (not (equal x '?=)) 
+       (symbolp x) (eql (char (symbol-name x) 0) #\?)))
+
+
+;; EOF

samples/Component Pascal/Example.cp

@@ -0,0 +1,130 @@
+MODULE ObxControls;
+(**
+    project         = "BlackBox"
+    organization    = "www.oberon.ch"
+    contributors    = "Oberon microsystems"
+    version         = "System/Rsrc/About"
+    copyright       = "System/Rsrc/About"
+    license         = "Docu/BB-License"
+    changes         = ""
+    issues          = ""
+
+**)
+
+IMPORT Dialog, Ports, Properties, Views;
+
+CONST beginner = 0; advanced = 1; expert = 2; guru = 3;    (* user classes *)
+
+TYPE
+    View = POINTER TO RECORD (Views.View)
+        size: INTEGER    (* border size in mm *)
+    END;
+
+VAR
+    data*: RECORD
+        class*: INTEGER;    (* current user class *)
+        list*: Dialog.List;    (* list of currently available sizes, derived from class *)
+        width*: INTEGER    (* width of next view to be opened. Derived from
+                                    class, or entered through a text entry field *)
+    END;
+
+    predef: ARRAY 6 OF INTEGER;    (* table of predefined sizes *)
+
+
+PROCEDURE SetList;
+BEGIN
+    IF data.class = beginner THEN
+        data.list.SetLen(1);
+        data.list.SetItem(0, "default")
+    ELSIF data.class = advanced THEN
+        data.list.SetLen(4);
+        data.list.SetItem(0, "default");
+        data.list.SetItem(1, "small");
+        data.list.SetItem(2, "medium");
+        data.list.SetItem(3, "large");
+    ELSE
+        data.list.SetLen(6);
+        data.list.SetItem(0, "default");
+        data.list.SetItem(1, "small");
+        data.list.SetItem(2, "medium");
+        data.list.SetItem(3, "large");
+        data.list.SetItem(4, "tiny");
+        data.list.SetItem(5, "huge");
+    END
+END SetList;
+
+(* View *)
+
+PROCEDURE (v: View) CopyFromSimpleView (source: Views.View);
+BEGIN
+    v.size := source(View).size
+END CopyFromSimpleView;
+
+PROCEDURE (v: View) Restore (f: Views.Frame; l, t, r, b: INTEGER);
+BEGIN    (* fill view with a red square of size v.size *)
+    IF v.size = 0 THEN v.size := predef[0] END;    (* lazy initialization of size *)
+    f.DrawRect(0, 0, v.size, v.size, Ports.fill, Ports.red)
+END Restore;
+
+PROCEDURE (v: View) HandlePropMsg (VAR msg: Views.PropMessage);
+BEGIN
+    WITH msg: Properties.SizePref DO
+        IF v.size = 0 THEN v.size := predef[0] END;    (* lazy initialization of size *)
+        msg.w := v.size; msg.h := v.size    (* tell environment about desired width and height *)
+    ELSE    (* ignore other messages *)
+    END
+END HandlePropMsg;
+
+(* notifiers *)
+
+PROCEDURE ClassNotify* (op, from, to: INTEGER);
+BEGIN    (* react to change in data.class *)
+    IF op = Dialog.changed THEN
+        IF (to = beginner) OR (to = advanced) & (data.list.index > 3) THEN
+            (* if class is reduced, make sure that selection contains legal elements *)
+            data.list.index := 0; data.width := predef[0];    (* modify interactor *)
+            Dialog.Update(data)    (* redraw controls where necessary *)
+        END;
+        SetList;
+        Dialog.UpdateList(data.list)    (* reconstruct list box contents *)
+    END
+END ClassNotify;
+
+PROCEDURE ListNotify* (op, from, to: INTEGER);
+BEGIN    (* reacto to change in data.list (index to was selected) *)
+    IF op = Dialog.changed THEN
+        data.width := predef[to];    (* modify interactor *)
+        Dialog.Update(data)    (* redraw controls where necessary *)
+    END
+END ListNotify;
+
+(* guards *)
+
+PROCEDURE ListGuard* (VAR par: Dialog.Par);
+BEGIN    (* disable list box for a beginner *)
+    par.disabled := data.class = beginner
+END ListGuard;
+
+PROCEDURE WidthGuard* (VAR par: Dialog.Par);
+BEGIN    (* make text entry field read-only if user is not guru *)
+    par.readOnly := data.class # guru
+END WidthGuard;
+
+(* commands *)
+
+PROCEDURE Open*;
+    VAR v: View;
+BEGIN
+    NEW(v);    (* create and initialize a new view *)
+    v.size := data.width * Ports.mm;    (* define view's size in function of class *)
+    Views.OpenAux(v, "Example")    (* open the view in a window *)
+END Open;
+
+BEGIN    (* initialization of global variables *)
+    predef[0] := 40; predef[1] := 30; predef[2] := 50;    (* predefined sizes *)
+    predef[3] := 70; predef[4] := 20; predef[5] := 100;
+    data.class := beginner;    (* default values *)
+    data.list.index := 0;
+    data.width := predef[0];
+    SetList
+END ObxControls.

samples/Component Pascal/Example2.cps

@@ -0,0 +1,71 @@
+MODULE ObxFact;
+(**
+    project         = "BlackBox"
+    organization    = "www.oberon.ch"
+    contributors    = "Oberon microsystems"
+    version         = "System/Rsrc/About"
+    copyright       = "System/Rsrc/About"
+    license         = "Docu/BB-License"
+    changes         = ""
+    issues          = ""
+
+**)
+
+IMPORT
+    Stores, Models, TextModels, TextControllers, Integers;
+
+PROCEDURE Read(r: TextModels.Reader; VAR x: Integers.Integer);
+    VAR i, len, beg: INTEGER; ch: CHAR; buf: POINTER TO ARRAY OF CHAR;
+BEGIN
+    r.ReadChar(ch);
+    WHILE ~r.eot & (ch <= " ") DO r.ReadChar(ch) END;
+    ASSERT(~r.eot & (((ch >= "0") & (ch <= "9")) OR (ch = "-")));
+    beg := r.Pos() - 1; len := 0;
+    REPEAT INC(len); r.ReadChar(ch) UNTIL r.eot OR (ch < "0") OR (ch > "9");
+    NEW(buf, len + 1);
+    i := 0; r.SetPos(beg);
+    REPEAT r.ReadChar(buf[i]); INC(i) UNTIL i = len;
+    buf[i] := 0X;
+    Integers.ConvertFromString(buf^, x)
+END Read;
+
+PROCEDURE Write(w: TextModels.Writer; x: Integers.Integer);
+    VAR i: INTEGER;
+BEGIN
+    IF Integers.Sign(x) < 0 THEN w.WriteChar("-") END;
+    i := Integers.Digits10Of(x);
+    IF i # 0 THEN
+        REPEAT DEC(i); w.WriteChar(Integers.ThisDigit10(x, i)) UNTIL i = 0
+    ELSE w.WriteChar("0")
+    END
+END Write;
+
+PROCEDURE Compute*;
+    VAR beg, end, i, n: INTEGER; ch: CHAR;
+        s: Stores.Operation;
+        r: TextModels.Reader; w: TextModels.Writer; attr: TextModels.Attributes;
+        c: TextControllers.Controller;
+        x: Integers.Integer;
+BEGIN
+    c := TextControllers.Focus();
+    IF (c # NIL) & c.HasSelection() THEN
+        c.GetSelection(beg, end);
+        r := c.text.NewReader(NIL); r.SetPos(beg); r.ReadChar(ch);
+        WHILE ~r.eot & (beg < end) & (ch <= " ") DO r.ReadChar(ch); INC(beg) END;
+        IF ~r.eot & (beg < end) THEN
+            r.ReadPrev; Read(r, x);
+            end := r.Pos(); r.ReadPrev; attr :=r.attr;
+            IF (Integers.Sign(x) > 0) & (Integers.Compare(x, Integers.Long(MAX(LONGINT))) <= 0) THEN
+                n := SHORT(Integers.Short(x)); i := 2; x := Integers.Long(1);
+                WHILE i <= n DO x := Integers.Product(x, Integers.Long(i)); INC(i) END;
+                Models.BeginScript(c.text, "computation", s);
+                c.text.Delete(beg, end);
+                w := c.text.NewWriter(NIL); w.SetPos(beg); w.SetAttr(attr);
+                Write(w, x);
+                Models.EndScript(c.text, s)
+            END
+        END
+    END
+END Compute;
+
+END ObxFact.

samples/Crystal/const_spec.cr

@@ -0,0 +1,169 @@
+#!/usr/bin/env bin/crystal --run
+require "../../spec_helper"
+
+describe "Codegen: const" do
+  it "define a constant" do
+    run("A = 1; A").to_i.should eq(1)
+  end
+
+  it "support nested constant" do
+    run("class B; A = 1; end; B::A").to_i.should eq(1)
+  end
+
+  it "support constant inside a def" do
+    run("
+      class Foo
+        A = 1
+
+        def foo
+          A
+        end
+      end
+
+      Foo.new.foo
+    ").to_i.should eq(1)
+  end
+
+  it "finds nearest constant first" do
+    run("
+      A = 1
+
+      class Foo
+        A = 2.5_f32
+
+        def foo
+          A
+        end
+      end
+
+      Foo.new.foo
+    ").to_f32.should eq(2.5)
+  end
+
+  it "allows constants with same name" do
+    run("
+      A = 1
+
+      class Foo
+        A = 2.5_f32
+
+        def foo
+          A
+        end
+      end
+
+      A
+      Foo.new.foo
+    ").to_f32.should eq(2.5)
+  end
+
+  it "constants with expression" do
+    run("
+      A = 1 + 1
+      A
+    ").to_i.should eq(2)
+  end
+
+  it "finds global constant" do
+    run("
+      A = 1
+
+      class Foo
+        def foo
+          A
+        end
+      end
+
+      Foo.new.foo
+    ").to_i.should eq(1)
+  end
+
+  it "define a constant in lib" do
+    run("lib Foo; A = 1; end; Foo::A").to_i.should eq(1)
+  end
+
+  it "invokes block in const" do
+    run("require \"prelude\"; A = [\"1\"].map { |x| x.to_i }; A[0]").to_i.should eq(1)
+  end
+
+  it "declare constants in right order" do
+    run("A = 1 + 1; B = true ? A : 0; B").to_i.should eq(2)
+  end
+
+  it "uses correct types lookup" do
+    run("
+      module A
+        class B
+          def foo
+            1
+          end
+        end
+
+        C = B.new;
+      end
+
+      def foo
+        A::C.foo
+      end
+
+      foo
+      ").to_i.should eq(1)
+  end
+
+  it "codegens variable assignment in const" do
+    run("
+      class Foo
+        def initialize(@x)
+        end
+
+        def x
+          @x
+        end
+      end
+
+      A = begin
+            f = Foo.new(1)
+            f
+          end
+
+      def foo
+        A.x
+      end
+
+      foo
+      ").to_i.should eq(1)
+  end
+
+  it "declaring var" do
+    run("
+      BAR = begin
+        a = 1
+        while 1 == 2
+          b = 2
+        end
+        a
+      end
+      class Foo
+        def compile
+          BAR
+        end
+      end
+
+      Foo.new.compile
+      ").to_i.should eq(1)
+  end
+
+  it "initialize const that might raise an exception" do
+    run("
+      require \"prelude\"
+      CONST = (raise \"OH NO\" if 1 == 2)
+
+      def doit
+        CONST
+      rescue
+      end
+
+      doit.nil?
+    ").to_b.should be_true
+  end
+end

samples/Crystal/declare_var_spec.cr

@@ -0,0 +1,79 @@
+#!/usr/bin/env bin/crystal --run
+require "../../spec_helper"
+
+describe "Type inference: declare var" do
+  it "types declare var" do
+    assert_type("a :: Int32") { int32 }
+  end
+
+  it "types declare var and reads it" do
+    assert_type("a :: Int32; a") { int32 }
+  end
+
+  it "types declare var and changes its type" do
+    assert_type("a :: Int32; while 1 == 2; a = 'a'; end; a") { union_of(int32, char) }
+  end
+
+  it "declares instance var which appears in initialize" do
+    result = assert_type("
+      class Foo
+        @x :: Int32
+      end
+
+      Foo.new") { types["Foo"] }
+
+    mod = result.program
+
+    foo = mod.types["Foo"] as NonGenericClassType
+    foo.instance_vars["@x"].type.should eq(mod.int32)
+  end
+
+  it "declares instance var of generic class" do
+    result = assert_type("
+      class Foo(T)
+        @x :: T
+      end
+
+      Foo(Int32).new") do
+        foo = types["Foo"] as GenericClassType
+        foo_i32 = foo.instantiate([int32] of Type | ASTNode)
+        foo_i32.lookup_instance_var("@x").type.should eq(int32)
+        foo_i32
+    end
+  end
+
+  it "declares instance var of generic class after reopen" do
+    result = assert_type("
+      class Foo(T)
+      end
+
+      f = Foo(Int32).new
+
+      class Foo(T)
+        @x :: T
+      end
+
+      f") do
+        foo = types["Foo"] as GenericClassType
+        foo_i32 = foo.instantiate([int32] of Type | ASTNode)
+        foo_i32.lookup_instance_var("@x").type.should eq(int32)
+        foo_i32
+    end
+  end
+
+  it "declares an instance variable in initialize" do
+    assert_type("
+      class Foo
+        def initialize
+          @x :: Int32
+        end
+
+        def x
+          @x
+        end
+      end
+
+      Foo.new.x
+      ") { int32 }
+  end
+end

samples/Crystal/transformer.cr

@@ -0,0 +1,515 @@
+module Crystal
+  class ASTNode
+    def transform(transformer)
+      transformer.before_transform self
+      node = transformer.transform self
+      transformer.after_transform self
+      node
+    end
+  end
+
+  class Transformer
+    def before_transform(node)
+    end
+
+    def after_transform(node)
+    end
+
+    def transform(node : Expressions)
+      exps = [] of ASTNode
+      node.expressions.each do |exp|
+        new_exp = exp.transform(self)
+        if new_exp
+          if new_exp.is_a?(Expressions)
+            exps.concat new_exp.expressions
+          else
+            exps << new_exp
+          end
+        end
+      end
+
+      if exps.length == 1
+        exps[0]
+      else
+        node.expressions = exps
+        node
+      end
+    end
+
+    def transform(node : Call)
+      if node_obj = node.obj
+        node.obj = node_obj.transform(self)
+      end
+      transform_many node.args
+
+      if node_block = node.block
+        node.block = node_block.transform(self)
+      end
+
+      if node_block_arg = node.block_arg
+        node.block_arg = node_block_arg.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : And)
+      node.left = node.left.transform(self)
+      node.right = node.right.transform(self)
+      node
+    end
+
+    def transform(node : Or)
+      node.left = node.left.transform(self)
+      node.right = node.right.transform(self)
+      node
+    end
+
+    def transform(node : StringInterpolation)
+      transform_many node.expressions
+      node
+    end
+
+    def transform(node : ArrayLiteral)
+      transform_many node.elements
+
+      if node_of = node.of
+        node.of = node_of.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : HashLiteral)
+      transform_many node.keys
+      transform_many node.values
+
+      if of_key = node.of_key
+        node.of_key = of_key.transform(self)
+      end
+
+      if of_value = node.of_value
+        node.of_value = of_value.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : If)
+      node.cond = node.cond.transform(self)
+      node.then = node.then.transform(self)
+      node.else = node.else.transform(self)
+      node
+    end
+
+    def transform(node : Unless)
+      node.cond = node.cond.transform(self)
+      node.then = node.then.transform(self)
+      node.else = node.else.transform(self)
+      node
+    end
+
+    def transform(node : IfDef)
+      node.cond = node.cond.transform(self)
+      node.then = node.then.transform(self)
+      node.else = node.else.transform(self)
+      node
+    end
+
+    def transform(node : MultiAssign)
+      transform_many node.targets
+      transform_many node.values
+      node
+    end
+
+    def transform(node : SimpleOr)
+      node.left = node.left.transform(self)
+      node.right = node.right.transform(self)
+      node
+    end
+
+    def transform(node : Def)
+      transform_many node.args
+      node.body = node.body.transform(self)
+
+      if receiver = node.receiver
+        node.receiver = receiver.transform(self)
+      end
+
+      if block_arg = node.block_arg
+        node.block_arg = block_arg.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : Macro)
+      transform_many node.args
+      node.body = node.body.transform(self)
+
+      if receiver = node.receiver
+        node.receiver = receiver.transform(self)
+      end
+
+      if block_arg = node.block_arg
+        node.block_arg = block_arg.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : PointerOf)
+      node.exp = node.exp.transform(self)
+      node
+    end
+
+    def transform(node : SizeOf)
+      node.exp = node.exp.transform(self)
+      node
+    end
+
+    def transform(node : InstanceSizeOf)
+      node.exp = node.exp.transform(self)
+      node
+    end
+
+    def transform(node : IsA)
+      node.obj = node.obj.transform(self)
+      node.const = node.const.transform(self)
+      node
+    end
+
+    def transform(node : RespondsTo)
+      node.obj = node.obj.transform(self)
+      node
+    end
+
+    def transform(node : Case)
+      node.cond = node.cond.transform(self)
+      transform_many node.whens
+
+      if node_else = node.else
+        node.else = node_else.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : When)
+      transform_many node.conds
+      node.body = node.body.transform(self)
+      node
+    end
+
+    def transform(node : ImplicitObj)
+      node
+    end
+
+    def transform(node : ClassDef)
+      node.body = node.body.transform(self)
+
+      if superclass = node.superclass
+        node.superclass = superclass.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : ModuleDef)
+      node.body = node.body.transform(self)
+      node
+    end
+
+    def transform(node : While)
+      node.cond = node.cond.transform(self)
+      node.body = node.body.transform(self)
+      node
+    end
+
+    def transform(node : Generic)
+      node.name = node.name.transform(self)
+      transform_many node.type_vars
+      node
+    end
+
+    def transform(node : ExceptionHandler)
+      node.body = node.body.transform(self)
+      transform_many node.rescues
+
+      if node_ensure = node.ensure
+        node.ensure = node_ensure.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : Rescue)
+      node.body = node.body.transform(self)
+      transform_many node.types
+      node
+    end
+
+    def transform(node : Union)
+      transform_many node.types
+      node
+    end
+
+    def transform(node : Hierarchy)
+      node.name = node.name.transform(self)
+      node
+    end
+
+    def transform(node : Metaclass)
+      node.name = node.name.transform(self)
+      node
+    end
+
+    def transform(node : Arg)
+      if default_value = node.default_value
+        node.default_value = default_value.transform(self)
+      end
+
+      if restriction = node.restriction
+        node.restriction = restriction.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : BlockArg)
+      node.fun = node.fun.transform(self)
+      node
+    end
+
+    def transform(node : Fun)
+      transform_many node.inputs
+
+      if output = node.output
+        node.output = output.transform(self)
+      end
+
+      node
+    end
+
+    def transform(node : Block)
+      node.args.map! { |exp| exp.transform(self) as Var }
+      node.body = node.body.transform(self)
+      node
+    end
+
+    def transform(node : FunLiteral)
+      node.def.body = node.def.body.transform(self)
+      node
+    end
+
+    def transform(node : FunPointer)
+      if obj = node.obj
+        node.obj = obj.transform(self)
+      end
+      node
+    end
+
+    def transform(node : Return)
+      transform_many node.exps
+      node
+    end
+
+    def transform(node : Break)
+      transform_many node.exps
+      node
+    end
+
+    def transform(node : Next)
+      transform_many node.exps
+      node
+    end
+
+    def transform(node : Yield)
+      if scope = node.scope
+        node.scope = scope.transform(self)
+      end
+      transform_many node.exps
+      node
+    end
+
+    def transform(node : Include)
+      node.name = node.name.transform(self)
+      node
+    end
+
+    def transform(node : Extend)
+      node.name = node.name.transform(self)
+      node
+    end
+
+    def transform(node : RangeLiteral)
+      node.from = node.from.transform(self)
+      node.to = node.to.transform(self)
+      node
+    end
+
+    def transform(node : Assign)
+      node.target = node.target.transform(self)
+      node.value = node.value.transform(self)
+      node
+    end
+
+    def transform(node : Nop)
+      node
+    end
+
+    def transform(node : NilLiteral)
+      node
+    end
+
+    def transform(node : BoolLiteral)
+      node
+    end
+
+    def transform(node : NumberLiteral)
+      node
+    end
+
+    def transform(node : CharLiteral)
+      node
+    end
+
+    def transform(node : StringLiteral)
+      node
+    end
+
+    def transform(node : SymbolLiteral)
+      node
+    end
+
+    def transform(node : RegexLiteral)
+      node
+    end
+
+    def transform(node : Var)
+      node
+    end
+
+    def transform(node : MetaVar)
+      node
+    end
+
+    def transform(node : InstanceVar)
+      node
+    end
+
+    def transform(node : ClassVar)
+      node
+    end
+
+    def transform(node : Global)
+      node
+    end
+
+    def transform(node : Require)
+      node
+    end
+
+    def transform(node : Path)
+      node
+    end
+
+    def transform(node : Self)
+      node
+    end
+
+    def transform(node : LibDef)
+      node.body = node.body.transform(self)
+      node
+    end
+
+    def transform(node : FunDef)
+      if body = node.body
+        node.body = body.transform(self)
+      end
+      node
+    end
+
+    def transform(node : TypeDef)
+      node
+    end
+
+    def transform(node : StructDef)
+      node
+    end
+
+    def transform(node : UnionDef)
+      node
+    end
+
+    def transform(node : EnumDef)
+      node
+    end
+
+    def transform(node : ExternalVar)
+      node
+    end
+
+    def transform(node : IndirectRead)
+      node.obj = node.obj.transform(self)
+      node
+    end
+
+    def transform(node : IndirectWrite)
+      node.obj = node.obj.transform(self)
+      node.value = node.value.transform(self)
+      node
+    end
+
+    def transform(node : TypeOf)
+      transform_many node.expressions
+      node
+    end
+
+    def transform(node : Primitive)
+      node
+    end
+
+    def transform(node : Not)
+      node
+    end
+
+    def transform(node : TypeFilteredNode)
+      node
+    end
+
+    def transform(node : TupleLiteral)
+      transform_many node.exps
+      node
+    end
+
+    def transform(node : Cast)
+      node.obj = node.obj.transform(self)
+      node.to = node.to.transform(self)
+      node
+    end
+
+    def transform(node : DeclareVar)
+      node.var = node.var.transform(self)
+      node.declared_type = node.declared_type.transform(self)
+      node
+    end
+
+    def transform(node : Alias)
+      node.value = node.value.transform(self)
+      node
+    end
+
+    def transform(node : TupleIndexer)
+      node
+    end
+
+    def transform(node : Attribute)
+      node
+    end
+
+    def transform_many(exps)
+      exps.map! { |exp| exp.transform(self) } if exps
+    end
+  end
+end

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/Dogescript/example.djs

@@ -0,0 +1,16 @@
+quiet
+ wow 
+    such language
+  very syntax
+        github recognized wow
+loud
+
+such language much friendly
+    rly friendly is true
+        plz console.loge with 'such friend, very inclusive'
+    but
+        plz console.loge with 'no love for doge'
+    wow
+wow
+
+module.exports is language

samples/E/Extends.E

@@ -0,0 +1,31 @@
+# from
+# http://wiki.erights.org/wiki/Walnut/Ordinary_Programming/Objects_and_Functions
+def makeVehicle(self) {
+    def vehicle {
+        to milesTillEmpty() {
+            return self.milesPerGallon() * self.getFuelRemaining()
+        }
+    }
+    return vehicle
+}
+
+def makeCar() {
+    var fuelRemaining := 20
+    def car extends makeVehicle(car) {
+        to milesPerGallon() {return 19}
+        to getFuelRemaining() {return fuelRemaining}
+    }
+    return car
+}
+
+def makeJet() {
+    var fuelRemaining := 2000
+    def jet extends makeVehicle(jet) {
+        to milesPerGallon() {return 2}
+        to getFuelRemaining() {return fuelRemaining}
+    }
+    return jet
+}
+
+def car := makeCar()
+println(`The car can go ${car.milesTillEmpty()} miles.`)

samples/E/Functions.E

@@ -0,0 +1,21 @@
+# from
+# http://wiki.erights.org/wiki/Walnut/Ordinary_Programming/Objects_and_Functions
+def makeCar(var name) {
+    var x := 0
+    var y := 0
+    def car {
+        to moveTo(newX,newY) {
+            x := newX
+            y := newY
+        }
+        to getX() {return x}
+        to getY() {return y}
+        to setName(newName) {name := newName}
+        to getName() {return name}
+    } 
+    return car
+}
+# Now use the makeCar function to make a car, which we will move and print
+def sportsCar := makeCar("Ferrari")
+sportsCar.moveTo(10,20)
+println(`The car ${sportsCar.getName()} is at X location ${sportsCar.getX()}`)

samples/E/Guards.E

@@ -0,0 +1,69 @@
+# from
+# http://wiki.erights.org/wiki/Walnut/Advanced_Topics/Build_your_Own_Guards
+def makeVOCPair(brandName :String) :near {
+
+    var myTempContents := def none {}
+
+    def brand {
+        to __printOn(out :TextWriter) :void {
+            out.print(brandName)
+        }
+    }
+
+    def ProveAuth {
+        to __printOn(out :TextWriter) :void {
+            out.print(`<$brandName prover>`)
+        }
+        to getBrand() :near { return brand }
+        to coerce(specimen, optEjector) :near {
+            def sealedBox {
+                to getBrand() :near { return brand }
+                to offerContent() :void {
+                    myTempContents := specimen
+                }
+            }
+            return sealedBox
+        }
+    }
+    def CheckAuth {
+        to __printOn(out :TextWriter) :void {
+            out.print(`<$brandName checker template>`)
+        }
+        to getBrand() :near { return brand }
+        match [`get`, authList :any[]] {
+            def checker {
+                to __printOn(out :TextWriter) :void {
+                    out.print(`<$brandName checker>`)
+                }
+                to getBrand() :near { return brand }
+                to coerce(specimenBox, optEjector) :any {
+                    myTempContents := null
+                    if (specimenBox.__respondsTo("offerContent", 0)) {
+                      # XXX Using __respondsTo/2 here is a kludge
+                        specimenBox.offerContent()
+                    } else {
+                        myTempContents := specimenBox
+                    }
+                    for auth in authList {
+                        if (auth == myTempContents) {
+                            return auth
+                        }
+                    }
+                    myTempContents := none
+                    throw.eject(optEjector,
+                                `Unmatched $brandName authorization`)
+                }
+            }
+        }
+        match [`__respondsTo`, [`get`, _]] {
+            true
+        }
+        match [`__respondsTo`, [_, _]] {
+            false
+        }
+        match [`__getAllegedType`, []] {
+            null.__getAllegedType()
+        }
+    }
+    return [ProveAuth, CheckAuth]
+}

samples/E/IO.E

@@ -0,0 +1,14 @@
+# E sample from
+# http://wiki.erights.org/wiki/Walnut/Ordinary_Programming/InputOutput
+#File objects for hardwired files:
+def file1 := <file:myFile.txt>
+def file2 := <file:/home/marcs/myFile.txt>
+
+#Using a variable for a file name:
+def filePath := "c:\\docs\\myFile.txt"
+def file3 := <file>[filePath]
+
+#Using a single character to specify a Windows drive
+def file4 := <file:c:/docs/myFile.txt>
+def file5 := <c:/docs/myFile.txt>
+def file6 := <c:\docs\myFile.txt>

samples/E/Promises.E

@@ -0,0 +1,9 @@
+# E snippet from
+# http://wiki.erights.org/wiki/Walnut/Distributed_Computing/Promises
+when (tempVow) -> {
+    #...use tempVow
+} catch prob {
+    #.... report problem
+} finally {
+    #....log event
+}

samples/E/minChat.E

@@ -0,0 +1,18 @@
+# from
+# http://wiki.erights.org/wiki/Walnut/Secure_Distributed_Computing/Auditing_minChat
+pragma.syntax("0.9")
+to send(message) {
+    when (friend<-receive(message)) -> {
+        chatUI.showMessage("self", message)
+    } catch prob {chatUI.showMessage("system", "connection lost")}
+}
+to receive(message) {chatUI.showMessage("friend", message)}
+to receiveFriend(friendRcvr) {
+    bind friend := friendRcvr        
+    chatUI.showMessage("system", "friend has arrived")
+}
+to save(file) {file.setText(makeURIFromObject(chatController))}
+to load(file) {
+    bind friend := getObjectFromURI(file.getText())
+    friend <- receiveFriend(chatController)
+}

samples/Frege/CommandLineClock.fr

@@ -0,0 +1,44 @@
+{-- 
+    This program displays the
+    current time on stdandard output
+    every other second.
+    -}
+    
+module examples.CommandLineClock where
+
+data Date = native java.util.Date where
+    native new :: () -> IO (MutableIO Date)     -- new Date()
+    native toString :: Mutable s Date -> ST s String    -- d.toString()
+
+--- 'IO' action to give us the current time as 'String'
+current :: IO String
+current = do
+    d <- Date.new ()
+    d.toString
+
+{- 
+    "java.lang.Thread.sleep" takes a "long" and
+    returns nothing, but may throw an InterruptedException.
+    This is without doubt an IO action.
+    
+    public static void sleep(long millis)
+                  throws InterruptedException
+    
+    Encoded in Frege:
+    - argument type  long   Long
+    - result         void   ()
+    - does IO               IO ()
+    - throws ...            throws ....
+     
+-}
+-- .... defined in frege.java.Lang
+-- native sleep java.lang.Thread.sleep :: Long -> IO () throws InterruptedException
+
+      
+main args =  
+    forever do
+        current >>= print
+        print "\r"
+        stdout.flush
+        Thread.sleep 999
+                

samples/Frege/Concurrent.fr

@@ -0,0 +1,147 @@
+module examples.Concurrent where
+
+import System.Random
+import Java.Net (URL)
+import Control.Concurrent as C
+
+main2 args = do
+    m <- newEmptyMVar
+    forkIO do
+        m.put 'x'
+        m.put 'y' 
+        m.put 'z'
+    replicateM_ 3 do
+        c <- m.take
+        print "got: "
+        println c  
+        
+            
+example1 = do
+    forkIO (replicateM_ 100000 (putChar 'a'))
+    replicateM_ 100000 (putChar 'b')
+
+example2 =  do
+    s <- getLine
+    case s.long of
+        Right n -> forkIO (setReminder n) >> example2
+        Left _  -> println ("exiting ...")
+    
+setReminder :: Long -> IO ()
+setReminder n = do
+        println ("Ok, I remind you in " ++ show n ++ " seconds")
+        Thread.sleep (1000L*n)
+        println (show n ++ " seconds is up!")
+
+table = "table"
+            
+mainPhil _ = do
+    [fork1,fork2,fork3,fork4,fork5] <- mapM MVar.new [1..5]
+    forkIO (philosopher "Kant" fork5 fork1)
+    forkIO (philosopher "Locke" fork1 fork2)
+    forkIO (philosopher "Wittgenstein" fork2 fork3)
+    forkIO (philosopher "Nozick" fork3 fork4)
+    forkIO (philosopher "Mises" fork4 fork5)
+    return ()    
+
+philosopher :: String -> MVar Int -> MVar Int -> IO ()
+philosopher me left right = do
+    g <- Random.newStdGen
+    let phil g  = do
+            let (tT,g1) = Random.randomR (60L, 120L) g
+                (eT, g2)  = Random.randomR (80L, 160L) g1
+                thinkTime = 300L * tT
+                eatTime   = 300L * eT
+    
+            println(me ++ " is going to the dining room and takes his seat.") 
+            fl <- left.take            
+            println (me ++ " takes up left fork (" ++ show fl ++ ")")
+            rFork <- right.poll
+            case rFork of
+                Just fr -> do 
+                    println (me ++ " takes up right fork. (" ++ show fr ++ ")") 
+                    println (me ++ " is going to eat for " ++ show eatTime ++ "ms")
+                    Thread.sleep eatTime
+                    println (me ++ " finished eating.")
+                    right.put fr
+                    println (me ++ " took down right fork.")
+                    left.put fl
+                    println (me ++ " took down left fork.")
+                    table.notifyAll 
+                    println(me ++ " is going to think for " ++ show thinkTime ++ "ms.")
+                    Thread.sleep thinkTime
+                    phil g2
+                Nothing -> do
+                    println (me ++ " finds right fork is already in use.")
+                    left.put fl
+                    println (me ++ " took down left fork.")
+                    table.notifyAll
+                    println (me ++ " is going to the bar to await notifications from table.")
+                    table.wait
+                    println (me ++ " got notice that something changed at the table.")
+                    phil g2
+            
+        inter :: InterruptedException -> IO ()
+        inter _ = return ()        
+    
+    phil g `catch` inter
+
+    
+getURL xx = do
+        url <- URL.new xx 
+        con <- url.openConnection
+        con.connect
+        is  <- con.getInputStream
+        typ <- con.getContentType
+        -- stderr.println ("content-type is " ++ show typ) 
+        ir  <- InputStreamReader.new is (fromMaybe "UTF-8" (charset typ))
+            `catch` unsupportedEncoding is 
+        br  <- BufferedReader.new ir
+        br.getLines
+    where
+        unsupportedEncoding :: InputStream -> UnsupportedEncodingException -> IO InputStreamReader
+        unsupportedEncoding is x = do
+            stderr.println x.catched
+            InputStreamReader.new is "UTF-8"
+            
+        charset ctyp = do
+            typ <- ctyp
+            case typ of
+                m~´charset=(\S+)´ -> m.group 1
+                _ -> Nothing
+
+    
+type SomeException = Throwable
+
+main ["dining"] = mainPhil []
+        
+main _ =  do
+    m1 <- MVar.newEmpty
+    m2 <- MVar.newEmpty
+    m3 <- MVar.newEmpty
+    
+    forkIO do
+        r <- (catchAll . getURL) "http://www.wikipedia.org/wiki/Haskell"
+        m1.put r
+    
+    forkIO do
+        r <- (catchAll . getURL) "htto://www.wikipedia.org/wiki/Java"
+        m2.put r
+    
+    forkIO do
+        r <- (catchAll . getURL) "http://www.wikipedia.org/wiki/Frege"
+        m3.put r
+    
+    r1 <- m1.take
+    r2 <- m2.take
+    r3 <- m3.take
+    println (result r1, result r2, result r3)
+    -- case r3 of
+    --     Right ss -> mapM_ putStrLn ss
+    --     Left _   -> return ()
+  where
+    result :: (SomeException|[String]) -> (String|Int)
+    result (Left x)  = Left x.getClass.getName
+    result (Right y) = (Right . sum . map length)  y
+    -- mapM_ putStrLn r2
+
+        

samples/Frege/Sudoku.fr

@@ -0,0 +1,561 @@
+package examples.Sudoku where
+
+import Data.TreeMap (Tree, keys)
+import Data.List as DL hiding (find, union)
+
+
+type Element    = Int           -- 1,2,3,4,5,6,7,8,9
+type Zelle      = [Element]     -- set of candidates
+type Position   = Int           -- 0..80
+type Feld       = (Position, Zelle)
+type Brett      = [Feld]
+
+--- data type for assumptions and conclusions
+data Assumption =
+              !ISNOT Position Element
+            | !IS    Position Element
+
+
+derive Eq Assumption
+derive Ord Assumption
+instance Show Assumption where
+    show (IS p e)    = pname p ++ "=" ++ e.show
+    show (ISNOT p e) = pname p ++ "/" ++ e.show
+
+showcs cs = joined " " (map Assumption.show cs)
+
+elements :: [Element]           -- all possible elements
+elements = [1 .. 9]
+
+{-
+    a  b  c   d  e  f   g  h  i
+     0  1  2 | 3  4  5 | 6  7  8    1
+     9 10 11 |12 13 14 |15 16 17    2
+    18 19 20 |21 22 23 |24 25 26    3
+    ---------|---------|--------
+    27 28 29 |30 31 32 |33 34 35    4
+    36 37 38 |39 40 41 |42 43 44    5
+    45 46 47 |48 49 50 |51 52 53    6
+    ---------|---------|--------
+    54 55 56 |57 58 59 |60 61 62    7
+    63 64 65 |66 67 68 |69 70 71    8
+    72 73 74 |75 76 77 |78 79 80    9
+-}
+
+positions :: [Position]         -- all possible positions
+positions = [0..80]
+rowstarts :: [Position]         -- all positions where a row is starting
+rowstarts =  [0,9,18,27,36,45,54,63,72]
+colstarts :: [Position]         -- all positions where a column is starting
+colstarts =  [0,1,2,3,4,5,6,7,8]
+boxstarts :: [Position]         -- all positions where a box is starting
+boxstarts =  [0,3,6,27,30,33,54,57,60]
+boxmuster :: [Position]         -- pattern for a box, by adding upper left position results in real box
+boxmuster =  [0,1,2,9,10,11,18,19,20]
+
+
+--- extract field for position
+getf :: Brett -> Position  -> Feld
+getf (f:fs) p
+    | fst f == p = f
+    | otherwise  = getf fs p
+getf [] p = (p,[])
+
+
+--- extract cell for position
+getc :: Brett -> Position -> Zelle
+getc b p = snd (getf b p)
+
+--- compute the list of all positions that belong to the same row as a given position
+row :: Position -> [Position]
+row p = [z..(z+8)] where z = (p `quot` 9) * 9
+
+--- compute the list of all positions that belong to the same col as a given position
+col :: Position -> [Position]
+col p = map (c+) rowstarts where c = p `mod` 9
+
+--- compute the list of all positions that belong to the same box as a given position
+box :: Position -> [Position]
+box p  = map (z+) boxmuster where
+    ri = p `div` 27 * 27    -- 0, 27 or 54, depending on row
+    ci = p `mod` 9          -- column index 0..8, 0,1,2 is left, 3,4,5 is middle, 6,7,8 is right
+    cs = ci `div` 3 * 3     -- 0, 3 or 6
+    z  = ri + cs
+
+--- check if candidate set has exactly one member, i.e. field has been solved
+single :: Zelle -> Bool
+single [_] = true
+single _   = false
+
+unsolved :: Zelle -> Bool
+unsolved [_] = false
+unsolved _   = true
+
+-- list of rows, cols, boxes
+allrows = map row rowstarts
+allcols = map col colstarts
+allboxs = map box boxstarts
+allrcb  = zip (repeat "row") allrows
+          ++ zip (repeat "col") allcols
+          ++ zip (repeat "box") allboxs
+
+
+containers :: [(Position -> [Position], String)]
+containers = [(row, "row"), (col, "col"), (box, "box")]
+
+-- ----------------- PRINTING ------------------------------------
+-- printable coordinate of field, upper left is a1, lower right is i9
+pname p = packed [chr (ord 'a' + p `mod` 9), chr (ord '1' + p `div` 9)]
+
+-- print board
+printb b = mapM_ p1line allrows >> println ""
+    where
+        p1line row = do
+                print (joined "" (map pfld line))
+            where line = map (getc b) row
+
+-- print field (brief)
+--   ? = no candidate
+--   5 = field is 5
+--   . = some candidates
+pfld [] = "?"
+pfld [x] = show x
+pfld zs = "0"
+
+-- print initial/final board
+result msg b = do
+        println ("Result: " ++ msg)
+        print   ("Board: ")
+        printb b
+        return b
+
+res012 b = case concatMap (getc b) [0,1,2] of
+    [a,b,c] -> a*100+b*10+c
+    _ -> 9999999
+
+-- -------------------------- BOARD ALTERATION ACTIONS ---------------------------------
+-- print a message about what is done to the board and return the new board
+turnoff1 :: Position -> Zelle -> Brett -> IO Brett
+turnoff1 i off b
+    | single nc = do
+            -- print (pname i)
+            -- print ": set to "
+            -- print (head nc)
+            -- println " (naked single)"
+            return newb
+    | otherwise = return newb
+    where
+        cell   = getc b i
+        nc     = filter (`notElem` off) cell
+        newb   = (i, nc) : [ f | f <- b, fst f != i ]
+
+turnoff :: Int -> Zelle -> String -> Brett -> IO Brett
+turnoff i off msg b = do
+        -- print (pname i)
+        -- print ": set to "
+        -- print nc
+        -- print " by clearing "
+        -- print off
+        -- print " "
+        -- println  msg
+        return newb
+    where
+        cell   = getc b i
+        nc     = filter (`notElem` off) cell
+        newb   = (i, nc) : [ f | f <- b, fst f != i ]
+
+turnoffh ps off msg b = foldM toh b ps
+    where
+        toh b p = turnoff p off msg b
+
+setto :: Position -> Element -> String -> Brett -> IO Brett
+setto i n cname b = do
+        -- print (pname i)
+        -- print ": set to "
+        -- print n
+        -- print " (hidden single in "
+        -- print cname
+        -- println ")"
+        return newb
+    where
+        nf     = [n]
+        newb   = (i, nf) : [ f | f <- b, fst f != i ]
+
+
+-- ----------------------------- SOLVING STRATEGIES ---------------------------------------------
+-- reduce candidate sets that contains numbers already in same row, col or box
+-- This finds (and logs) NAKED SINGLEs in passing.
+reduce b = [  turnoff1 p sss | (p,cell) <- b,               -- for each field
+                unsolved cell,                              --  with more than 1 candidate
+                --       single fields in containers that are candidates of that field
+                sss = [ s | (rcb, _) <- containers, [s] <- map (getc b) (rcb p), s `elem` cell],
+                sss != [] ]                                     -- collect field index, elements to remove from candidate set
+
+-- look for a number that appears in exactly 1 candidate set of a container
+-- this number can go in no other place (HIDDEN SINGLE)
+hiddenSingle b = [ setto i n cname |                     -- select index, number, containername
+            (cname, rcb) <- allrcb,                 -- FOR rcb IN allrcb
+            n <- elements,                          --  FOR n IN elements
+            fs     = filter (unsolved • snd) (map (getf b) rcb),
+            occurs  = filter ((n `elem`) • snd) fs,
+            length occurs == 1,
+            (i, _) <- occurs ]
+
+-- look for NAKED PAIRS, TRIPLES, QUADS
+nakedPair n b = [ turnoff p t ("(naked tuple in " ++ nm ++ ")") |           -- SELECT pos, tuple, name
+            -- n <- [2,3,4],                    //  FOR n IN [2,3,4]
+            (nm, rcb) <- allrcb,             --    FOR rcb IN containers
+            fs = map (getf b) rcb,              --      let fs = fields for rcb positions
+            u  = (fold union [] . filter unsolved . map snd) fs,   -- let u = union of non single candidates
+            t <- n `outof` u,                   --      FOR t IN n-tuples
+            hit = (filter ((`subset` t) . snd) . filter (unsolved . snd)) fs,
+            length hit == n,
+            (p, cell) <- fs,
+            p `notElem` map fst hit,
+            any (`elem` cell) t
+            ]
+
+-- look for HIDDEN PAIRS, TRIPLES or QUADS
+hiddenPair n b = [ turnoff p off ("(hidden " ++ show t ++ " in " ++ nm ++ ")") |           -- SELECT pos, tuple, name
+            -- n <- [2,3,4],                    //  FOR n IN [2,3,4]
+            (nm, rcb) <- allrcb,             --    FOR rcb IN containers
+            fs = map (getf b) rcb,              --      let fs = fields for rcb positions
+            u  = (fold union [] . filter ((>1) . length) . map snd) fs,   -- let u = union of non single candidates
+            t <- n `outof` u,                   --      FOR t IN n-tuples
+            hit = (filter (any ( `elem` t) . snd) . filter (unsolved . snd)) fs,
+            length hit == n,
+            off = (fold union [] . map snd) hit `minus` t,
+            off != [],
+            (p, cell) <- hit,
+            ! (cell `subset` t)
+            ]
+
+a `subset` b = all (`elem` b) a
+a `union`  b = uniq (sort (a ++ b))
+a `minus`  b = filter (`notElem` b) a
+a `common` b = filter (`elem` b) a
+n `outof` as
+    | length as < n = []
+    | [] <- as      = []
+    | 1 >= n        = map (:[]) as
+    | (a:bs) <- as  = map (a:) ((n-1) `outof` bs) ++ (n `outof` bs)
+    | otherwise     = undefined  -- cannot happen because either as is empty or not
+
+same f a b = b `elem` f a
+
+intersectionlist = [(allboxs, row, "box/row intersection"), (allboxs, col, "box/col intersection"),
+                    (allrows ++ allcols, box, "line/box intersection")]
+intersections b = [
+    turnoff pos [c] reason |    -- SELECT position, candidate, reson
+        (from, container, reason) <- intersectionlist,
+        rcb <- from,
+        fs = (filter (unsolved . snd) . map (getf b)) rcb,        -- fs = fields in from with more than 1 candidate
+        c <- (fold union [] • map snd) fs,                          -- FOR c IN union of candidates
+        cpos = (map fst • filter ((c `elem`) • snd)) fs,            -- cpos = positions where c occurs
+        cpos != [],                                                 -- WHERE cpos is not empty
+        all (same container (head cpos)) (tail cpos),               -- WHERE all positions are in the intersection
+        -- we can remove all occurences of c that are in container, but not in from
+        (pos, cell) <- map (getf b) (container (head cpos)),
+        c `elem` cell,
+        pos `notElem` rcb ]
+
+
+-- look for an XY Wing
+--  - there exists a cell A with candidates X and Y
+--  - there exists a cell B with candidates X and Z that shares a container with A
+--  - there exists a cell C with candidates Y and Z that shares a container with A
+-- reasoning
+--  - if A is X, B will be Z
+--  - if A is Y, C will be Z
+--  - since A will indeed be X or Y -> B or C will be Z
+--  - thus, no cell that can see B and C can be Z
+xyWing board = [ turnoff p [z] ("xy wing " ++ pname b ++ " " ++ pname c ++ " because of " ++ pname a) |
+        (a, [x,y]) <- board,                            -- there exists a cell a with candidates x and y
+        rcba = map (getf board) (row a ++ col a ++ box a),  -- rcba = all fields that share a container with a
+        (b, [b1, b2]) <- rcba,
+        b != a,
+        b1 == x && b2 != y || b2 == x && b1 != y,       -- there exists a cell B with candidates x and z
+        z = if b1 == x then b2 else b1,
+        (c, [c1, c2]) <- rcba,
+        c != a, c!= b,
+        c1 == y && c2 == z || c1 == z && c2 == y,       -- there exists a cell C with candidates y and z
+        ps = (uniq . sort) ((row b ++ col b ++ box b) `common` (row c ++ col c ++ box c)),
+        -- remove z in ps
+        (p, cs) <- map (getf board) ps,
+        p != b, p != c,
+        z `elem` cs ]
+
+-- look for a N-Fish (2: X-Wing, 3: Swordfish, 4: Jellyfish)
+-- When all candidates for a particular digit in N rows are located
+-- in only N columns, we can eliminate all candidates from those N columns
+--  which are not located on those N rows
+fish n board = fish "row" allrows row col ++ fish "col" allcols col row where
+    fishname 2 = "X-Wing"
+    fishname 3 = "Swordfish"
+    fishname 4 = "Jellyfish"
+    fishname _ = "unknown fish"
+    fish nm allrows row col = [ turnoff p [x] (fishname n ++ " in " ++ nm ++ " " ++ show (map (pname . head) rset)) |
+        rset <- n `outof` allrows,          -- take n rows (or cols)
+        x <- elements,                      -- look for certain number
+        rflds = map (filter ((>1) . length . snd) . map (getf board)) rset,       -- unsolved fields in the rowset
+        colss  = (map (map (head . col . fst) . filter ((x `elem`) . snd)) rflds),   -- where x occurs in candidates
+        all ((>1) . length) colss,         -- x must appear in at least 2 cols
+        cols = fold union [] colss,
+        length cols == n,
+        cstart <- cols,
+        (p, cell) <- map (getf board) (col cstart),
+        x `elem` cell,
+        all (p `notElem`) rset]
+
+
+-- compute immediate consequences of an assumption of the form (p `IS` e) or (p `ISNOT` e)
+conseq board (IS p e) = uniq (sort ([ p `ISNOT` x | x <- getc board p, x != e ] ++
+    [ a `ISNOT` e |
+        (a,cs) <- map (getf board) (row p ++ col p ++ box p),
+        a != p,
+        e `elem` cs
+    ]))
+conseq board (ISNOT p  e) = uniq (sort ([ p `IS` x | cs = getc board p, length cs == 2, x <- cs, x != e ] ++
+    [ a `IS` e |
+        cp <- [row p, box p, col p],
+        as = (filter ((e `elem`) . getc board) . filter (p!=)) cp,
+        length as == 1,
+        a = head as
+    ]))
+
+-- check if two assumptions contradict each other
+contradicts (IS a x)    (IS b y)    = a==b && x!=y
+contradicts (IS a x)    (ISNOT b y) = a==b && x==y
+contradicts (ISNOT a x) (IS b y)    = a==b && x==y
+contradicts (ISNOT _ _) (ISNOT _ _) = false
+
+-- get the Position of an Assumption
+aPos (IS p _)    = p
+aPos (ISNOT p _) = p
+
+-- get List of elements that must be turned off when assumption is true/false
+toClear board true  (IS p x)    = filter (x!=) (getc board p)
+toClear board false (IS p x)    = [x]
+toClear board true  (ISNOT p x) = [x]
+toClear board false (ISNOT p x) = filter (x!=) (getc board p)
+
+
+-- look for assumptions whose implications contradict themself
+chain board paths = [ solution a (head cs) (reverse cs) |
+        (a, css) <-  paths,
+        cs <- take 1 [ cs | cs <- css, contradicts a (head cs) ]
+        ]
+    where
+        solution a c cs = turnoff (aPos a) (toClear board false a) reason where
+            reason = "Assumption " ++ show a ++ " implies " ++ show c ++ "\n\t"
+                ++ showcs cs ++ "\n\t"
+                ++ "Therefore, " ++ show a ++ " must be false."
+
+-- look for an assumption that yields to contradictory implications
+-- this assumption must be false
+chainContra board paths = [ solution a (reverse pro) (reverse contra) |
+        (a, css) <- paths,          -- FOR ALL assumptions "a" with list of conlusions "css"
+        (pro, contra) <- take 1 [ (pro, contra) |
+            pro <- (uniqBy (using head) . sortBy (comparing head)) css,                 -- FOR ALL conslusion chains "pro"
+            c = head pro,               -- LET "c" BE the final conclusion
+            contra <- take 1 (filter ((contradicts c) . head) css)   -- THE FIRST conclusion that contradicts c
+        ]
+      ]
+    where
+        solution a pro con = turnoff (aPos a) (toClear board false a) reason where
+            reason = ("assumption " ++ show a ++ " leads to contradictory conclusions\n\t"
+                        ++ showcs pro ++ "\n\t" ++ showcs con)
+
+
+
+-- look for a common implication c of some assumptions ai, where at least 1 ai is true
+-- so that (a0 OR a1 OR a2 OR ...) IMPLIES c
+-- For all cells pi in same container that have x as candidate, we can construct (p0==x OR p1==x OR ... OR pi==x)
+-- For a cell p with candidates ci, we can construct (p==c0 OR p==c1)
+cellRegionChain board paths = [ solution b as (map head os) |
+        as <- cellas ++ regionas,           -- one of as must be true
+        iss = filter ((`elem` as) . fst) paths,    -- the implications for as
+        (a, ass) <- take 1 iss,             -- implications for first assumption
+        fs <- (uniqBy (using head) . sortBy (comparing head)) ass,
+        b = head fs,                        -- final conclusions of first assumption
+        os = [fs] : map (take 1 . filter ((b==) . head) . snd) (tail iss), -- look for implications with same conclusion
+        all ([]!=) os]
+    where
+        cellas   = [ map (p `IS`) candidates | (p, candidates@(_:_:_)) <- board ]
+        regionas = [ map (`IS` e) ps |
+            region <- map (map (getf board)) (allrows ++ allcols ++ allboxs),
+            e <- elements,
+            ps = map fst (filter ((e `elem`) . snd) region),
+            length ps > 1 ]
+        solution b as oss = turnoff (aPos b) (toClear board true b) reason where
+            reason = "all of the assumptions " ++ joined ", " (map show as) ++ " imply " ++ show b ++ "\n\t"
+                ++ joined "\n\t" (map (showcs . reverse) oss) ++ "\n\t"
+                ++ "One of them must be true, so " ++ show b ++ " must be true."
+
+
+{-
+    Wir brauchen für einige Funktionen eine Datenstruktur wie
+        [ (Assumption, [[Assumption]]) ]
+    d.i. eine Liste von möglichen Annahmen samt aller Schlußketten.
+    Idealerweise sollte die Schlußkette in umgekehrter Reihenfolge vorliegen,
+    dann kann man einfach finden:
+    - Annahmen, die zum Selbstwiderspruch führen.
+    - alles, was aus einer bestimmten Annahme folgt (map (map head) [[a]])
+    -...
+-}
+--- Liste aller Annahmen für ein bestimmtes Brett
+assumptions :: Brett -> [Assumption]
+assumptions board = [ a |
+                (p, cs) <- board,
+                !(single cs),
+                a <- map (ISNOT p) cs ++ map (IS p) cs ]
+
+consequences :: Brett -> [Assumption] -> [[Assumption]]
+consequences board as = map (conseq board) as
+
+acstree :: Brett -> Tree Assumption [Assumption]
+acstree board = Tree.fromList (zip as cs)
+    where
+        as = assumptions  board
+        cs = consequences board as
+
+-- bypass maybe on tree lookup
+find :: Tree Assumption [Assumption] -> Assumption -> [Assumption]
+find t a
+    | Just cs <- t.lookup a = cs
+    | otherwise = error ("no consequences for " ++ show a)
+
+-- for performance resons, we confine ourselves to implication chains of length 20 per assumption
+mkPaths :: Tree Assumption [Assumption] -> [ (Assumption, [[Assumption]]) ]
+mkPaths acst = map impl  (keys acst)   -- {[a1], [a2], [a3] ]
+    where
+        -- [Assumption] -> [(a, [chains, ordered by length]
+        impl a = (a, impls [[a]])
+        impls ns = (take 1000 • concat • takeUntil null • iterate expandchain) ns
+        -- expandchain :: [[Assumption]] -> [[Assumption]]
+        expandchain css = [ (n:a:as) |
+            (a : as) <- css,               -- list of assumptions
+            n <- find acst a,              -- consequences of a
+            n `notElem` as                 -- avoid loops
+          ]
+        -- uni (a:as) = a : uni (filter ((head a !=) • head) as)
+        -- uni [] = empty
+        -- empty = []
+
+
+-- ------------------ SOLVE A SUDOKU --------------------------
+-- Apply all available strategies until nothing changes anymore
+-- Strategy functions are supposed to return a list of
+-- functions, which, when applied to a board, give a changed board.
+-- When a strategy does not find anything to alter,
+-- it returns [], and the next strategy can be tried.
+solve b
+    | all (single . snd) b       = result "Solved" b
+    | any (([]==) . snd) b       = result "not solvable" b
+    | res@(_:_) <- reduce b       = apply b res >>=solve       -- compute smallest candidate sets
+    -- comment "candidate sets are up to date" = ()
+    | res@(_:_) <- hiddenSingle b  = apply b res >>= solve     -- find HIDDEN SINGLES
+    -- comment "no more hidden singles" = ()
+    | res@(_:_) <- intersections b = apply b res >>= solve     -- find locked candidates
+    -- comment "no more intersections" = ()
+    | res@(_:_) <- nakedPair 2 b     = apply b res >>= solve     -- find NAKED PAIRS, TRIPLES or QUADRUPELS
+    -- comment "no more naked pairs" = ()
+    | res@(_:_) <- hiddenPair  2 b   = apply b res >>= solve      -- find HIDDEN PAIRS, TRIPLES or QUADRUPELS
+    -- comment "no more hidden pairs" = ()
+    -- res@(_:_) <- nakedPair 3 b     = apply b res >>= solve       // find NAKED PAIRS, TRIPLES or QUADRUPELS
+    -- | comment "no more naked triples" = ()
+    -- res@(_:_) <- hiddenPair  3 b    = apply b res >>= solve      // find HIDDEN PAIRS, TRIPLES or QUADRUPELS
+    -- | comment "no more hidden triples" = ()
+    -- res@(_:_) <- nakedPair 4 b     = apply b res >>=solve       // find NAKED PAIRS, TRIPLES or QUADRUPELS
+    -- | comment "no more naked quadruples" = ()
+    -- res@(_:_) <- hiddenPair  4 b    = apply b res >>=solve      // find HIDDEN PAIRS, TRIPLES or QUADRUPELS
+    -- | comment "no more hidden quadruples" = ()
+    | res@(_:_) <- xyWing b            = apply b res >>=solve      -- find XY WINGS
+    -- comment "no more xy wings"       = ()
+    | res@(_:_) <- fish 2 b            = apply b res >>=solve      -- find 2-FISH
+    -- comment "no more x-wings"        = ()
+    -- res@(_:_) <- fish 3 b            = apply b res >>=solve      // find 3-FISH
+    -- | comment "no more swordfish"      = ()
+    -- res@(_:_) <- fish 4 b            = apply b res >>=solve      // find 4-FISH
+    -- | comment "no more jellyfish"      = ()
+    -- | comment pcomment                 = ()
+    | res@(_:_) <- chain b paths             = apply b (take 9 res) >>= solve  -- find forcing chains
+    | res@(_:_) <- cellRegionChain b paths   = apply b (take 9 res) >>= solve  -- find common conclusion for true assumption
+    | res@(_:_) <- chainContra b paths       = apply b (take 9 res) >>= solve  -- find assumptions that allow to infer both a and !a
+    -- comment "consistent conclusions only"       = ()
+
+    | otherwise = result "ambiguous" b
+    where
+        apply brd fs = foldM (\b\f -> f b) brd fs
+        paths = mkPaths (acstree b)
+        -- pcomment = show (length paths) ++ " assumptions with " ++ show (fold (+) 0 (map (length <~ snd) paths))
+        --    ++ " implication chains"
+
+-- comment com = do stderr << com << "\n" for false
+-- log com     = do stderr << com << "\n" for true
+
+--- turn a string into a row
+mkrow :: String -> [Zelle]
+mkrow s = mkrow1 xs
+    where
+        xs = s ++ "---------" -- make sure at least 9 elements
+        mkrow1 xs = (take 9 • filter ([]!=) • map f • unpacked) xs
+        f x | x >= '1' && x <= '9'  =  [ord x - ord '0']
+            | x == ' '  = []    -- ignored
+            | otherwise = elements
+
+main ["-h"]    = main []
+main ["-help"] = main []
+main [] = do
+        mapM_ stderr.println [
+            "usage: java Sudoku file ...",
+            "       java Sudoku position",
+            "where position is a 81 char string consisting of digits",
+            "One can get such a string by going to",
+            "http://www.sudokuoftheday.com/pages/s-o-t-d.php",
+            "Right click on the puzzle and open it in new tab",
+            "Copy the 81 digits from the URL in the address field of your browser.",
+            "",
+            "There is also a file with hard sudokus in examples/top95.txt\n"]
+        return ()
+
+
+main [s@#^[0-9\W]{81}$#] = solve board >> return ()
+    where
+        board = zip positions felder
+        felder = decode s
+
+main files = forM_ files sudoku
+    where
+        sudoku file = do
+            br <- openReader file
+            lines <- BufferedReader.getLines br
+            bs <- process lines
+            ss <- mapM (\b -> print "Puzzle: " >> printb b >> solve b) bs
+            println ("Euler: " ++ show (sum (map res012 ss)))
+            return ()
+
+-- "--3-" => [1..9, 1..9, [3], 1..9]
+decode s = map candi (unpacked s) where
+        candi c | c >= '1' && c <= '9'  = [(ord c - ord '0')]
+                | otherwise = elements
+process [] = return []
+process (s:ss)
+    | length s == 81 = consider b1
+    | length s == 9,
+      length acht == 8,
+      all ((9==) • length) acht = consider b2
+    | otherwise = do
+            stderr.println ("skipped line: " ++ s)
+            process ss
+    where
+        acht = take 8 ss
+        neun = fold (++) "" (s:acht)
+        b1 = zip positions (decode s)
+        b2 = zip positions (decode neun)
+        consider b = do
+            -- print "Puzzle: "
+            -- printb b
+            bs <- process ss
+            return (b:bs)
+

samples/Frege/SwingExamples.fr

@@ -0,0 +1,79 @@
+package examples.SwingExamples where
+
+import Java.Awt  (ActionListener)
+import Java.Swing
+
+
+main _ = do
+    rs <- mapM Runnable.new [helloWorldGUI, buttonDemoGUI, celsiusConverterGUI]
+    mapM_ invokeLater rs
+    println "Hit enter to end ...."
+    s <- getLine
+    return ()
+
+celsiusConverterGUI = do
+    tempTextField   <- JTextField.new()
+    celsiusLabel    <- JLabel.new ()
+    convertButton   <- JButton.new ()
+    fahrenheitLabel <- JLabel.new () 
+    frame           <- JFrame.new ()
+    frame.setDefaultCloseOperation JFrame.dispose_on_close
+    frame.setTitle "Celsius Converter"
+    celsiusLabel.setText  "Celsius"
+    convertButton.setText "Convert"
+    let convertButtonActionPerformed _ = do
+            celsius <- tempTextField.getText
+            case celsius.double of
+                Left _  -> fahrenheitLabel.setText ("not a valid number: " ++ celsius)
+                Right c -> fahrenheitLabel.setText (show (c*1.8 + 32.0).long ++ " Fahrenheit") 
+            return ()
+    ActionListener.new convertButtonActionPerformed >>= convertButton.addActionListener
+    fahrenheitLabel.setText "Fahrenheit"
+    contentPane <- frame.getContentPane
+    layout      <- GroupLayout.new contentPane
+    contentPane.setLayout layout
+    -- TODO continue
+    -- http://docs.oracle.com/javase/tutorial/displayCode.html?code=http://docs.oracle.com/javase/tutorial/uiswing/examples/learn/CelsiusConverterProject/src/learn/CelsiusConverterGUI.java
+    frame.pack
+    frame.setVisible true
+
+helloWorldGUI = do
+    frame <- JFrame.new "Hello World Frege"
+    frame.setDefaultCloseOperation(JFrame.dispose_on_close)
+    label <- JLabel.new "Hello World!"
+    cp <- frame.getContentPane
+    cp.add label
+    frame.pack
+    frame.setVisible true
+
+buttonDemoGUI = do
+    frame <- JFrame.new "Button Demo"
+    frame.setDefaultCloseOperation(JFrame.dispose_on_close)
+    newContentPane <- JPanel.new ()
+    b1::JButton <- JButton.new "Disable middle button"
+    b1.setVerticalTextPosition   SwingConstants.center
+    b1.setHorizontalTextPosition SwingConstants.leading
+    b2::JButton <- JButton.new "Middle button"
+    b2.setVerticalTextPosition   SwingConstants.center
+    b2.setHorizontalTextPosition SwingConstants.leading
+    b3::JButton <- JButton.new "Enable middle button"
+    b3.setVerticalTextPosition   SwingConstants.center
+    b3.setHorizontalTextPosition SwingConstants.leading
+    b3.setEnabled false
+    let action1 _ = do
+            b2.setEnabled false
+            b1.setEnabled false
+            b3.setEnabled true
+        action3 _ = do
+            b2.setEnabled true
+            b1.setEnabled true
+            b3.setEnabled false
+    ActionListener.new action1  >>= b1.addActionListener
+    ActionListener.new action3  >>= b3.addActionListener 
+    newContentPane.add b1
+    newContentPane.add b2
+    newContentPane.add b3
+    newContentPane.setOpaque true
+    frame.setContentPane newContentPane
+    frame.pack
+    frame.setVisible true

samples/GAMS/transport.gms

@@ -0,0 +1,76 @@
+*Basic example of transport model from GAMS model library
+
+$Title  A Transportation Problem (TRNSPORT,SEQ=1)
+$Ontext
+
+This problem finds a least cost shipping schedule that meets
+requirements at markets and supplies at factories.
+
+
+Dantzig, G B, Chapter 3.3. In Linear Programming and Extensions.
+Princeton University Press, Princeton, New Jersey, 1963.
+
+This formulation is described in detail in:
+Rosenthal, R E, Chapter 2: A GAMS Tutorial. In GAMS: A User's Guide.
+The Scientific Press, Redwood City, California, 1988.
+
+The line numbers will not match those in the book because of these
+comments.
+
+$Offtext
+
+
+  Sets
+       i   canning plants   / seattle, san-diego /
+       j   markets          / new-york, chicago, topeka / ;
+  Parameters
+       a(i)  capacity of plant i in cases
+         /    seattle     350
+              san-diego   600  /
+       b(j)  demand at market j in cases
+         /    new-york    325
+              chicago     300
+              topeka      275  / ;
+  Table d(i,j)  distance in thousands of miles
+                    new-york       chicago      topeka
+      seattle          2.5           1.7          1.8
+      san-diego        2.5           1.8          1.4  ;
+  Scalar f  freight in dollars per case per thousand miles  /90/ ;
+  Parameter c(i,j)  transport cost in thousands of dollars per case ;
+            c(i,j) = f * d(i,j) / 1000 ;
+  Variables
+       x(i,j)  shipment quantities in cases
+       z       total transportation costs in thousands of dollars ;
+
+  Positive Variable x ;
+
+  Equations
+       cost        define objective function
+       supply(i)   observe supply limit at plant i
+       demand(j)   satisfy demand at market j ;
+
+  cost ..        z  =e=  sum((i,j), c(i,j)*x(i,j)) ;
+
+  supply(i) ..   sum(j, x(i,j))  =l=  a(i) ;
+
+  demand(j) ..   sum(i, x(i,j))  =g=  b(j) ;
+
+  Model transport /all/ ;
+
+  Solve transport using lp minimizing z ;
+
+  Display x.l, x.m ;
+
+$ontext
+#user model library stuff
+Main topic Basic GAMS
+Featured item 1 Trnsport model
+Featured item 2
+Featured item 3
+Featured item 4
+Description
+Basic example of transport model from GAMS model library
+
+
+
+$offtext

samples/GAP/Magic.gd

@@ -0,0 +1,307 @@
+#############################################################################
+##
+##  Magic.gd                                         AutoDoc package
+##
+##  Copyright 2013, Max Horn, JLU Giessen
+##                  Sebastian Gutsche, University of Kaiserslautern
+##
+#############################################################################
+
+
+#! @Description
+#! This is the main function of the &AutoDoc; package. It can perform
+#! any combination of the following three tasks:
+#! <Enum>
+#! <Item>
+#!     It can (re)generate a scaffold for your package manual.
+#!     That is, it can produce two XML files in &GAPDoc; format to be used as part
+#!     of your manual: First, a file named <F>doc/PACKAGENAME.xml</F>
+#!     (with your package's name substituted) which is used as
+#!     main file for the package manual, i.e. this file sets the
+#!     XML DOCTYPE and defines various XML entities, includes
+#!     other XML files (both those generated by &AutoDoc; as well
+#!     as additional files created by other means), tells &GAPDoc;
+#!     to generate a table of content and an index, and more.
+#!     Secondly, it creates a file <F>doc/title.xml</F> containing a title
+#!     page for your documentation, with information about your package
+#!     (name, description, version), its authors and more, based
+#!     on the data in your <F>PackageInfo.g</F>.
+#! </Item>
+#! <Item>
+#!     It can scan your package for &AutoDoc; based documentation (by using &AutoDoc;
+#!     tags and the Autodoc command.
+#!     This will
+#!     produce further XML files to be used as part of the package manual.
+#! </Item>
+#! <Item>
+#!     It can use &GAPDoc; to generate PDF, text and HTML (with
+#!     MathJaX enabled) documentation from the &GAPDoc; XML files it
+#!     generated as well as additional such files provided by you. For
+#!     this, it invokes <Ref Func='MakeGAPDocDoc' BookName='gapdoc'/>
+#!     to convert the XML sources, and it also instructs &GAPDoc; to copy
+#!     supplementary files (such as CSS style files) into your doc directory
+#!     (see <Ref Func='CopyHTMLStyleFiles' BookName='gapdoc'/>).
+#! </Item>
+#! </Enum>
+#! For more information and some examples, please refer to Chapter <Ref Label='Tutorials'/>.
+#! <P/>
+#! The parameters have the following meanings:
+#! <List>
+#!
+#! <Mark><A>package_name</A></Mark>
+#! <Item>
+#!     The name of the package whose documentation should be(re)generated.
+#! </Item>
+#!
+#!
+#! <Mark><A>option_record</A></Mark>
+#! <Item>
+#!     <A>option_record</A> can be a record with some additional options.
+#!     The following are currently supported:
+#!     <List>
+#!     <Mark><A>dir</A></Mark>
+#!     <Item>
+#!         This should be a string containing a (relative) path or a
+#!         Directory() object specifying where the package documentation
+#!         (i.e. the &GAPDoc; XML files) are stored.
+#!         <Br/>
+#!         <E>Default value: <C>"doc/"</C>.</E>
+#!     </Item>
+#!     <Mark><A>scaffold</A></Mark>
+#!     <Item>
+#!         This controls whether and how to generate scaffold XML files
+#!         for the main and title page of the package's documentation. 
+#!         <P/>
+#!         The value should be either <K>true</K>, <K>false</K> or a
+#!         record. If it is a record or <K>true</K> (the latter is
+#!         equivalent to specifying an empty record), then this feature is
+#!         enabled. It is also enabled if <A>opt.scaffold</A> is missing but the
+#!         package's info record in <F>PackageInfo.g</F> has an <C>AutoDoc</C> entry.
+#!         In all other cases (in particular if <A>opt.scaffold</A> is
+#!         <K>false</K>), scaffolding is disabled.
+#!         <P/>
+#!
+#!         If <A>opt.scaffold</A> is a record, it may contain the following entries.
+#!
+#### TODO: mention merging with PackageInfo.AutoDoc!
+#!         <List>
+#!
+#!         <Mark><A>includes</A></Mark>
+#!         <Item>
+#!             A list of XML files to be included in the body of the main XML file.
+#!             If you specify this list and also are using &AutoDoc; to document
+#!             your operations with &AutoDoc; comments,
+#!             you can add <F>AutoDocMainFile.xml</F> to this list
+#!             to control at which point the documentation produced by &AutoDoc;
+#!             is inserted. If you do not do this, it will be added after the last
+#!             of your own XML files.
+#!         </Item>
+#!
+#!         <Mark><A>appendix</A></Mark>
+#!         <Item>
+#!             This entry is similar to <A>opt.scaffold.includes</A> but is used
+#!             to specify files to include after the main body of the manual,
+#!             i.e. typically appendices.
+#!         </Item>
+#!
+#!         <Mark><A>bib</A></Mark>
+#!         <Item>
+#!             The name of a bibliography file, in Bibtex or XML format.
+#!             If this key is not set, but there is a file <F>doc/PACKAGENAME.bib</F>
+#!             then it is assumed that you want to use this as your bibliography.
+#!         </Item>
+#!
+#### TODO: The 'entities' param is a bit strange. We should probably change it to be a bit more
+#### general, as one might want to define other entities... For now, we do not document it
+#### to leave us the choice of revising how it works.
+####
+####                 <Mark><A>entities</A></Mark>
+####                 <Item>
+####                     A list of package names or other entities which are used to define corresponding XML entities.
+####                     For example, if set to a list containing the string <Q>SomePackage</Q>,
+####                     then the following is added to the XML preamble:
+####                     <Listing><![CDATA[<!ENTITY SomePackage '<Package>SomePackage</Package>'>]]></Listing>
+####                     This allows you to write <Q>&amp;SomePackage;</Q> in your documentation
+####                     to reference that package. If another type of entity is desired, one can simply add,
+####                     instead of a string, add a two entry list <A>a</A> to the list. It will be handled as
+####                     <Listing><![CDATA[<!ENTITY a[ 2 ] '<a[ 1 ]>a[ 2 ]</a[ 1 ]>'>]]></Listing>,
+####                     so please be careful.
+####                 </Item>
+#!
+#!         <Mark><A>TitlePage</A></Mark>
+#!         <Item>
+#!             A record whose entries are used to embellish the generated titlepage
+#!             for the package manual with extra information, such as a copyright
+#!             statement or acknowledgments. To this end, the names of the record
+#!             components are used as XML element names, and the values of the
+#!             components are outputted as content of these XML elements. For
+#!             example, you could pass the following record to set a custom
+#!             acknowledgements text:
+#!             <Listing><![CDATA[
+#!             rec( Acknowledgements := "Many thanks to ..." )]]></Listing>
+#!             For a list of valid entries in the titlepage, please refer to the
+#!             &GAPDoc; manual, specifically section <Ref Subsect='Title' BookName='gapdoc'/>
+#!             and following.
+#!         </Item>
+#!         <Mark><A>document_class</A></Mark>
+#!         <Item>
+#!             Sets the document class of the resulting pdf. The value can either be a string
+#!             which has to be the name of the new document class, a list containing this string, or
+#!             a list of two strings. Then the first one has to be the document class name, the second one
+#!             the option string ( contained in [ ] ) in LaTeX.
+#!         </Item>
+#!         <Mark><A>latex_header_file</A></Mark>
+#!         <Item>
+#!             Replaces the standard header from &GAPDoc; completely with the header in this LaTeX file.
+#!             Please be careful here, and look at GAPDoc's latexheader.tex file for an example.
+#!         </Item>
+#!         <Mark><A>gapdoc_latex_options</A></Mark>
+#!         <Item>
+#!             Must be a record with entries which can be understood by SetGapDocLaTeXOptions. Each entry can be a string, which
+#!             will be given to &GAPDoc; directly, or a list containing of two entries: The first one must be the string "file",
+#!             the second one a filename. This file will be read and then its content is passed to &GAPDoc; as option with the name
+#!             of the entry.
+#!         </Item>
+#!
+#!         </List>
+#!     </Item>
+#!
+#!
+#!     <Mark><A>autodoc</A></Mark>
+#!     <Item>
+#!         This controls whether and how to generate addition XML documentation files
+#!         by scanning for &AutoDoc; documentation comments.
+#!         <P/>
+#!         The value should be either <K>true</K>, <K>false</K> or a
+#!         record. If it is a record or <K>true</K> (the latter is
+#!         equivalent to specifying an empty record), then this feature is
+#!         enabled. It is also enabled if <A>opt.autodoc</A> is missing but the
+#!         package depends (directly) on the &AutoDoc; package.
+#!         In all other cases (in particular if <A>opt.autodoc</A> is
+#!         <K>false</K>), this feature is disabled.
+#!         <P/>
+#!
+#!         If <A>opt.autodoc</A> is a record, it may contain the following entries.
+#!
+#!         <List>
+#!
+#!         <Mark><A>files</A></Mark>
+#!         <Item>
+#!             A list of files (given by paths relative to the package directory)
+#!             to be scanned for &AutoDoc; documentation comments.
+#!             Usually it is more convenient to use <A>autodoc.scan_dirs</A>, see below.
+#!         </Item>
+#!
+#!         <Mark><A>scan_dirs</A></Mark>
+#!         <Item>
+#!             A list of subdirectories of the package directory (given as relative paths)
+#!             which &AutoDoc; then scans for .gi, .gd and .g files; all of these files
+#!             are then scanned for &AutoDoc; documentation comments.
+#!             <Br/>
+#!             <E>Default value: <C>[ "gap", "lib", "examples", "examples/doc" ]</C>.</E>
+#!         </Item>
+#!
+#!         <Mark><A>level</A></Mark>
+#!         <Item>
+#!             This defines the level of the created documentation. The default value is 0.
+#!             When parts of the manual are declared with a higher value
+#!             they will not be printed into the manual.
+#!         </Item>
+#!
+#### TODO: Document section_intros later on.
+#### However, note that thanks to the new AutoDoc comment syntax, the only remaining
+#### use for this seems to be the ability to specify the order of chapters and
+#### sections.
+####                 <Mark><A>section_intros</A></Mark>
+####                 <Item>
+####                     TODO.
+####                 </Item>
+#!
+#!         </List>
+#!     </Item>
+#!
+#!
+#!     <Mark><A>gapdoc</A></Mark>
+#!     <Item>
+#!         This controls whether and how to invoke &GAPDoc; to create HTML, PDF and text
+#!         files from your various XML files.
+#!         <P/>
+#!         The value should be either <K>true</K>, <K>false</K> or a
+#!         record. If it is a record or <K>true</K> (the latter is
+#!         equivalent to specifying an empty record), then this feature is
+#!         enabled. It is also enabled if <A>opt.gapdoc</A> is missing.
+#!         In all other cases (in particular if <A>opt.gapdoc</A> is
+#!         <K>false</K>), this feature is disabled.
+#!         <P/>
+#!
+#!         If <A>opt.gapdoc</A> is a record, it may contain the following entries.
+#!
+#!         <List>
+#!
+#!
+#### Note: 'main' is strictly speaking also used for the scaffold.
+#### However, if one uses the scaffolding mechanism, then it is not
+#### really necessary to specify a custom name for the main XML file.
+#### Thus, the purpose of this parameter is to cater for packages
+#### that have existing documentation using a different XML name,
+#### and which do not wish to use scaffolding.
+####
+#### This explain why we only allow specifying gapdoc.main.
+#### The scaffolding code will still honor it, though, just in case.
+#!         <Mark><A>main</A></Mark>
+#!         <Item>
+#!             The name of the main XML file of the package manual.
+#!             This exists primarily to support packages with existing manual
+#!             which use a filename here which differs from the default.
+#!             In particular, specifying this is unnecessary when using scaffolding.
+#!             <Br/>
+#!             <E>Default value: <C>PACKAGENAME.xml</C></E>.
+#!         </Item>
+#!
+#!         <Mark><A>files</A></Mark>
+#!         <Item>
+#!             A list of files (given by paths relative to the package directory)
+#!             to be scanned for &GAPDoc; documentation comments.
+#!             Usually it is more convenient to use <A>gapdoc.scan_dirs</A>, see below.
+#!         </Item>
+#!
+#!         <Mark><A>scan_dirs</A></Mark>
+#!         <Item>
+#!             A list of subdirectories of the package directory (given as relative paths)
+#!             which &AutoDoc; then scans for .gi, .gd and .g files; all of these files
+#!             are then scanned for &GAPDoc; documentation comments.
+#!             <Br/>
+#!             <E>Default value: <C>[ "gap", "lib", "examples", "examples/doc" ]</C>.</E>
+#!         </Item>
+#!
+#!         </List>
+#!     </Item>
+## This is the maketest part. Still under construction.
+#!        <Mark><A>maketest</A></Mark>
+#!        <Item>
+#!          The maketest item can be true or a record. When it is true,
+#!          a simple maketest.g is created in the main package directory,
+#!          which can be used to test the examples from the manual. As a record,
+#!          the entry can have the following entries itself, to specify some options.
+#!          <List>
+#!          <Mark>filename</Mark>
+#!          <Item>
+#!            Sets the name of the test file.
+#!          </Item>
+#!          <Mark>commands</Mark>
+#!          <Item>
+#!            A list of strings, each one a command, which
+#!            will be executed at the beginning of the test file.
+#!          </Item>
+#!          </List>
+#!        </Item>
+#!
+#!     </List>
+#! </Item>
+#! </List>
+#!
+#! @Returns nothing
+#! @Arguments package_name[, option_record ]
+#! @ChapterInfo AutoDoc, The AutoDoc() function
+DeclareGlobalFunction( "AutoDoc" );
+

samples/GAP/Magic.gi

@@ -0,0 +1,534 @@
+#############################################################################
+##
+##  Magic.gi                                         AutoDoc package
+##
+##  Copyright 2013, Max Horn, JLU Giessen
+##                  Sebastian Gutsche, University of Kaiserslautern
+##
+#############################################################################
+
+# Check if a string has the given suffix or not. Another
+# name for this would "StringEndsWithOtherString".
+# For example, AUTODOC_HasSuffix("file.gi", ".gi") returns
+# true while AUTODOC_HasSuffix("file.txt", ".gi") returns false.
+BindGlobal( "AUTODOC_HasSuffix",
+function(str, suffix)
+    local n, m;
+    n := Length(str);
+    m := Length(suffix);
+    return n >= m and str{[n-m+1..n]} = suffix;
+end );
+
+# Given a string containing a ".", , return its suffix,
+# i.e. the bit after the last ".". For example, given "test.txt",
+# it returns "txt".
+BindGlobal( "AUTODOC_GetSuffix",
+function(str)
+    local i;
+    i := Length(str);
+    while i > 0 and str[i] <> '.' do i := i - 1; od;
+    if i < 0 then return ""; fi;
+    return str{[i+1..Length(str)]};
+end );
+
+# Check whether the given directory exists, and if not, attempt
+# to create it.
+BindGlobal( "AUTODOC_CreateDirIfMissing",
+function(d)
+    local tmp;
+    if not IsDirectoryPath(d) then
+        tmp := CreateDir(d); # Note: CreateDir is currently undocumented
+        if tmp = fail then
+            Error("Cannot create directory ", d, "\n",
+                  "Error message: ", LastSystemError().message, "\n");
+            return false;
+        fi;
+    fi;
+    return true;
+end );
+
+
+# Scan the given (by name) subdirs of a package dir for
+# files with one of the given extensions, and return the corresponding
+# filenames, as relative paths (relative to the package dir).
+#
+# For example, the invocation
+#   AUTODOC_FindMatchingFiles("AutoDoc", [ "gap/" ], [ "gi", "gd" ]);
+# might return a list looking like
+#  [ "gap/AutoDocMainFunction.gd", "gap/AutoDocMainFunction.gi", ... ]
+BindGlobal( "AUTODOC_FindMatchingFiles",
+function (pkg, subdirs, extensions)
+    local d_rel, d, tmp, files, result;
+
+    result := [];
+
+    for d_rel in subdirs do
+        # Get the absolute path to the directory in side the package...
+        d := DirectoriesPackageLibrary( pkg, d_rel );
+        if IsEmpty( d ) then
+            continue;
+        fi;
+        d := d[1];
+        # ... but also keep the relative path (such as "gap")
+        d_rel := Directory( d_rel );
+
+        files := DirectoryContents( d );
+        Sort( files );
+        for tmp in files do
+            if not AUTODOC_GetSuffix( tmp ) in [ "g", "gi", "gd", "autodoc" ] then
+                continue;
+            fi;
+            if not IsReadableFile( Filename( d, tmp ) ) then
+                continue;
+            fi;
+            Add( result, Filename( d_rel, tmp ) );
+        od;
+    od;
+    return result;
+end );
+
+
+# AutoDoc(pkg[, opt])
+#
+## Make this function callable with the package_name AutoDocWorksheet.
+## Which will then create a worksheet!
+InstallGlobalFunction( AutoDoc,
+function( arg )
+    local pkg, package_info, opt, scaffold, gapdoc, maketest,
+          autodoc, pkg_dir, doc_dir, doc_dir_rel, d, tmp,
+          title_page, tree, is_worksheet, position_document_class, i, gapdoc_latex_option_record;
+    
+    pkg := arg[1];
+    
+    if LowercaseString( pkg ) = "autodocworksheet" then
+        is_worksheet := true;
+        package_info := rec( );
+        pkg_dir := DirectoryCurrent( );
+    else
+        is_worksheet := false;
+        package_info := PackageInfo( pkg )[ 1 ];
+        pkg_dir := DirectoriesPackageLibrary( pkg, "" )[1];
+    fi;
+
+    if Length(arg) >= 2 then
+        opt := arg[2];
+    else
+        opt := rec();
+    fi;
+
+    # Check for certain user supplied options, and if present, add them
+    # to the opt record.
+    tmp := function( key )
+        local val;
+        val := ValueOption( key );
+        if val <> fail then
+            opt.(key) := val;
+        fi;
+    end;
+    
+    tmp( "dir" );
+    tmp( "scaffold" );
+    tmp( "autodoc" );
+    tmp( "gapdoc" );
+    tmp( "maketest" );
+    
+    #
+    # Setup the output directory
+    #
+    if not IsBound( opt.dir ) then
+        doc_dir := "doc";
+    elif IsString( opt.dir ) or IsDirectory( opt.dir ) then
+        doc_dir := opt.dir;
+    else
+        Error( "opt.dir must be a string containing a path, or a directory object" );
+    fi;
+    
+    if IsString( doc_dir ) then
+        # Record the relative version of the path
+        doc_dir_rel := Directory( doc_dir );
+
+        # We intentionally do not use
+        #   DirectoriesPackageLibrary( pkg, "doc" )
+        # because it returns an empty list if the subdirectory is missing.
+        # But we want to handle that case by creating the directory.
+        doc_dir := Filename(pkg_dir, doc_dir);
+        doc_dir := Directory(doc_dir);
+
+    else
+        # TODO: doc_dir_rel = ... ?
+    fi;
+
+    # Ensure the output directory exists, create it if necessary
+    AUTODOC_CreateDirIfMissing(Filename(doc_dir, ""));
+    
+    # Let the developer know where we are generating the documentation.
+    # This helps diagnose problems where multiple instances of a package
+    # are visible to GAP and the wrong one is used for generating the
+    # documentation.
+    # TODO: Using Info() instead of Print?
+    Print( "Generating documentation in ", doc_dir, "\n" );
+
+    #
+    # Extract scaffolding settings, which can be controlled via
+    # opt.scaffold or package_info.AutoDoc. The former has precedence.
+    #
+    if not IsBound(opt.scaffold) then
+        # Default: enable scaffolding if and only if package_info.AutoDoc is present
+        if IsBound( package_info.AutoDoc ) then
+            scaffold := rec( );
+        fi;
+    elif IsRecord(opt.scaffold) then
+        scaffold := opt.scaffold;
+    elif IsBool(opt.scaffold) then
+        if opt.scaffold = true then
+            scaffold := rec();
+        fi;
+    else
+        Error("opt.scaffold must be a bool or a record");
+    fi;
+
+    # Merge package_info.AutoDoc into scaffold
+    if IsBound(scaffold) and IsBound( package_info.AutoDoc ) then
+        AUTODOC_APPEND_RECORD_WRITEONCE( scaffold, package_info.AutoDoc );
+    fi;
+    
+    if IsBound( scaffold ) then
+        AUTODOC_WriteOnce( scaffold, "TitlePage", true );
+        AUTODOC_WriteOnce( scaffold, "MainPage", true );
+    fi;
+
+    
+    #
+    # Extract AutoDoc settings
+    #
+    if not IsBound(opt.autodoc) and not is_worksheet then
+        # Enable AutoDoc support if the package depends on AutoDoc.
+        tmp := Concatenation( package_info.Dependencies.NeededOtherPackages,
+                              package_info.Dependencies.SuggestedOtherPackages );
+        if ForAny( tmp, x -> LowercaseString(x[1]) = "autodoc" ) then
+            autodoc := rec();
+        fi;
+    elif IsRecord(opt.autodoc) then
+        autodoc := opt.autodoc;
+    elif IsBool(opt.autodoc) and opt.autodoc = true then
+        autodoc := rec();
+    fi;
+    
+    if IsBound(autodoc) then
+        if not IsBound( autodoc.files ) then
+            autodoc.files := [ ];
+        fi;
+        
+        if not IsBound( autodoc.scan_dirs ) and not is_worksheet then
+            autodoc.scan_dirs := [ "gap", "lib", "examples", "examples/doc" ];
+        elif not IsBound( autodoc.scan_dirs ) and is_worksheet then
+            autodoc.scan_dirs := [ ];
+        fi;
+        
+        if not IsBound( autodoc.level ) then
+            autodoc.level := 0;
+        fi;
+        
+        PushOptions( rec( level_value := autodoc.level ) );
+        
+        if not is_worksheet then
+            Append( autodoc.files, AUTODOC_FindMatchingFiles(pkg, autodoc.scan_dirs, [ "g", "gi", "gd" ]) );
+        fi;
+    fi;
+
+    #
+    # Extract GAPDoc settings
+    #
+    if not IsBound( opt.gapdoc ) then
+        # Enable GAPDoc support by default
+        gapdoc := rec();
+    elif IsRecord( opt.gapdoc ) then
+        gapdoc := opt.gapdoc;
+    elif IsBool( opt.gapdoc ) and opt.gapdoc = true then
+        gapdoc := rec();
+    fi;
+    
+    #
+    # Extract test settings
+    #
+    
+    if IsBound( opt.maketest ) then
+        if IsRecord( opt.maketest ) then
+            maketest := opt.maketest;
+        elif opt.maketest = true then
+            maketest := rec( );
+        fi;
+    fi;
+    
+    if IsBound( gapdoc ) then
+
+        if not IsBound( gapdoc.main ) then
+            gapdoc.main := pkg;
+        fi;
+
+        # FIXME: the following may break if a package uses more than one book
+        if IsBound( package_info.PackageDoc ) and IsBound( package_info.PackageDoc[1].BookName ) then
+            gapdoc.bookname := package_info.PackageDoc[1].BookName;
+        elif not is_worksheet then
+            # Default: book name = package name
+            gapdoc.bookname := pkg;
+
+            Print("\n");
+            Print("WARNING: PackageInfo.g is missing a PackageDoc entry!\n");
+            Print("Without this, your package manual will not be recognized by the GAP help system.\n");
+            Print("You can correct this by adding the following to your PackageInfo.g:\n");
+            Print("PackageDoc := rec(\n");
+            Print("  BookName  := ~.PackageName,\n");
+            #Print("  BookName  := \"", pkg, "\",\n");
+            Print("  ArchiveURLSubset := [\"doc\"],\n");
+            Print("  HTMLStart := \"doc/chap0.html\",\n");
+            Print("  PDFFile   := \"doc/manual.pdf\",\n");
+            Print("  SixFile   := \"doc/manual.six\",\n");
+            Print("  LongTitle := ~.Subtitle,\n");
+            Print("),\n");
+            Print("\n");
+        fi;
+
+        if not IsBound( gapdoc.files ) then
+            gapdoc.files := [];
+        fi;
+
+        if not IsBound( gapdoc.scan_dirs ) and not is_worksheet then
+            gapdoc.scan_dirs := [ "gap", "lib", "examples", "examples/doc" ];
+        fi;
+        
+        if not is_worksheet then
+            Append( gapdoc.files, AUTODOC_FindMatchingFiles(pkg, gapdoc.scan_dirs, [ "g", "gi", "gd" ]) );
+        fi;
+
+        # Attempt to weed out duplicates as they may confuse GAPDoc (this
+        # won't work if there are any non-normalized paths in the list).
+        gapdoc.files := Set( gapdoc.files );
+        
+        # Convert the file paths in gapdoc.files, which are relative to
+        # the package directory, to paths which are relative to the doc directory.
+        # For this, we assume that doc_dir_rel is normalized (e.g.
+        # it does not contains '//') and relative.
+        d := Number( Filename( doc_dir_rel, "" ), x -> x = '/' );
+        d := Concatenation( ListWithIdenticalEntries(d, "../") );
+        gapdoc.files := List( gapdoc.files, f -> Concatenation( d, f ) );
+    fi;
+    
+    
+    # read tree
+    # FIXME: shouldn't tree be declared inside of an 'if IsBound(autodoc)' section?
+    tree := DocumentationTree( );
+    
+    if IsBound( autodoc ) then
+        if IsBound( autodoc.section_intros ) then
+            AUTODOC_PROCESS_INTRO_STRINGS( autodoc.section_intros : Tree := tree );
+        fi;
+    
+        AutoDocScanFiles( autodoc.files : PackageName := pkg, Tree := tree );
+    fi;
+    
+    if is_worksheet then
+        # FIXME: We use scaffold and autodoc here without checking whether
+        # they are bound. Does that mean worksheets always use them?
+        if IsRecord( scaffold.TitlePage ) and IsBound( scaffold.TitlePage.Title ) then
+            pkg := scaffold.TitlePage.Title;
+
+        elif IsBound( tree!.TitlePage.Title ) then
+            pkg := tree!.TitlePage.Title;
+
+        elif IsBound( autodoc.files ) and Length( autodoc.files ) > 0  then
+            pkg := autodoc.files[ 1 ];
+            
+            while Position( pkg, '/' ) <> fail do
+                Remove( pkg, 1 );
+            od;
+            
+            while Position( pkg, '.' ) <> fail do
+                Remove( pkg, Length( pkg ) );
+            od;
+
+        else
+            Error( "could not figure out a title." );
+        fi;
+        
+        if not IsString( pkg ) then
+            pkg := JoinStringsWithSeparator( pkg, " " );
+        fi;
+        
+        gapdoc.main := ReplacedString( pkg, " ", "_" );
+        gapdoc.bookname := ReplacedString( pkg, " ", "_" );
+    fi;
+    
+    #
+    # Generate scaffold
+    #
+    gapdoc_latex_option_record := rec( );
+    
+    if IsBound( scaffold ) then
+        ## Syntax is [ "class", [ "options" ] ]
+        if IsBound( scaffold.document_class ) then
+            position_document_class := PositionSublist( GAPDoc2LaTeXProcs.Head, "documentclass" );
+            
+            if IsString( scaffold.document_class ) then
+                scaffold.document_class := [ scaffold.document_class ];
+            fi;
+            
+            if position_document_class = fail then
+                Error( "something is wrong with the LaTeX header" );
+            fi;
+            
+            GAPDoc2LaTeXProcs.Head := Concatenation(
+                  GAPDoc2LaTeXProcs.Head{[ 1 .. PositionSublist( GAPDoc2LaTeXProcs.Head, "{", position_document_class ) ]},
+                  scaffold.document_class[ 1 ],
+                  GAPDoc2LaTeXProcs.Head{[ PositionSublist( GAPDoc2LaTeXProcs.Head, "}", position_document_class ) .. Length( GAPDoc2LaTeXProcs.Head ) ]} );
+            
+            if Length( scaffold.document_class ) = 2 then
+                
+                GAPDoc2LaTeXProcs.Head := Concatenation(
+                      GAPDoc2LaTeXProcs.Head{[ 1 .. PositionSublist( GAPDoc2LaTeXProcs.Head, "[", position_document_class ) ]},
+                      scaffold.document_class[ 2 ],
+                      GAPDoc2LaTeXProcs.Head{[ PositionSublist( GAPDoc2LaTeXProcs.Head, "]", position_document_class ) .. Length( GAPDoc2LaTeXProcs.Head ) ]} );
+            fi;
+        fi;
+        
+        if IsBound( scaffold.latex_header_file ) then
+            GAPDoc2LaTeXProcs.Head := StringFile( scaffold.latex_header_file );
+        fi;
+        
+        if IsBound( scaffold.gapdoc_latex_options ) then
+            if IsRecord( scaffold.gapdoc_latex_options ) then
+                for i in RecNames( scaffold.gapdoc_latex_options ) do
+                    if not IsString( scaffold.gapdoc_latex_options.( i ) )
+                       and IsList( scaffold.gapdoc_latex_options.( i ) )
+                       and LowercaseString( scaffold.gapdoc_latex_options.( i )[ 1 ] ) = "file" then
+                        scaffold.gapdoc_latex_options.( i ) := StringFile( scaffold.gapdoc_latex_options.( i )[ 2 ] );
+                    fi;
+                od;
+                
+                gapdoc_latex_option_record := scaffold.gapdoc_latex_options;
+            fi;
+        fi;
+        
+        if not IsBound( scaffold.includes ) then
+            scaffold.includes := [ ];
+        fi;
+
+        if IsBound( autodoc ) then
+            # If scaffold.includes is already set, then we add
+            # AutoDocMainFile.xml to it, but *only* if it not already
+            # there. This way, package authors can control where
+            # it is put in their includes list.
+            if not "AutoDocMainFile.xml" in scaffold.includes then
+                Add( scaffold.includes, "AutoDocMainFile.xml" );
+            fi;
+        fi;
+
+        if IsBound( scaffold.bib ) and IsBool( scaffold.bib ) then
+            if scaffold.bib = true then
+                scaffold.bib := Concatenation( pkg, ".bib" );
+            else
+                Unbind( scaffold.bib );
+            fi;
+        elif not IsBound( scaffold.bib ) then
+            # If there is a doc/PKG.bib file, assume that we want to reference it in the scaffold.
+            if IsReadableFile( Filename( doc_dir, Concatenation( pkg, ".bib" ) ) ) then
+                scaffold.bib := Concatenation( pkg, ".bib" );
+            fi;
+        fi;
+        
+        AUTODOC_WriteOnce( scaffold, "index", true );
+
+        if IsBound( gapdoc ) then
+            if AUTODOC_GetSuffix( gapdoc.main ) = "xml" then
+                scaffold.main_xml_file := gapdoc.main;
+            else
+                scaffold.main_xml_file := Concatenation( gapdoc.main, ".xml" );
+            fi;
+        fi;
+
+        # TODO: It should be possible to only rebuild the title page. (Perhaps also only the main page? but this is less important)
+        if IsBound( scaffold.TitlePage ) then
+            if IsRecord( scaffold.TitlePage ) then
+                title_page := scaffold.TitlePage;
+            else
+                title_page := rec( );
+            fi;
+            
+            AUTODOC_WriteOnce( title_page, "dir", doc_dir );
+            AUTODOC_APPEND_RECORD_WRITEONCE( title_page, tree!.TitlePage );
+            
+            if not is_worksheet then
+                AUTODOC_APPEND_RECORD_WRITEONCE( title_page, ExtractTitleInfoFromPackageInfo( pkg ) );
+            fi;
+            
+            CreateTitlePage( title_page );
+        fi;
+        
+        if IsBound( scaffold.MainPage ) and scaffold.MainPage <> false then
+            scaffold.dir := doc_dir;
+            scaffold.book_name := pkg;
+            CreateMainPage( scaffold );
+        fi;
+    fi;
+    
+    #
+    # Run AutoDoc
+    #
+    if IsBound( autodoc ) then
+        WriteDocumentation( tree, doc_dir );
+    fi;
+    
+    
+    #
+    # Run GAPDoc
+    #
+    if IsBound( gapdoc ) then
+
+        # Ask GAPDoc to use UTF-8 as input encoding for LaTeX, as the XML files
+        # of the documentation are also in UTF-8 encoding, and may contain characters
+        # not contained in the default Latin 1 encoding.
+        SetGapDocLaTeXOptions( "utf8", gapdoc_latex_option_record );
+
+        MakeGAPDocDoc( doc_dir, gapdoc.main, gapdoc.files, gapdoc.bookname, "MathJax" );
+
+        CopyHTMLStyleFiles( Filename( doc_dir, "" ) );
+
+        # The following (undocumented) API is there for compatibility
+        # with old-style gapmacro.tex based package manuals. It
+        # produces a manual.lab file which those packages can use if
+        # they wish to link to things in the manual we are currently
+        # generating. This can probably be removed eventually, but for
+        # now, doing it does not hurt.
+        
+        # FIXME: It seems that this command does not work if pdflatex
+        #        is not present. Maybe we should remove it.
+        
+        if not is_worksheet then
+            GAPDocManualLab( pkg );
+        fi;
+
+    fi;
+    
+    if IsBound( maketest ) then
+        
+        AUTODOC_WriteOnce( maketest, "filename", "maketest.g" );
+        AUTODOC_WriteOnce( maketest, "folder", pkg_dir );
+        AUTODOC_WriteOnce( maketest, "scan_dir", doc_dir );
+        AUTODOC_WriteOnce( maketest, "files_to_scan", gapdoc.files );
+
+        if IsString( maketest.folder ) then
+            maketest.folder := Directory( maketest.folder );
+        fi;
+        
+        if IsString( maketest.scan_dir ) then
+            maketest.scan_dir := Directory( maketest.scan_dir );
+        fi;
+        
+        AUTODOC_WriteOnce( maketest, "commands", [ ] );
+        AUTODOC_WriteOnce( maketest, "book_name", gapdoc.main );
+        
+        CreateMakeTest( maketest );
+    fi;
+
+    return true;
+end );

samples/GAP/PackageInfo.g

@@ -0,0 +1,115 @@
+#############################################################################
+##  
+##  PackageInfo.g for the package `cvec'                      Max Neunhoeffer
+##
+##  (created from Frank Lübeck's PackageInfo.g template file)
+##  
+
+SetPackageInfo( rec(
+
+PackageName := "cvec",
+Subtitle := "Compact vectors over finite fields",
+Version := "2.5.1",
+Date := "04/04/2014", # dd/mm/yyyy format
+
+##  Information about authors and maintainers.
+Persons := [
+  rec( 
+    LastName      := "Neunhoeffer",
+    FirstNames    := "Max",
+    IsAuthor      := true,
+    IsMaintainer  := false,
+    Email         := "neunhoef@mcs.st-and.ac.uk",
+    WWWHome       := "http://www-groups.mcs.st-and.ac.uk/~neunhoef/",
+    PostalAddress := Concatenation( [
+                       "School of Mathematics and Statistics\n",
+                       "University of St Andrews\n",
+                       "Mathematical Institute\n",
+                       "North Haugh\n",
+                       "St Andrews, Fife KY16 9SS\n",
+                       "Scotland, UK" ] ),
+    Place         := "St Andrews",
+    Institution   := "University of St Andrews"
+  ),
+],
+
+##  Status information. Currently the following cases are recognized:
+##    "accepted"      for successfully refereed packages
+##    "deposited"     for packages for which the GAP developers agreed 
+##                    to distribute them with the core GAP system
+##    "dev"           for development versions of packages 
+##    "other"         for all other packages
+##
+# Status := "accepted",
+Status := "deposited",
+
+##  You must provide the next two entries if and only if the status is 
+##  "accepted" because is was successfully refereed:
+# format: 'name (place)'
+# CommunicatedBy := "Mike Atkinson (St. Andrews)",
+#CommunicatedBy := "",
+# format: mm/yyyy
+# AcceptDate := "08/1999",
+#AcceptDate := "",
+
+PackageWWWHome := "http://neunhoef.github.io/cvec/",
+README_URL     := Concatenation(~.PackageWWWHome, "README"),
+PackageInfoURL := Concatenation(~.PackageWWWHome, "PackageInfo.g"),
+ArchiveURL     := Concatenation("https://github.com/neunhoef/cvec/",
+                                "releases/download/v", ~.Version,
+                                "/cvec-", ~.Version),
+ArchiveFormats := ".tar.gz .tar.bz2",
+
+##  Here you  must provide a short abstract explaining the package content 
+##  in HTML format (used on the package overview Web page) and an URL 
+##  for a Webpage with more detailed information about the package
+##  (not more than a few lines, less is ok):
+##  Please, use '<span class="pkgname">GAP</span>' and
+##  '<span class="pkgname">MyPKG</span>' for specifing package names.
+##  
+AbstractHTML := 
+  "This package provides an implementation of compact vectors over finite\
+   fields. Contrary to earlier implementations no table lookups are used\
+   but only word-based processor arithmetic. This allows for bigger finite\
+   fields and higher speed.",
+
+PackageDoc := rec(
+  BookName  := "cvec",
+  ArchiveURLSubset := ["doc"],
+  HTMLStart := "doc/chap0.html",
+  PDFFile   := "doc/manual.pdf",
+  SixFile   := "doc/manual.six",
+  LongTitle := "Compact vectors over finite fields",
+),
+
+Dependencies := rec(
+  GAP := ">=4.5.5",
+  NeededOtherPackages := [
+    ["GAPDoc", ">= 1.2"],
+    ["IO", ">= 4.1"],
+    ["orb", ">= 4.2"],
+  ],
+  SuggestedOtherPackages := [],
+  ExternalConditions := []
+),
+
+AvailabilityTest := function()
+  if not "cvec" in SHOW_STAT() and
+     Filename(DirectoriesPackagePrograms("cvec"), "cvec.so") = fail then
+    #Info(InfoWarning, 1, "cvec: kernel cvec functions not available.");
+    return fail;
+  fi;
+  return true;
+end,
+
+##  *Optional*, but recommended: path relative to package root to a file which 
+##  contains as many tests of the package functionality as sensible.
+#TestFile := "tst/testall.g",
+
+##  *Optional*: Here you can list some keyword related to the topic 
+##  of the package.
+Keywords := []
+
+));
+
+

samples/GAP/example.gd

@@ -0,0 +1,23 @@
+#############################################################################
+##
+#W  example.gd
+##
+##  This file contains a sample of a GAP declaration file.
+##
+DeclareProperty( "SomeProperty", IsLeftModule );
+DeclareGlobalFunction( "SomeGlobalFunction" );
+
+
+#############################################################################
+##
+#C  IsQuuxFrobnicator(<R>)
+##
+##  <ManSection>
+##  <Filt Name="IsQuuxFrobnicator" Arg='R' Type='Category'/>
+##
+##  <Description>
+##  Tests whether R is a quux frobnicator.
+##  </Description>
+##  </ManSection>
+##
+DeclareSynonym( "IsQuuxFrobnicator", IsField and IsGroup );

samples/GAP/example.gi

@@ -0,0 +1,64 @@
+#############################################################################
+##
+#W  example.gd
+##
+##  This file contains a sample of a GAP implementation file.
+##
+
+
+#############################################################################
+##
+#M  SomeOperation( <val> )
+##
+##  performs some operation on <val>
+##
+InstallMethod( SomeProperty,
+    "for left modules",
+    [ IsLeftModule ], 0,
+    function( M )
+    if IsFreeLeftModule( M ) and not IsTrivial( M ) then
+      return true;
+    fi;
+    TryNextMethod();
+    end );
+
+
+
+#############################################################################
+##
+#F  SomeGlobalFunction( )
+##
+##  A global variadic funfion.
+##
+InstallGlobalFunction( SomeGlobalFunction, function( arg )
+    if Length( arg ) = 3 then
+      return arg[1] + arg[2] * arg[3];
+    elif Length( arg ) = 2 then
+      return arg[1] - arg[2]
+    else
+      Error( "usage: SomeGlobalFunction( <x>, <y>[, <z>] )" );
+    fi;
+    end );
+
+
+#
+# A plain function.
+#
+SomeFunc := function(x, y)
+    local z, func, tmp, j;
+    z := x * 1.0;
+    y := 17^17 - y;
+    func := a -> a mod 5;
+    tmp := List( [1..50], func );
+    while y > 0 do
+        for j in tmp do
+            Print(j, "\n");
+        od;
+        repeat
+            y := y - 1;
+        until 0 < 1;
+        y := y -1;
+    od;
+    return z;
+end;
+        

samples/GAP/vspc.gd

@@ -0,0 +1,822 @@
+#############################################################################
+##
+#W  vspc.gd                     GAP library                     Thomas Breuer
+##
+##
+#Y  Copyright (C)  1997,  Lehrstuhl D für Mathematik,  RWTH Aachen,  Germany
+#Y  (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland
+#Y  Copyright (C) 2002 The GAP Group
+##
+##  This file declares the operations for vector spaces.
+##
+##  The operations for bases of free left modules can be found in the file
+##  <F>lib/basis.gd<F>.
+##
+
+
+#############################################################################
+##
+#C  IsLeftOperatorRing(<R>)
+##
+##  <ManSection>
+##  <Filt Name="IsLeftOperatorRing" Arg='R' Type='Category'/>
+##
+##  <Description>
+##  </Description>
+##  </ManSection>
+##
+DeclareSynonym( "IsLeftOperatorRing",
+    IsLeftOperatorAdditiveGroup and IsRing and IsAssociativeLOpDProd );
+#T really?
+
+
+#############################################################################
+##
+#C  IsLeftOperatorRingWithOne(<R>)
+##
+##  <ManSection>
+##  <Filt Name="IsLeftOperatorRingWithOne" Arg='R' Type='Category'/>
+##
+##  <Description>
+##  </Description>
+##  </ManSection>
+##
+DeclareSynonym( "IsLeftOperatorRingWithOne",
+    IsLeftOperatorAdditiveGroup and IsRingWithOne
+    and IsAssociativeLOpDProd );
+#T really?
+
+
+#############################################################################
+##
+#C  IsLeftVectorSpace( <V> )
+#C  IsVectorSpace( <V> )
+##
+##  <#GAPDoc Label="IsLeftVectorSpace">
+##  <ManSection>
+##  <Filt Name="IsLeftVectorSpace" Arg='V' Type='Category'/>
+##  <Filt Name="IsVectorSpace" Arg='V' Type='Category'/>
+##
+##  <Description>
+##  A <E>vector space</E> in &GAP; is a free left module
+##  (see&nbsp;<Ref Func="IsFreeLeftModule"/>) over a division ring
+##  (see Chapter&nbsp;<Ref Chap="Fields and Division Rings"/>).
+##  <P/>
+##  Whenever we talk about an <M>F</M>-vector space <A>V</A> then <A>V</A> is
+##  an additive group (see&nbsp;<Ref Func="IsAdditiveGroup"/>) on which the
+##  division ring <M>F</M> acts via multiplication from the left such that
+##  this action and the addition in <A>V</A> are left and right distributive.
+##  The division ring <M>F</M> can be accessed as value of the attribute
+##  <Ref Func="LeftActingDomain"/>.
+##  <P/>
+##  Vector spaces in &GAP; are always <E>left</E> vector spaces,
+##  <Ref Filt="IsLeftVectorSpace"/> and <Ref Filt="IsVectorSpace"/> are
+##  synonyms.
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "IsLeftVectorSpace",
+    IsLeftModule and IsLeftActedOnByDivisionRing );
+
+DeclareSynonym( "IsVectorSpace", IsLeftVectorSpace );
+
+InstallTrueMethod( IsFreeLeftModule,
+    IsLeftModule and IsLeftActedOnByDivisionRing );
+
+
+#############################################################################
+##
+#F  IsGaussianSpace( <V> )
+##
+##  <#GAPDoc Label="IsGaussianSpace">
+##  <ManSection>
+##  <Func Name="IsGaussianSpace" Arg='V'/>
+##
+##  <Description>
+##  The filter <Ref Filt="IsGaussianSpace"/> (see&nbsp;<Ref Sect="Filters"/>)
+##  for the row space (see&nbsp;<Ref Func="IsRowSpace"/>)
+##  or matrix space (see&nbsp;<Ref Func="IsMatrixSpace"/>) <A>V</A>
+##  over the field <M>F</M>, say,
+##  indicates that the entries of all row vectors or matrices in <A>V</A>,
+##  respectively, are all contained in <M>F</M>.
+##  In this case, <A>V</A> is called a <E>Gaussian</E> vector space.
+##  Bases for Gaussian spaces can be computed using Gaussian elimination for
+##  a given list of vector space generators.
+##  <Example><![CDATA[
+##  gap> mats:= [ [[1,1],[2,2]], [[3,4],[0,1]] ];;
+##  gap> V:= VectorSpace( Rationals, mats );;
+##  gap> IsGaussianSpace( V );
+##  true
+##  gap> mats[1][1][1]:= E(4);;   # an element in an extension field
+##  gap> V:= VectorSpace( Rationals, mats );;
+##  gap> IsGaussianSpace( V );
+##  false
+##  gap> V:= VectorSpace( Field( Rationals, [ E(4) ] ), mats );;
+##  gap> IsGaussianSpace( V );
+##  true
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareFilter( "IsGaussianSpace", IsVectorSpace );
+
+InstallTrueMethod( IsGaussianSpace,
+    IsVectorSpace and IsFullMatrixModule );
+
+InstallTrueMethod( IsGaussianSpace,
+    IsVectorSpace and IsFullRowModule );
+
+
+#############################################################################
+##
+#C  IsDivisionRing( <D> )
+##
+##  <#GAPDoc Label="IsDivisionRing">
+##  <ManSection>
+##  <Filt Name="IsDivisionRing" Arg='D' Type='Category'/>
+##
+##  <Description>
+##  A <E>division ring</E> in &GAP; is a nontrivial associative algebra
+##  <A>D</A> with a multiplicative inverse for each nonzero element.
+##  In &GAP; every division ring is a vector space over a division ring
+##  (possibly over itself).
+##  Note that being a division ring is thus not a property that a ring can
+##  get, because a ring is usually not represented as a vector space.
+##  <P/>
+##  The field of coefficients is stored as the value of the attribute
+##  <Ref Func="LeftActingDomain"/> of <A>D</A>.
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonymAttr( "IsDivisionRing",
+        IsMagmaWithInversesIfNonzero
+    and IsLeftOperatorRingWithOne
+    and IsLeftVectorSpace
+    and IsNonTrivial
+    and IsAssociative
+    and IsEuclideanRing );
+
+
+#############################################################################
+##
+#A  GeneratorsOfLeftVectorSpace( <V> )
+#A  GeneratorsOfVectorSpace( <V> )
+##
+##  <#GAPDoc Label="GeneratorsOfLeftVectorSpace">
+##  <ManSection>
+##  <Attr Name="GeneratorsOfLeftVectorSpace" Arg='V'/>
+##  <Attr Name="GeneratorsOfVectorSpace" Arg='V'/>
+##
+##  <Description>
+##  For an <M>F</M>-vector space <A>V</A>,
+##  <Ref Attr="GeneratorsOfLeftVectorSpace"/> returns a list of vectors in
+##  <A>V</A> that generate <A>V</A> as an <M>F</M>-vector space.
+##  <Example><![CDATA[
+##  gap> GeneratorsOfVectorSpace( FullRowSpace( Rationals, 3 ) );
+##  [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonymAttr( "GeneratorsOfLeftVectorSpace",
+    GeneratorsOfLeftOperatorAdditiveGroup );
+
+DeclareSynonymAttr( "GeneratorsOfVectorSpace",
+    GeneratorsOfLeftOperatorAdditiveGroup );
+
+
+#############################################################################
+##
+#A  CanonicalBasis( <V> )
+##
+##  <#GAPDoc Label="CanonicalBasis">
+##  <ManSection>
+##  <Attr Name="CanonicalBasis" Arg='V'/>
+##
+##  <Description>
+##  If the vector space <A>V</A> supports a <E>canonical basis</E> then
+##  <Ref Attr="CanonicalBasis"/> returns this basis,
+##  otherwise <K>fail</K> is returned.
+##  <P/>
+##  The defining property of a canonical basis is that its vectors are
+##  uniquely determined by the vector space.
+##  If canonical bases exist for two vector spaces over the same left acting
+##  domain (see&nbsp;<Ref Func="LeftActingDomain"/>) then the equality of
+##  these vector spaces can be decided by comparing the canonical bases.
+##  <P/>
+##  The exact meaning of a canonical basis depends on the type of <A>V</A>.
+##  Canonical bases are defined for example for Gaussian row and matrix
+##  spaces (see&nbsp;<Ref Sect="Row and Matrix Spaces"/>).
+##  <P/>
+##  If one designs a new kind of vector spaces
+##  (see&nbsp;<Ref Sect="How to Implement New Kinds of Vector Spaces"/>) and
+##  defines a canonical basis for these spaces then the
+##  <Ref Attr="CanonicalBasis"/> method one installs
+##  (see&nbsp;<Ref Func="InstallMethod"/>)
+##  must <E>not</E> call <Ref Func="Basis"/>.
+##  On the other hand, one probably should install a <Ref Func="Basis"/>
+##  method that simply calls <Ref Attr="CanonicalBasis"/>,
+##  the value of the method
+##  (see&nbsp;<Ref Sect="Method Installation"/> and
+##  <Ref Sect="Applicable Methods and Method Selection"/>)
+##  being <C>CANONICAL_BASIS_FLAGS</C>.
+##  <Example><![CDATA[
+##  gap> vecs:= [ [ 1, 2, 3 ], [ 1, 1, 1 ], [ 1, 1, 1 ] ];;
+##  gap> V:= VectorSpace( Rationals, vecs );;
+##  gap> B:= CanonicalBasis( V );
+##  CanonicalBasis( <vector space over Rationals, with 3 generators> )
+##  gap> BasisVectors( B );
+##  [ [ 1, 0, -1 ], [ 0, 1, 2 ] ]
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareAttribute( "CanonicalBasis", IsFreeLeftModule );
+
+
+#############################################################################
+##
+#F  IsRowSpace( <V> )
+##
+##  <#GAPDoc Label="IsRowSpace">
+##  <ManSection>
+##  <Func Name="IsRowSpace" Arg='V'/>
+##
+##  <Description>
+##  A <E>row space</E> in &GAP; is a vector space that consists of
+##  row vectors (see Chapter&nbsp;<Ref Chap="Row Vectors"/>).
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "IsRowSpace", IsRowModule and IsVectorSpace );
+
+
+#############################################################################
+##
+#F  IsGaussianRowSpace( <V> )
+##
+##  <ManSection>
+##  <Func Name="IsGaussianRowSpace" Arg='V'/>
+##
+##  <Description>
+##  A row space is <E>Gaussian</E> if the left acting domain contains all
+##  scalars that occur in the vectors.
+##  Thus one can use Gaussian elimination in the calculations.
+##  <P/>
+##  (Otherwise the space is non-Gaussian.
+##  We will need a flag for this to write down methods that delegate from
+##  non-Gaussian spaces to Gaussian ones.)
+##  <!-- reformulate this when it becomes documented -->
+##  </Description>
+##  </ManSection>
+##
+DeclareSynonym( "IsGaussianRowSpace", IsGaussianSpace and IsRowSpace );
+
+
+#############################################################################
+##
+#F  IsNonGaussianRowSpace( <V> )
+##
+##  <ManSection>
+##  <Func Name="IsNonGaussianRowSpace" Arg='V'/>
+##
+##  <Description>
+##  If an <M>F</M>-vector space <A>V</A> is in the filter
+##  <Ref Func="IsNonGaussianRowSpace"/> then this expresses that <A>V</A>
+##  consists of row vectors (see&nbsp;<Ref Func="IsRowVector"/>) such
+##  that not all entries in these row vectors are contained in <M>F</M>
+##  (so Gaussian elimination cannot be used to compute an <M>F</M>-basis
+##  from a list of vector space generators),
+##  and that <A>V</A> is handled via the mechanism of nice bases
+##  (see&nbsp;<Ref ???="..."/>) in the following way.
+##  Let <M>K</M> be the field spanned by the entries of all vectors in
+##  <A>V</A>.
+##  Then the <Ref Attr="NiceFreeLeftModuleInfo"/> value of <A>V</A> is
+##  a basis <M>B</M> of the field extension <M>K / ( K \cap F )</M>,
+##  and the <Ref Func="NiceVector"/> value of <M>v \in <A>V</A></M>
+##  is defined by replacing each entry of <M>v</M> by the list of its
+##  <M>B</M>-coefficients, and then forming the concatenation.
+##  <P/>
+##  So the associated nice vector space is a Gaussian row space
+##  (see&nbsp;<Ref Func="IsGaussianRowSpace"/>).
+##  </Description>
+##  </ManSection>
+##
+DeclareHandlingByNiceBasis( "IsNonGaussianRowSpace",
+    "for non-Gaussian row spaces" );
+
+
+#############################################################################
+##
+#F  IsMatrixSpace( <V> )
+##
+##  <#GAPDoc Label="IsMatrixSpace">
+##  <ManSection>
+##  <Func Name="IsMatrixSpace" Arg='V'/>
+##
+##  <Description>
+##  A <E>matrix space</E> in &GAP; is a vector space that consists of matrices
+##  (see Chapter&nbsp;<Ref Chap="Matrices"/>).
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "IsMatrixSpace", IsMatrixModule and IsVectorSpace );
+
+
+#############################################################################
+##
+#F  IsGaussianMatrixSpace( <V> )
+##
+##  <ManSection>
+##  <Func Name="IsGaussianMatrixSpace" Arg='V'/>
+##
+##  <Description>
+##  A matrix space is Gaussian if the left acting domain contains all
+##  scalars that occur in the vectors.
+##  Thus one can use Gaussian elimination in the calculations.
+##  <P/>
+##  (Otherwise the space is non-Gaussian.
+##  We will need a flag for this to write down methods that delegate from
+##  non-Gaussian spaces to Gaussian ones.)
+##  </Description>
+##  </ManSection>
+##
+DeclareSynonym( "IsGaussianMatrixSpace", IsGaussianSpace and IsMatrixSpace );
+
+
+#############################################################################
+##
+#F  IsNonGaussianMatrixSpace( <V> )
+##
+##  <ManSection>
+##  <Func Name="IsNonGaussianMatrixSpace" Arg='V'/>
+##
+##  <Description>
+##  If an <M>F</M>-vector space <A>V</A> is in the filter
+##  <Ref Func="IsNonGaussianMatrixSpace"/>
+##  then this expresses that <A>V</A> consists of matrices
+##  (see&nbsp;<Ref Func="IsMatrix"/>)
+##  such that not all entries in these matrices are contained in <M>F</M>
+##  (so Gaussian elimination cannot be used to compute an <M>F</M>-basis
+##  from a list of vector space generators),
+##  and that <A>V</A> is handled via the mechanism of nice bases
+##  (see&nbsp;<Ref ???="..."/>) in the following way.
+##  Let <M>K</M> be the field spanned by the entries of all vectors in <A>V</A>.
+##  The <Ref Attr="NiceFreeLeftModuleInfo"/> value of <A>V</A> is irrelevant,
+##  and the <Ref Func="NiceVector"/> value of <M>v \in <A>V</A></M>
+##  is defined as the concatenation of the rows of <M>v</M>.
+##  <P/>
+##  So the associated nice vector space is a (not necessarily Gaussian)
+##  row space (see&nbsp;<Ref Func="IsRowSpace"/>).
+##  </Description>
+##  </ManSection>
+##
+DeclareHandlingByNiceBasis( "IsNonGaussianMatrixSpace",
+    "for non-Gaussian matrix spaces" );
+
+
+#############################################################################
+##
+#A  NormedRowVectors( <V> ) . . .  normed vectors in a Gaussian row space <V>
+##
+##  <#GAPDoc Label="NormedRowVectors">
+##  <ManSection>
+##  <Attr Name="NormedRowVectors" Arg='V'/>
+##
+##  <Description>
+##  For a finite Gaussian row space <A>V</A>
+##  (see&nbsp;<Ref Func="IsRowSpace"/>, <Ref Func="IsGaussianSpace"/>),
+##  <Ref Attr="NormedRowVectors"/> returns a list of those nonzero
+##  vectors in <A>V</A> that have a one in the first nonzero component.
+##  <P/>
+##  The result list can be used as action domain for the action of a matrix
+##  group via <Ref Func="OnLines"/>, which yields the natural action on
+##  one-dimensional subspaces of <A>V</A>
+##  (see also&nbsp;<Ref Func="Subspaces"/>).
+##  <Example><![CDATA[
+##  gap> vecs:= NormedRowVectors( GF(3)^2 );
+##  [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], 
+##    [ Z(3)^0, Z(3) ] ]
+##  gap> Action( GL(2,3), vecs, OnLines );
+##  Group([ (3,4), (1,2,4) ])
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareAttribute( "NormedRowVectors", IsGaussianSpace );
+
+
+#############################################################################
+##
+#A  TrivialSubspace( <V> )
+##
+##  <#GAPDoc Label="TrivialSubspace">
+##  <ManSection>
+##  <Attr Name="TrivialSubspace" Arg='V'/>
+##
+##  <Description>
+##  For a vector space <A>V</A>, <Ref Attr="TrivialSubspace"/> returns the
+##  subspace of <A>V</A> that consists of the zero vector in <A>V</A>.
+##  <Example><![CDATA[
+##  gap> V:= GF(3)^3;;
+##  gap> triv:= TrivialSubspace( V );
+##  <vector space over GF(3), with 0 generators>
+##  gap> AsSet( triv );
+##  [ [ 0*Z(3), 0*Z(3), 0*Z(3) ] ]
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonymAttr( "TrivialSubspace", TrivialSubmodule );
+
+
+#############################################################################
+##
+#F  VectorSpace( <F>, <gens>[, <zero>][, "basis"] )
+##
+##  <#GAPDoc Label="VectorSpace">
+##  <ManSection>
+##  <Func Name="VectorSpace" Arg='F, gens[, zero][, "basis"]'/>
+##
+##  <Description>
+##  For a field <A>F</A> and a collection <A>gens</A> of vectors,
+##  <Ref Func="VectorSpace"/> returns the <A>F</A>-vector space spanned by
+##  the elements in <A>gens</A>.
+##  <P/>
+##  The optional argument <A>zero</A> can be used to specify the zero element
+##  of the space; <A>zero</A> <E>must</E> be given if <A>gens</A> is empty.
+##  The optional string <C>"basis"</C> indicates that <A>gens</A> is known to
+##  be linearly independent over <A>F</A>, in particular the dimension of the
+##  vector space is immediately set;
+##  note that <Ref Func="Basis"/> need <E>not</E> return the basis formed by
+##  <A>gens</A> if the string <C>"basis"</C> is given as an argument.
+##  <!-- crossref. to <C>FreeLeftModule</C> as soon as the modules chapter
+##       is reliable!-->
+##  <Example><![CDATA[
+##  gap> V:= VectorSpace( Rationals, [ [ 1, 2, 3 ], [ 1, 1, 1 ] ] );
+##  <vector space over Rationals, with 2 generators>
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareGlobalFunction( "VectorSpace" );
+
+
+#############################################################################
+##
+#F  Subspace( <V>, <gens>[, "basis"] )  . subspace of <V> generated by <gens>
+#F  SubspaceNC( <V>, <gens>[, "basis"] )
+##
+##  <#GAPDoc Label="Subspace">
+##  <ManSection>
+##  <Func Name="Subspace" Arg='V, gens[, "basis"]'/>
+##  <Func Name="SubspaceNC" Arg='V, gens[, "basis"]'/>
+##
+##  <Description>
+##  For an <M>F</M>-vector space <A>V</A> and a list or collection
+##  <A>gens</A> that is a subset of <A>V</A>,
+##  <Ref Func="Subspace"/> returns the <M>F</M>-vector space spanned by
+##  <A>gens</A>; if <A>gens</A> is empty then the trivial subspace
+##  (see&nbsp;<Ref Func="TrivialSubspace"/>) of <A>V</A> is returned.
+##  The parent (see&nbsp;<Ref Sect="Parents"/>) of the returned vector space
+##  is set to <A>V</A>.
+##  <P/>
+##  <Ref Func="SubspaceNC"/> does the same as <Ref Func="Subspace"/>,
+##  except that it omits the check whether <A>gens</A> is a subset of
+##  <A>V</A>.
+##  <P/>
+##  The optional string <A>"basis"</A> indicates that <A>gens</A> is known to
+##  be linearly independent over <M>F</M>.
+##  In this case the dimension of the subspace is immediately set,
+##  and both <Ref Func="Subspace"/> and <Ref Func="SubspaceNC"/> do
+##  <E>not</E> check whether <A>gens</A> really is linearly independent and
+##  whether <A>gens</A> is a subset of <A>V</A>.
+##  <!-- crossref. to <C>Submodule</C> as soon as the modules chapter
+##       is reliable!-->
+##  <Example><![CDATA[
+##  gap> V:= VectorSpace( Rationals, [ [ 1, 2, 3 ], [ 1, 1, 1 ] ] );;
+##  gap> W:= Subspace( V, [ [ 0, 1, 2 ] ] );
+##  <vector space over Rationals, with 1 generators>
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "Subspace", Submodule );
+
+DeclareSynonym( "SubspaceNC", SubmoduleNC );
+
+
+#############################################################################
+##
+#O  AsVectorSpace( <F>, <D> ) . . . . . . . . .  view <D> as <F>-vector space
+##
+##  <#GAPDoc Label="AsVectorSpace">
+##  <ManSection>
+##  <Oper Name="AsVectorSpace" Arg='F, D'/>
+##
+##  <Description>
+##  Let <A>F</A> be a division ring and <A>D</A> a domain.
+##  If the elements in <A>D</A> form an <A>F</A>-vector space then
+##  <Ref Oper="AsVectorSpace"/> returns this <A>F</A>-vector space,
+##  otherwise <K>fail</K> is returned.
+##  <P/>
+##  <Ref Oper="AsVectorSpace"/> can be used for example to view a given
+##  vector space as a vector space over a smaller or larger division ring.
+##  <Example><![CDATA[
+##  gap> V:= FullRowSpace( GF( 27 ), 3 );
+##  ( GF(3^3)^3 )
+##  gap> Dimension( V );  LeftActingDomain( V );
+##  3
+##  GF(3^3)
+##  gap> W:= AsVectorSpace( GF( 3 ), V );
+##  <vector space over GF(3), with 9 generators>
+##  gap> Dimension( W );  LeftActingDomain( W );
+##  9
+##  GF(3)
+##  gap> AsVectorSpace( GF( 9 ), V );
+##  fail
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "AsVectorSpace", AsLeftModule );
+
+
+#############################################################################
+##
+#O  AsSubspace( <V>, <U> )  . . . . . . . . . . . view <U> as subspace of <V>
+##
+##  <#GAPDoc Label="AsSubspace">
+##  <ManSection>
+##  <Oper Name="AsSubspace" Arg='V, U'/>
+##
+##  <Description>
+##  Let <A>V</A> be an <M>F</M>-vector space, and <A>U</A> a collection.
+##  If <A>U</A> is a subset of <A>V</A> such that the elements of <A>U</A>
+##  form an <M>F</M>-vector space then <Ref Oper="AsSubspace"/> returns this
+##  vector space, with parent set to <A>V</A>
+##  (see&nbsp;<Ref Func="AsVectorSpace"/>).
+##  Otherwise <K>fail</K> is returned.
+##  <Example><![CDATA[
+##  gap> V:= VectorSpace( Rationals, [ [ 1, 2, 3 ], [ 1, 1, 1 ] ] );;
+##  gap> W:= VectorSpace( Rationals, [ [ 1/2, 1/2, 1/2 ] ] );;
+##  gap> U:= AsSubspace( V, W );
+##  <vector space over Rationals, with 1 generators>
+##  gap> Parent( U ) = V;
+##  true
+##  gap> AsSubspace( V, [ [ 1, 1, 1 ] ] );
+##  fail
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareOperation( "AsSubspace", [ IsVectorSpace, IsCollection ] );
+
+
+#############################################################################
+##
+#F  Intersection2Spaces( <AsStruct>, <Substruct>, <Struct> )
+##
+##  <ManSection>
+##  <Func Name="Intersection2Spaces" Arg='AsStruct, Substruct, Struct'/>
+##
+##  <Description>
+##  is a function that takes two arguments <A>V</A> and <A>W</A> which must
+##  be finite dimensional vector spaces,
+##  and returns the intersection of <A>V</A> and <A>W</A>.
+##  <P/>
+##  If the left acting domains are different then let <M>F</M> be their
+##  intersection.
+##  The intersection of <A>V</A> and <A>W</A> is computed as intersection of
+##  <C><A>AsStruct</A>( <A>F</A>, <A>V</A> )</C> and
+##  <C><A>AsStruct</A>( <A>F</A>, <A>V</A> )</C>.
+##  <P/>
+##  If the left acting domains are equal to <M>F</M> then the intersection of
+##  <A>V</A> and <A>W</A> is returned either as <M>F</M>-<A>Substruct</A>
+##  with the common parent of <A>V</A> and <A>W</A> or as
+##  <M>F</M>-<A>Struct</A>, in both cases with known basis.
+##  <P/>
+##  This function is used to handle the intersections of two vector spaces,
+##  two algebras, two algebras-with-one, two left ideals, two right ideals,
+##  two two-sided ideals.
+##  </Description>
+##  </ManSection>
+##
+DeclareGlobalFunction( "Intersection2Spaces" );
+
+
+#############################################################################
+##
+#F  FullRowSpace( <F>, <n> )
+##
+##  <#GAPDoc Label="FullRowSpace">
+##  <ManSection>
+##  <Func Name="FullRowSpace" Arg='F, n'/>
+##  <Meth Name="\^" Arg='F, n' Label="for a field and an integer"/>
+##
+##  <Description>
+##  For a field <A>F</A> and a nonnegative integer <A>n</A>,
+##  <Ref Func="FullRowSpace"/> returns the <A>F</A>-vector space that
+##  consists of all row vectors (see&nbsp;<Ref Func="IsRowVector"/>) of
+##  length <A>n</A> with entries in <A>F</A>.
+##  <P/>
+##  An alternative to construct this vector space is via
+##  <A>F</A><C>^</C><A>n</A>.
+##  <Example><![CDATA[
+##  gap> FullRowSpace( GF( 9 ), 3 );
+##  ( GF(3^2)^3 )
+##  gap> GF(9)^3;           # the same as above
+##  ( GF(3^2)^3 )
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "FullRowSpace", FullRowModule );
+DeclareSynonym( "RowSpace", FullRowModule );
+
+
+#############################################################################
+##
+#F  FullMatrixSpace( <F>, <m>, <n> )
+##
+##  <#GAPDoc Label="FullMatrixSpace">
+##  <ManSection>
+##  <Func Name="FullMatrixSpace" Arg='F, m, n'/>
+##  <Meth Name="\^" Arg='F, dims'
+##   Label="for a field and a pair of integers"/>
+##
+##  <Description>
+##  For a field <A>F</A> and two positive integers <A>m</A> and <A>n</A>,
+##  <Ref Func="FullMatrixSpace"/> returns the <A>F</A>-vector space that
+##  consists of all <A>m</A> by <A>n</A> matrices
+##  (see&nbsp;<Ref Func="IsMatrix"/>) with entries in <A>F</A>.
+##  <P/>
+##  If <A>m</A><C> = </C><A>n</A> then the result is in fact an algebra
+##  (see&nbsp;<Ref Func="FullMatrixAlgebra"/>).
+##  <P/>
+##  An alternative to construct this vector space is via
+##  <A>F</A><C>^[</C><A>m</A>,<A>n</A><C>]</C>.
+##  <Example><![CDATA[
+##  gap> FullMatrixSpace( GF(2), 4, 5 );
+##  ( GF(2)^[ 4, 5 ] )
+##  gap> GF(2)^[ 4, 5 ];    # the same as above
+##  ( GF(2)^[ 4, 5 ] )
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareSynonym( "FullMatrixSpace", FullMatrixModule );
+DeclareSynonym( "MatrixSpace", FullMatrixModule );
+DeclareSynonym( "MatSpace", FullMatrixModule );
+
+
+#############################################################################
+##
+#C  IsSubspacesVectorSpace( <D> )
+##
+##  <#GAPDoc Label="IsSubspacesVectorSpace">
+##  <ManSection>
+##  <Filt Name="IsSubspacesVectorSpace" Arg='D' Type='Category'/>
+##
+##  <Description>
+##  The domain of all subspaces of a (finite) vector space or of all
+##  subspaces of fixed dimension, as returned by <Ref Func="Subspaces"/>
+##  (see&nbsp;<Ref Func="Subspaces"/>) lies in the category
+##  <Ref Filt="IsSubspacesVectorSpace"/>.
+##  <Example><![CDATA[
+##  gap> D:= Subspaces( GF(3)^3 );
+##  Subspaces( ( GF(3)^3 ) )
+##  gap> Size( D );
+##  28
+##  gap> iter:= Iterator( D );;
+##  gap> NextIterator( iter );
+##  <vector space over GF(3), with 0 generators>
+##  gap> NextIterator( iter );
+##  <vector space of dimension 1 over GF(3)>
+##  gap> IsSubspacesVectorSpace( D );
+##  true
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareCategory( "IsSubspacesVectorSpace", IsDomain );
+
+
+#############################################################################
+##
+#M  IsFinite( <D> ) . . . . . . . . . . . . . . . . .  for a subspaces domain
+##
+##  Returns `true' if <D> is finite.
+##  We allow subspaces domains in `IsSubspacesVectorSpace' only for finite
+##  vector spaces.
+##
+InstallTrueMethod( IsFinite, IsSubspacesVectorSpace );
+
+
+#############################################################################
+##
+#A  Subspaces( <V>[, <k>] )
+##
+##  <#GAPDoc Label="Subspaces">
+##  <ManSection>
+##  <Attr Name="Subspaces" Arg='V[, k]'/>
+##
+##  <Description>
+##  Called with a finite vector space <A>v</A>,
+##  <Ref Oper="Subspaces"/> returns the domain of all subspaces of <A>V</A>.
+##  <P/>
+##  Called with <A>V</A> and a nonnegative integer <A>k</A>,
+##  <Ref Oper="Subspaces"/> returns the domain of all <A>k</A>-dimensional
+##  subspaces of <A>V</A>.
+##  <P/>
+##  Special <Ref Attr="Size"/> and <Ref Oper="Iterator"/> methods are
+##  provided for these domains.
+##  <!-- <C>Enumerator</C> would also be good ...
+##       (special treatment for full row spaces,
+##       other spaces delegate to this)-->
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareAttribute( "Subspaces", IsLeftModule );
+DeclareOperation( "Subspaces", [ IsLeftModule, IsInt ] );
+
+
+#############################################################################
+##
+#F  IsSubspace( <V>, <U> )
+##
+##  <ManSection>
+##  <Func Name="IsSubspace" Arg='V, U'/>
+##
+##  <Description>
+##  check that <A>U</A> is a vector space that is contained in <A>V</A>
+##  <!-- Must also <A>V</A> be a vector space?
+##       If yes then must <A>V</A> and <A>U</A> have same left acting domain?
+##       (Is this function useful at all?) -->
+##  </Description>
+##  </ManSection>
+##
+DeclareGlobalFunction( "IsSubspace" );
+
+
+#############################################################################
+##
+#A  OrthogonalSpaceInFullRowSpace( <U> )
+##
+##  <ManSection>
+##  <Attr Name="OrthogonalSpaceInFullRowSpace" Arg='U'/>
+##
+##  <Description>
+##  For a Gaussian row space <A>U</A> over <M>F</M>,
+##  <Ref Attr="OrthogonalSpaceInFullRowSpace"/>
+##  returns a complement of <A>U</A> in the full row space of same vector
+##  dimension as <A>U</A> over <M>F</M>.
+##  </Description>
+##  </ManSection>
+##
+DeclareAttribute( "OrthogonalSpaceInFullRowSpace", IsGaussianSpace );
+
+
+#############################################################################
+##
+#P  IsVectorSpaceHomomorphism( <map> )
+##
+##  <ManSection>
+##  <Prop Name="IsVectorSpaceHomomorphism" Arg='map'/>
+##
+##  <Description>
+##  A mapping <M>f</M> is a vector space homomorphism (or linear mapping)
+##  if the source and range are vector spaces
+##  (see&nbsp;<Ref Func="IsVectorSpace"/>)
+##  over the same division ring <M>D</M>
+##  (see&nbsp;<Ref Func="LeftActingDomain"/>),
+##  and if <M>f( a + b ) = f(a) + f(b)</M> and <M>f( s * a ) = s * f(a)</M>
+##  hold for all elements <M>a</M>, <M>b</M> in the source of <M>f</M> and
+##  <M>s \in D</M>.
+##  </Description>
+##  </ManSection>
+##
+DeclareProperty( "IsVectorSpaceHomomorphism", IsGeneralMapping );
+
+
+#############################################################################
+##
+#E
+

samples/GAP/vspc.gi

@@ -0,0 +1,651 @@
+#############################################################################
+##
+#W  vspc.gi                     GAP library                     Thomas Breuer
+##
+##
+#Y  Copyright (C)  1997,  Lehrstuhl D für Mathematik,  RWTH Aachen,  Germany
+#Y  (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland
+#Y  Copyright (C) 2002 The GAP Group
+##
+##  This file contains generic methods for vector spaces.
+##
+
+
+#############################################################################
+##
+#M  SetLeftActingDomain( <extL>, <D> )
+##
+##  check whether the left acting domain <D> of the external left set <extL>
+##  knows that it is a division ring.
+##  This is used, e.g.,  to tell a free module over a division ring
+##  that it is a vector space.
+##
+InstallOtherMethod( SetLeftActingDomain,
+    "method to set also 'IsLeftActedOnByDivisionRing'",
+    [ IsAttributeStoringRep and IsLeftActedOnByRing, IsObject ],0,
+    function( extL, D )
+    if HasIsDivisionRing( D ) and IsDivisionRing( D ) then
+      SetIsLeftActedOnByDivisionRing( extL, true );
+    fi;
+    TryNextMethod();
+    end );
+
+
+#############################################################################
+##
+#M  IsLeftActedOnByDivisionRing( <M> )
+##
+InstallMethod( IsLeftActedOnByDivisionRing,
+    "method for external left set that is left acted on by a ring",
+    [ IsExtLSet and IsLeftActedOnByRing ],
+    function( M )
+    if IsIdenticalObj( M, LeftActingDomain( M ) ) then
+      TryNextMethod();
+    else
+      return IsDivisionRing( LeftActingDomain( M ) );
+    fi;
+    end );
+
+
+#############################################################################
+##
+#F  VectorSpace( <F>, <gens>[, <zero>][, "basis"] )
+##
+##  The only difference between `VectorSpace' and `FreeLeftModule' shall be
+##  that the left acting domain of a vector space must be a division ring.
+##
+InstallGlobalFunction( VectorSpace, function( arg )
+    if Length( arg ) = 0 or not IsDivisionRing( arg[1] ) then
+      Error( "usage: VectorSpace( <F>, <gens>[, <zero>][, \"basis\"] )" );
+    fi;
+    return CallFuncList( FreeLeftModule, arg );
+    end );
+
+
+#############################################################################
+##
+#M  AsSubspace( <V>, <C> )  . . . . . . . for a vector space and a collection
+##
+InstallMethod( AsSubspace,
+    "for a vector space and a collection",
+    [ IsVectorSpace, IsCollection ],
+    function( V, C )
+    local newC;
+
+    if not IsSubset( V, C ) then
+      return fail;
+    fi;
+    newC:= AsVectorSpace( LeftActingDomain( V ), C );
+    if newC = fail then
+      return fail;
+    fi;
+    SetParent( newC, V );
+    UseIsomorphismRelation( C, newC );
+    UseSubsetRelation( C, newC );
+
+    return newC;
+    end );
+
+
+#############################################################################
+##
+#M  AsLeftModule( <F>, <V> )  . . . . . .  for division ring and vector space
+##
+##  View the vector space <V> as a vector space over the division ring <F>.
+##
+InstallMethod( AsLeftModule,
+    "method for a division ring and a vector space",
+    [ IsDivisionRing, IsVectorSpace ],
+    function( F, V )
+
+    local W,        # the space, result
+          base,     # basis vectors of field extension
+          gen,      # loop over generators of 'V'
+          b,        # loop over 'base'
+          gens,     # generators of 'V'
+          newgens;  # extended list of generators
+
+    if Characteristic( F ) <> Characteristic( LeftActingDomain( V ) ) then
+
+      # This is impossible.
+      return fail;
+
+    elif F = LeftActingDomain( V ) then
+
+      # No change of the left acting domain is necessary.
+      return V;
+
+    elif IsSubset( F, LeftActingDomain( V ) ) then
+
+      # Check whether 'V' is really a space over the bigger field,
+      # that is, whether the set of elements does not change.
+      base:= BasisVectors( Basis( AsField( LeftActingDomain( V ), F ) ) );
+      for gen in GeneratorsOfLeftModule( V ) do
+        for b in base do
+          if not b * gen in V then
+
+            # The field extension would change the set of elements.
+            return fail;
+
+          fi;
+        od;
+      od;
+
+      # Construct the space.
+      W:= LeftModuleByGenerators( F, GeneratorsOfLeftModule(V), Zero(V) );
+
+    elif IsSubset( LeftActingDomain( V ), F ) then
+
+      # View 'V' as a space over a smaller field.
+      # For that, the list of generators must be extended.
+      gens:= GeneratorsOfLeftModule( V );
+      if IsEmpty( gens ) then
+        W:= LeftModuleByGenerators( F, [], Zero( V ) );
+      else
+
+        base:= BasisVectors( Basis( AsField( F, LeftActingDomain( V ) ) ) );
+        newgens:= [];
+        for b in base do
+          for gen in gens do
+            Add( newgens, b * gen );
+          od;
+        od;
+        W:= LeftModuleByGenerators( F, newgens );
+
+      fi;
+
+    else
+
+      # View 'V' first as space over the intersection of fields,
+      # and then over the desired field.
+      return AsLeftModule( F,
+                 AsLeftModule( Intersection( F,
+                     LeftActingDomain( V ) ), V ) );
+
+    fi;
+
+    UseIsomorphismRelation( V, W );
+    UseSubsetRelation( V, W );
+    return W;
+    end );
+
+
+#############################################################################
+##
+#M  ViewObj( <V> )  . . . . . . . . . . . . . . . . . . . view a vector space
+##
+##  print left acting domain, if known also dimension or no. of generators
+##
+InstallMethod( ViewObj,
+    "for vector space with known generators",
+    [ IsVectorSpace and HasGeneratorsOfLeftModule ],
+    function( V )
+    Print( "<vector space over ", LeftActingDomain( V ), ", with ",
+           Length( GeneratorsOfLeftModule( V ) ), " generators>" );
+    end );
+
+InstallMethod( ViewObj,
+    "for vector space with known dimension",
+    [ IsVectorSpace and HasDimension ],
+    1, # override method for known generators
+    function( V )
+    Print( "<vector space of dimension ", Dimension( V ),
+           " over ", LeftActingDomain( V ), ">" );
+    end );
+
+InstallMethod( ViewObj,
+    "for vector space",
+    [ IsVectorSpace ],
+    function( V )
+    Print( "<vector space over ", LeftActingDomain( V ), ">" );
+    end );
+
+
+#############################################################################
+##
+#M  PrintObj( <V> ) . . . . . . . . . . . . . . . . . . .  for a vector space
+##
+InstallMethod( PrintObj,
+    "method for vector space with left module generators",
+    [ IsVectorSpace and HasGeneratorsOfLeftModule ],
+    function( V )
+    Print( "VectorSpace( ", LeftActingDomain( V ), ", ",
+           GeneratorsOfLeftModule( V ) );
+    if IsEmpty( GeneratorsOfLeftModule( V ) ) and HasZero( V ) then
+      Print( ", ", Zero( V ), " )" );
+    else
+      Print( " )" );
+    fi;
+    end );
+
+InstallMethod( PrintObj,
+    "method for vector space",
+    [ IsVectorSpace ],
+    function( V )
+    Print( "VectorSpace( ", LeftActingDomain( V ), ", ... )" );
+    end );
+
+
+#############################################################################
+##
+#M  \/( <V>, <W> )  . . . . . . . . .  factor of a vector space by a subspace
+#M  \/( <V>, <vectors> )  . . . . . .  factor of a vector space by a subspace
+##
+InstallOtherMethod( \/,
+    "method for vector space and collection",
+    IsIdenticalObj,
+    [ IsVectorSpace, IsCollection ],
+    function( V, vectors )
+    if IsVectorSpace( vectors ) then
+      TryNextMethod();
+    else
+      return V / Subspace( V, vectors );
+    fi;
+    end );
+
+InstallOtherMethod( \/,
+    "generic method for two vector spaces",
+    IsIdenticalObj,
+    [ IsVectorSpace, IsVectorSpace ],
+    function( V, W )
+    return ImagesSource( NaturalHomomorphismBySubspace( V, W ) );
+    end );
+
+
+#############################################################################
+##
+#M  Intersection2Spaces( <AsStruct>, <Substruct>, <Struct> )
+##
+InstallGlobalFunction( Intersection2Spaces,
+    function( AsStructure, Substructure, Structure )
+    return function( V, W )
+    local inters,  # intersection, result
+          F,       # coefficients field
+          gensV,   # list of generators of 'V'
+          gensW,   # list of generators of 'W'
+          VW,      # sum of 'V' and 'W'
+          B;       # basis of 'VW'
+
+    if LeftActingDomain( V ) <> LeftActingDomain( W ) then
+
+      # Compute the intersection as vector space over the intersection
+      # of the coefficients fields.
+      # (Note that the characteristic is the same.)
+      F:= Intersection2( LeftActingDomain( V ), LeftActingDomain( W ) );
+      return Intersection2( AsStructure( F, V ), AsStructure( F, W ) );
+
+    elif IsFiniteDimensional( V ) and IsFiniteDimensional( W ) then
+
+      # Compute the intersection of two spaces over the same field.
+      gensV:= GeneratorsOfLeftModule( V );
+      gensW:= GeneratorsOfLeftModule( W );
+      if   IsEmpty( gensV ) then
+        if Zero( V ) in W then
+          inters:= V;
+        else
+          inters:= [];
+        fi;
+      elif IsEmpty( gensW ) then
+        if Zero( V ) in W then
+          inters:= W;
+        else
+          inters:= [];
+        fi;
+      else
+        # Compute a common coefficient space.
+        VW:= LeftModuleByGenerators( LeftActingDomain( V ),
+                                     Concatenation( gensV, gensW ) );
+        B:= Basis( VW );
+
+        # Construct the coefficient subspaces corresponding to 'V' and 'W'.
+        gensV:= List( gensV, x -> Coefficients( B, x ) );
+        gensW:= List( gensW, x -> Coefficients( B, x ) );
+
+        # Construct the intersection of row spaces, and carry back to VW.
+        inters:= List( SumIntersectionMat( gensV, gensW )[2],
+                       x -> LinearCombination( B, x ) );
+
+        # Construct the intersection space, if possible with a parent.
+        if     HasParent( V ) and HasParent( W )
+           and IsIdenticalObj( Parent( V ), Parent( W ) ) then
+          inters:= Substructure( Parent( V ), inters, "basis" );
+        elif IsEmpty( inters ) then
+          inters:= Substructure( V, inters, "basis" );
+          SetIsTrivial( inters, true );
+        else
+          inters:= Structure( LeftActingDomain( V ), inters, "basis" );
+        fi;
+
+        # Run implications by the subset relation.
+        UseSubsetRelation( V, inters );
+        UseSubsetRelation( W, inters );
+      fi;
+
+      # Return the result.
+      return inters;
+
+    else
+      TryNextMethod();
+    fi;
+    end;
+end );
+
+
+#############################################################################
+##
+#M  Intersection2( <V>, <W> ) . . . . . . . . . . . . . for two vector spaces
+##
+InstallMethod( Intersection2,
+    "method for two vector spaces",
+    IsIdenticalObj,
+    [ IsVectorSpace, IsVectorSpace ],
+    Intersection2Spaces( AsLeftModule, SubspaceNC, VectorSpace ) );
+
+
+#############################################################################
+##
+#M  ClosureLeftModule( <V>, <a> ) . . . . . . . . . closure of a vector space
+##
+InstallMethod( ClosureLeftModule,
+    "method for a vector space with basis, and a vector",
+    IsCollsElms,
+    [ IsVectorSpace and HasBasis, IsVector ],
+    function( V, w )
+    local   B; # basis of 'V'
+
+    # We can test membership easily.
+    B:= Basis( V );
+#T why easily?
+    if Coefficients( B, w ) = fail then
+
+      # In the case of a vector space, we know a basis of the closure.
+      B:= Concatenation( BasisVectors( B ), [ w ] );
+      V:= LeftModuleByGenerators( LeftActingDomain( V ), B );
+      UseBasis( V, B );
+
+    fi;
+    return V;
+    end );
+
+
+#############################################################################
+##
+##  Methods for collections of subspaces of a vector space
+##
+
+
+#############################################################################
+##
+#R  IsSubspacesVectorSpaceDefaultRep( <D> )
+##
+##  is the representation of domains of subspaces of a vector space <V>,
+##  with the components 'structure' (with value <V>) and 'dimension'
+##  (with value either the dimension of the subspaces in the domain
+##  or the string '\"all\"', which means that the domain contains all
+##  subspaces of <V>).
+##
+DeclareRepresentation(
+    "IsSubspacesVectorSpaceDefaultRep",
+    IsComponentObjectRep,
+    [ "dimension", "structure" ] );
+#T not IsAttributeStoringRep?
+
+
+#############################################################################
+##
+#M  PrintObj( <D> )  . . . . . . . . . . . . . . . . . for a subspaces domain
+##
+InstallMethod( PrintObj,
+    "method for a subspaces domain",
+    [ IsSubspacesVectorSpace and IsSubspacesVectorSpaceDefaultRep ],
+    function( D )
+    if IsInt( D!.dimension ) then
+      Print( "Subspaces( ", D!.structure, ", ", D!.dimension, " )" );
+    else
+      Print( "Subspaces( ", D!.structure, " )" );
+    fi;
+    end );
+
+
+#############################################################################
+##
+#M  Size( <D> ) . . . . . . . . . . . . . . . . . . .  for a subspaces domain
+##
+##  The number of $k$-dimensional subspaces in a $n$-dimensional space over
+##  the field with $q$ elements is
+##  $$
+##  a(n,k) = \prod_{i=0}^{k-1} \frac{q^n-q^i}{q^k-q^i} =
+##           \prod_{i=0}^{k-1} \frac{q^{n-i}-1}{q^{k-i}-1}.
+##  $$
+##  We have the recursion
+##  $$
+##  a(n,k+1) = a(n,k) \frac{q^{n-i}-1}{q^{i+1}-1}.
+##  $$
+##
+##  (The number of all subspaces is $\sum_{k=0}^n a(n,k)$.)
+##
+InstallMethod( Size,
+    "method for a subspaces domain",
+    [ IsSubspacesVectorSpace and IsSubspacesVectorSpaceDefaultRep ],
+    function( D )
+
+    local k,
+          n,
+          q,
+          size,
+          qn,
+          qd,
+          ank,
+          i;
+
+    if D!.dimension = "all" then
+
+      # all subspaces of the space
+      n:= Dimension( D!.structure );
+
+      q:= Size( LeftActingDomain( D!.structure ) );
+      size:= 1;
+      qn:= q^n;
+      qd:= q;
+
+      # $a(n,0)$
+      ank:= 1;
+
+      for k in [ 1 .. Int( (n-1)/2 ) ] do
+
+        # Compute $a(n,k)$.
+        ank:= ank * ( qn - 1 ) / ( qd - 1 );
+        qn:= qn / q;
+        qd:= qd * q;
+
+        size:= size + ank;
+
+      od;
+
+      size:= 2 * size;
+
+      if n mod 2 = 0 then
+
+        # Add the number of spaces of dimension $n/2$.
+        size:= size + ank * ( qn - 1 ) / ( qd - 1 );
+      fi;
+
+    else
+
+      # number of spaces of dimension 'k' only
+      n:= Dimension( D!.structure );
+      if   D!.dimension < 0 or
+           n < D!.dimension then
+        return 0;
+      elif n / 2 < D!.dimension then
+        k:= n - D!.dimension;
+      else
+        k:= D!.dimension;
+      fi;
+
+      q:= Size( LeftActingDomain( D!.structure ) );
+      size:= 1;
+
+      qn:= q^n;
+      qd:= q;
+      for i in [ 1 .. k ] do
+        size:= size * ( qn - 1 ) / ( qd - 1 );
+        qn:= qn / q;
+        qd:= qd * q;
+      od;
+
+    fi;
+
+    # Return the result.
+    return size;
+    end );
+
+
+#############################################################################
+##
+#M  Enumerator( <D> ) . . . . . . . . . . . . . . . .  for a subspaces domain
+##
+##  Use the iterator to compute the elements list.
+#T This is not allowed!
+##
+InstallMethod( Enumerator,
+    "method for a subspaces domain",
+    [ IsSubspacesVectorSpace and IsSubspacesVectorSpaceDefaultRep ],
+    function( D )
+    local iter,    # iterator for 'D'
+          elms;    # elements list, result
+
+    iter:= Iterator( D );
+    elms:= [];
+    while not IsDoneIterator( iter ) do
+      Add( elms, NextIterator( iter ) );
+    od;
+    return elms;
+    end );
+#T necessary?
+
+
+#############################################################################
+##
+#M  Iterator( <D> ) . . . . . . . . . . . . . . . . .  for a subspaces domain
+##
+##  uses the subspaces iterator for full row spaces and the mechanism of
+##  associated row spaces.
+##
+BindGlobal( "IsDoneIterator_Subspaces",
+    iter -> IsDoneIterator( iter!.associatedIterator ) );
+
+BindGlobal( "NextIterator_Subspaces", function( iter )
+    local next;
+    next:= NextIterator( iter!.associatedIterator );
+    next:= List( GeneratorsOfLeftModule( next ),
+                 x -> LinearCombination( iter!.basis, x ) );
+    return Subspace( iter!.structure, next, "basis" );
+    end );
+
+BindGlobal( "ShallowCopy_Subspaces",
+    iter -> rec( structure          := iter!.structure,
+                 basis              := iter!.basis,
+                 associatedIterator := ShallowCopy(
+                                           iter!.associatedIterator ) ) );
+
+InstallMethod( Iterator,
+    "for a subspaces domain",
+    [ IsSubspacesVectorSpace and IsSubspacesVectorSpaceDefaultRep ],
+    function( D )
+    local V;      # the vector space
+
+    V:= D!.structure;
+    return IteratorByFunctions( rec(
+               IsDoneIterator     := IsDoneIterator_Subspaces,
+               NextIterator       := NextIterator_Subspaces,
+               ShallowCopy        := ShallowCopy_Subspaces,
+               structure          := V,
+               basis              := Basis( V ),
+               associatedIterator := Iterator(
+                      Subspaces( FullRowSpace( LeftActingDomain( V ),
+                                               Dimension( V ) ),
+                                 D!.dimension ) ) ) );
+    end );
+
+
+#############################################################################
+##
+#M  Subspaces( <V>, <dim> )
+##
+InstallMethod( Subspaces,
+    "for a vector space, and an integer",
+    [ IsVectorSpace, IsInt ],
+    function( V, dim )
+    if IsFinite( V ) then
+      return Objectify( NewType( CollectionsFamily( FamilyObj( V ) ),
+                                     IsSubspacesVectorSpace
+                                 and IsSubspacesVectorSpaceDefaultRep ),
+                        rec(
+                             structure  := V,
+                             dimension  := dim
+                           )
+                      );
+    else
+      TryNextMethod();
+    fi;
+    end );
+
+
+#############################################################################
+##
+#M  Subspaces( <V> )
+##
+InstallMethod( Subspaces,
+    "for a vector space",
+    [ IsVectorSpace ],
+    function( V )
+    if IsFinite( V ) then
+      return Objectify( NewType( CollectionsFamily( FamilyObj( V ) ),
+                                     IsSubspacesVectorSpace
+                                 and IsSubspacesVectorSpaceDefaultRep ),
+                        rec(
+                             structure  := V,
+                             dimension  := "all"
+                           )
+                      );
+    else
+      TryNextMethod();
+    fi;
+    end );
+
+
+#############################################################################
+##
+#F  IsSubspace( <V>, <U> ) . . . . . . . . . . . . . . . . . check <U> <= <V>
+##
+InstallGlobalFunction( IsSubspace, function( V, U )
+    return IsVectorSpace( U ) and IsSubset( V, U );
+end );
+
+
+#############################################################################
+##
+#M  IsVectorSpaceHomomorphism( <map> )
+##
+InstallMethod( IsVectorSpaceHomomorphism,
+    [ IsGeneralMapping ],
+    function( map )
+    local S, R, F;
+    S:= Source( map );
+    if not IsVectorSpace( S ) then
+      return false;
+    fi;
+    R:= Range( map );
+    if not IsVectorSpace( R ) then
+      return false;
+    fi;
+    F:= LeftActingDomain( S );
+    return ( F = LeftActingDomain( R ) ) and IsLinearMapping( F, map );
+    end );
+
+
+#############################################################################
+##
+#E
+

samples/GLSL/SimpleLighting.gl2.frag

@@ -0,0 +1,9 @@
+static const char* SimpleFragmentShader = STRINGIFY(
+
+varying vec4 FrontColor;
+
+void main(void)
+{
+    gl_FragColor = FrontColor;
+}
+);

samples/GLSL/recurse1.frag

@@ -0,0 +1,48 @@
+#version 330 core
+
+// cross-unit recursion
+
+void main() {}
+
+// two-level recursion
+
+float cbar(int);
+
+void cfoo(float)
+{
+	cbar(2);
+}
+
+// four-level, out of order
+
+void CB();
+void CD();
+void CA() { CB(); }
+void CC() { CD(); }
+
+// high degree
+
+void CBT();
+void CDT();
+void CAT() { CBT(); CBT(); CBT(); }
+void CCT() { CDT(); CDT(); CBT(); }
+
+// not recursive
+
+void norA() {}
+void norB() { norA(); }
+void norC() { norA(); }
+void norD() { norA(); }
+void norE() { norB(); }
+void norF() { norB(); }
+void norG() { norE(); }
+void norH() { norE(); }
+void norI() { norE(); }
+
+// not recursive, but with a call leading into a cycle if ignoring direction
+
+void norcA() { }
+void norcB() { norcA(); }
+void norcC() { norcB(); }
+void norcD() { norcC(); norcB(); } // head of cycle
+void norcE() { norcD(); } // lead into cycle

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