Compare commits

...

391 Commits

Author SHA1 Message Date
Arfon Smith
3d1555e278 Merge pull request #2856 from github/cut-release-v4.7.6
Cut release v4.7.6
2016-02-29 08:24:58 -07:00
Arfon Smith
54fab9eb4e Bumping to v4.7.6 2016-02-29 07:55:43 -07:00
Arfon Smith
8fea8a0b47 Grammar update 2016-02-29 07:54:29 -07:00
Arfon Smith
f14ae8e51b Merge pull request #2803 from c-lipka/master
Added support for the POV-Ray Scene Description Language.
2016-02-28 07:33:05 -07:00
Arfon Smith
57f5a3e780 Merge pull request #2831 from FarbodSalamat-Zadeh/patch-1
Add CSV as data type to languages.yml
2016-02-27 15:54:44 -07:00
Farbod Salamat-Zadeh
3be007526c Fix fixture_blob("Data/cars.csv")
Changes `fixture_blob("Data/cars.csv")` to `sample_blob("CSV/cars.csv")`
2016-02-27 15:30:22 +00:00
Farbod Salamat-Zadeh
9bfbd0550c Move cars.csv from test/fixtures/Data to samples/CSV 2016-02-27 14:32:50 +00:00
Christoph Lipka
0301a5dcdf Merge remote-tracking branch 'upstream/master' 2016-02-27 06:24:30 +01:00
Farbod Salamat-Zadeh
db994a1197 Remove .txt extension for CSV format 2016-02-27 00:42:03 +00:00
Arfon Smith
855c13ea2a Merge pull request #2851 from edechter/master
Add .yap ext and yap interpreter for Prolog lang
2016-02-26 17:21:11 -07:00
Arfon Smith
fc816d3429 Merge pull request #2845 from kusma/uno
add support for Uno
2016-02-23 17:56:51 -07:00
Eyal Dechter
ab69fd01ac Add .yap ext and yap interpreter for Prolog lang 2016-02-22 15:59:40 -05:00
Erik Faye-Lund
cc6106f31b add sample ux-files 2016-02-22 18:45:59 +01:00
Erik Faye-Lund
ead85379ed add sample uno-files 2016-02-22 18:44:02 +01:00
Erik Faye-Lund
f8d6be55ee add .ux as an XML extension
This is used by Fusetools' UX markup:
https://www.fusetools.com/learn/fuse#hello-ux-markup
2016-02-20 14:45:31 +01:00
Arfon Smith
a241d75043 Merge pull request #2846 from Dominator008/bzl
Add .bzl extension to Python in languages.yml
2016-02-19 20:14:15 -07:00
Michael Zhou
864a6c0a20 Add .bzl extension to Python in languages.yml
.bzl is the extension for Skylark, a subset of Python that is used
to define build extensions for the Bazel build system.

Eg:
  https://github.com/bazelbuild/bazel/blob/master/tools/build_rules/closure/closure_js_binary.bzl
2016-02-19 19:11:36 -05:00
Arfon Smith
1c20c54191 Fixing ordering of makefile filenames 2016-02-19 16:55:38 -07:00
Arfon Smith
4d722d1fd1 Merge pull request #2838 from scop/makefile
Makefile: Add Makefile.am and Makefile.in filenames
2016-02-19 12:39:59 -07:00
Erik Faye-Lund
b67254e986 add support for Uno
Uno is a fast, native dialect of C#, that includes a lot of
specialized functionality for graphics programming.

https://www.fusetools.com/learn/uno
2016-02-19 18:52:12 +01:00
Arfon Smith
041cf9c94e Merge pull request #2837 from scop/shell-script
Shell: Add shell-script alias for recognizing Emacs modelines
2016-02-19 09:05:37 -07:00
Ville Skyttä
b08c5a8421 Shell: Add .sh.in extension 2016-02-19 17:56:50 +02:00
Arfon Smith
125eaa4cc3 Merge pull request #2844 from pchaigno/hacking.rst.txt
Move HACKING.rst.txt to sample directory
2016-02-19 08:44:01 -07:00
Paul Chaignon
5c4129f85b Move HACKING.rst.txt to sample directory
The file was incorrectly placed at the root of the repo
2016-02-19 08:50:01 +01:00
Ville Skyttä
17a9463588 Makefile: Add Makefile.am and Makefile.in filenames 2016-02-14 22:08:21 +02:00
Ville Skyttä
fb9f271720 Shell: Add shell-script alias for recognizing Emacs modelines 2016-02-14 22:00:16 +02:00
Arfon Smith
8de50edb41 ruby for example 2016-02-12 17:05:44 -07:00
Arfon Smith
ab33fccddd Merge pull request #2836 from github/cut-release-v4.7.5
Cut release v4.7.5
2016-02-12 16:58:11 -07:00
Arfon Smith
bd95ac0beb Bumping version 2016-02-12 16:27:29 -07:00
Arfon Smith
7b3efb185f Updating grammars 2016-02-12 16:25:05 -07:00
Farbod Salamat-Zadeh
a0065febe2 Add ace_mode and tm_scope for CSV 2016-02-06 16:34:33 +00:00
Arfon Smith
9374784651 Merge pull request #2805 from jamesqo/patch-1
Add .xproj to list of XML file extensions
2016-02-04 20:28:47 -07:00
Arfon Smith
aa6af3deed Merge pull request #2822 from AbigailBuccaneer/master
Add detection of GrammarKit-generated files
2016-02-04 20:28:12 -07:00
Arfon Smith
a19e501b44 Merge pull request #2833 from pchaigno/less-new-grammar
New grammar for Less
2016-02-03 08:45:08 -07:00
Paul Chaignon
889a395340 Grammar for Less from Atom package 2016-02-03 14:22:23 +01:00
Paul Chaignon
eb8eb28ca7 Remove Less grammar 2016-02-03 14:19:58 +01:00
Arfon Smith
697b3351e6 Merge pull request #2832 from github/better-perl6
Adding Perl6-specific grammar.
2016-02-02 22:43:12 -07:00
Arfon Smith
9fd80bfd67 Updating to latest perl6 grammar 2016-02-02 22:38:50 -07:00
Arfon Smith
7b58b1ea59 Adding Perl6-specific grammar. 2016-02-02 19:37:35 -07:00
Farbod Salamat-Zadeh
c454396c26 Add CSV as data type to languages.xml
Adds the .csv extension (and also .txt extension) so that this file type is shown when searching on GitHub.
2016-02-02 19:41:05 +00:00
Arfon Smith
c46900396a Merge pull request #2827 from pchaigno/yang
Support for the YANG modeling language
2016-01-31 18:33:07 -06:00
Paul Chaignon
b235ed1223 Grammar for YANG from Atom package 2016-01-31 10:31:06 +01:00
Paul Chaignon
16d9612603 Support for YANG language 2016-01-31 10:29:06 +01:00
Abigail
721e5b4656 Add detection of GrammarKit-generated files
GrammarKit is a plugin by JetBrains for creating custom language plugins
for JetBrains IDEs (such as IntelliJ, RubyMine, CLion and more). It
defines a BNF parser language which can be used to generate a parser in
Java, and it also integrates JFLex for generating a lexer in Java.

Both of these generated Java files can be recognised by a comment on the
first line of the file, and so classifying them as generated is trivial.
2016-01-28 11:47:33 +00:00
Arfon Smith
9961f8bc1c Merge pull request #2797 from lpil/erlang-leex-yecc
support for leex (.xrl) / yecc (.yrl) files
2016-01-23 11:36:43 -05:00
Arfon Smith
c066867d59 Merge pull request #2812 from chrisarcand/improved-vim-modeline-detection
Improved vim modeline detection
2016-01-21 20:12:26 -05:00
Arfon Smith
21093165e1 Merge pull request #2613 from ismailarilik/patch-2
Add colors for some languages.
2016-01-21 20:10:36 -05:00
James Ko
df88de14e3 Add .xproj to list of XML extensions 2016-01-20 19:01:19 -05:00
Arfon Smith
94de431aa5 Merge pull request #2811 from pchaigno/pod-heuristic
Heuristic for Pod vs. Perl
2016-01-18 07:59:47 -05:00
Arfon Smith
502557a97f Merge pull request #2808 from pchaigno/submodules-ssh
HTTPS links for submodules
2016-01-17 16:14:55 -05:00
Paul Chaignon
52938f6dbf Test submodules are using HTTPS links 2016-01-17 18:14:51 +01:00
chrisarcand
d87fad649c Improved vim modeline detection
TLDR: This greatly increases the flexibility of vim modeline detection
to manually set the language of a file.

In vim there are two forms of modelines:

[text]{white}{vi:|vim:|ex:}[white]{options}
examples: 'vim: syntax=perl', 'ex: filetype=ruby'

-and-

[text]{white}{vi:|vim:|Vim:|ex:}[white]se[t] {options}:[text]
examples: 'vim set syntax=perl:', 'Vim: se ft=ruby:'

As you can see, there are many combinations. These changes should allow
most combinations to be used. The two most important additions are the
use of the keyword 'syntax', as well as the addition of the first form
(you now no longer need to use the keyword 'set' with a colon at the end).
The use of first form with 'syntax' is very, very common across GitHub:

https://github.com/search?l=ruby&q=vim%3A+syntax%3D&ref=searchresults&type=Code&utf8=%E2%9C%93
2016-01-16 08:57:20 -05:00
Paul Chaignon
d8666e5309 Heuristic for Pod vs. Perl
.pod files classified as Pod if they contain any Pod syntax
2016-01-16 11:21:26 +01:00
Arfon Smith
0c071990cb Merge pull request #2809 from github/cut-release-v4.7.4
v4.7.4 release
2016-01-15 10:34:50 -05:00
Arfon Smith
77dfb19a50 Bumping to v4.7.4 2016-01-15 09:21:43 -05:00
Arfon Smith
49254f1f74 Grammar update 2016-01-15 09:19:24 -05:00
Arfon Smith
9dd952c175 Merge pull request #2807 from mrmonday/patch-1
Support .rs.in as a file extension for Rust files.
2016-01-15 09:11:36 -05:00
Robert Clipsham
0b9897db1f Support .rs.in as a file extension for Rust files.
When using syntax extensions in stable or beta Rust channels using the syntex package, it is common to use the file extension .rs.in for the source file, and .rs for the generated file.
2016-01-11 19:15:01 +00:00
Christoph Lipka
9d11128362 Updated POV-Ray SDL grammar sub-project 2016-01-10 21:24:02 +01:00
Christoph Lipka
ee17ab3e26 Empty commit to trigger re-run of build checks. 2016-01-10 21:14:17 +01:00
Christoph Lipka
06af36dac2 Fixed POV-Ray SDL entry in grammars.yml and Ace mode in languages.yml 2016-01-10 20:23:09 +01:00
Christoph Lipka
51d6d741e5 Fixed ordering of POV-Ray SDL in languages.yml 2016-01-10 20:11:26 +01:00
Christoph Lipka
b593a8ae67 Added more samples for the POV-Ray Scene Description Language 2016-01-10 18:40:29 +01:00
Christoph Lipka
7b30240a7f Added POV-Ray Scene Description Language 2016-01-10 13:05:41 +01:00
Paul Chaignon
71f124faa5 HTTPS links for submodules
When cloning the repository with all its submodules,
users without an SSH key registered will fail to clone
submodules with an SSH link
2016-01-10 10:10:41 +01:00
Arfon Smith
470bd34349 Merge pull request #2800 from github/2794-local
[UPDATED] Switch to a different (and better) grammar for Inform 7 source code
2016-01-07 16:37:28 -05:00
Arfon Smith
65087dd7b8 Merge branch 'master' into 2794-local 2016-01-07 16:28:54 -05:00
Arfon Smith
89c5361f25 Merge pull request #2772 from ibnfirnas/fix-copypasta-artifact
Remove copypasta artifact.
2016-01-07 16:26:10 -05:00
Arfon Smith
f82cc26e4f Merge pull request #2778 from pchaigno/wiki
New extensions for consistency with Markup
2016-01-07 16:25:47 -05:00
Louis Pilfold
15232fc072 Add the LFE lexer as an example of erlang .xrl 2016-01-04 12:17:31 +00:00
Louis Pilfold
0a7aab947c Add the Elixir parser as an example of erlang .yrl 2016-01-04 12:16:32 +00:00
Louis Pilfold
5906fa81bb support for Erlang leex (.xrl) / yecc (.yrl) files 2016-01-04 11:12:39 +00:00
Arfon Smith
1b2f574af2 Merge pull request #2782 from pchaigno/perl-heuristic-order
Reorder Perl heuristic rules
2016-01-03 07:44:54 -05:00
Paul Chaignon
ca4bc6110f Remove 'use strict' from Perl6 sample 2016-01-03 11:47:09 +01:00
Arfon Smith
a944769d61 Grammars update 2016-01-02 22:18:27 -05:00
Arfon Smith
98a31515ef Merge pull request #2796 from github/2703-local
MagicPython
2016-01-02 22:09:52 -05:00
Arfon Smith
3e665099ac Updating Python grammars 2016-01-02 22:04:16 -05:00
Arfon Smith
5400b534e4 Merge branch 'master' into 2703-local 2016-01-02 21:38:37 -05:00
Arfon Smith
6f2d4dc195 Merge pull request #2788 from nwolverson/update-purescript-submodule
Update PureScript submodule (moved repo, grammar tweak)
2016-01-02 21:33:21 -05:00
Arfon Smith
4f7fac3ba1 Merge pull request #2783 from jrnold/add-stan-extension
Add stan extension
2016-01-02 21:32:14 -05:00
Arfon Smith
fd6569830a Merge pull request #2792 from aqnouch/patch-1
Updated copyright to 2016
2016-01-02 21:23:52 -05:00
Andrew Plotkin
5d4cad6394 Remove the old submodule entry. 2016-01-01 22:40:23 -05:00
Andrew Plotkin
b790a49282 Remove the old Sublime-Inform grammar from the submodules list. 2016-01-01 22:25:11 -05:00
Andrew Plotkin
537b83c759 Switch from Sublime-Inform grammar to language-inform7 grammar
for Inform 7 source code.
2016-01-01 22:23:01 -05:00
Andrew Plotkin
c0b9e2c3f4 Update comment. 2016-01-01 21:52:51 -05:00
Andrew Plotkin
f488b9b9f7 Test strings and substs in a doc comment. 2016-01-01 17:22:06 -05:00
Andrew Plotkin
7060b116f4 Reword a little. 2016-01-01 16:54:55 -05:00
Andrew Plotkin
0f4cf11294 Wrong semicolon. 2016-01-01 16:34:23 -05:00
Andrew Plotkin
048496723b Include lots more forms of Inform7 syntax. Including embedded Inform6
syntax.
2016-01-01 16:15:03 -05:00
AQNOUCH Mohammed
70068f74f1 Updated copyright to 2016 2016-01-01 01:53:09 +00:00
Nicholas Wolverson
6f197bacc7 Update PureScript submodule (moved repo, grammar tweak)
Updated grammar to support triple-quoted strings properly:
0c53f8162e

atom-language-purescript repo has been moved to purescript-contrib org,
update the URL.
2015-12-29 23:22:53 +00:00
jrnold
24a89d2d75 add tm_grammar for Stan 2015-12-28 22:32:53 -08:00
jrnold
1ac16cbec7 add vendor for Stan 2015-12-28 22:31:49 -08:00
jrnold
8144438f39 Add color for Stan
Use the brick-red color of the [Stan logo](https://raw.githubusercontent.com/stan-dev/logos/master/logo.png).
2015-12-27 18:50:43 -08:00
jrnold
f141abbc73 add tm_scope for Stan 2015-12-24 16:05:06 -08:00
jrnold
5329b96793 add Stan samples 2015-12-24 15:55:14 -08:00
jrnold
7a70931066 add Stan to languages 2015-12-24 15:55:00 -08:00
Paul Chaignon
9a070d7bb3 Reorder Perl heuristic rules
Order heuristic rules by accuracy
Heuristic rules which are expected to generated
less false positives should be tested first
2015-12-23 21:43:55 +01:00
Paul Chaignon
189b2d684b .rst.txt and .rest.txt as reStructuredText extensions 2015-12-20 16:21:11 +01:00
Paul Chaignon
71dfac26fe .wiki extension as Mediawiki 2015-12-20 13:09:00 +01:00
Arfon Smith
efdc790374 Merge pull request #2776 from humzashah/minor-code-improvements
minor code improvements
2015-12-18 11:50:25 -05:00
Syed Humza Shah
a3613dc438 fixed a typo 2015-12-18 01:43:01 +00:00
Syed Humza Shah
97afedd861 removed usage of keyword as variable
this was done mainly to fix annoying syntax highlighting
2015-12-18 01:27:58 +00:00
Syed Humza Shah
00a436f175 used proper 'if/elsif/end' syntax 2015-12-18 01:24:05 +00:00
Siraaj Khandkar
aa2e3000cd Remove copypasta artifact. 2015-12-16 14:00:48 -05:00
Arfon Smith
10e0fa4360 Merge pull request #2771 from ibnfirnas/add-mathematica-test-file-extension
Add mathematica unit test file extension
2015-12-15 19:48:05 -05:00
Siraaj Khandkar
0473af368f Add sample Mathematica test files. 2015-12-15 13:37:55 -05:00
Siraaj Khandkar
b82f563c38 Add Mathematica test file extension: .mt 2015-12-15 13:33:03 -05:00
Arfon Smith
344297895b Merge pull request #2768 from williamd1k0/master
Add Ren'Py language and grammars
2015-12-14 09:41:45 -05:00
William Claude Tumeo
d3c525645b Fix sample folder name and language order 2015-12-13 15:58:14 -02:00
William Claude Tumeo
59d02e5138 Add language-renpy submodule 2015-12-13 00:20:25 -02:00
William Claude Tumeo
8522dc1d33 Add Ren'Py language and grammars 2015-12-13 00:16:09 -02:00
Vicent Marti
53d238f310 Merge pull request #2766 from github/piki/clear-cache
Catch `ENOENT` in `clear_cache`
2015-12-10 09:08:40 +01:00
Patrick Reynolds
92ed2d189e Catch ENOENT in clear_cache
There's no need for `clear_cache` to fail if the cache doesn't exist,
either because we call `clear_cache` twice or because no cache was
previously written on this particular repo.
2015-12-09 23:24:32 -06:00
Arfon Smith
7133c3b11a Merge pull request #2765 from github/cut-release-v4.7.3
Bumping version to v4.7.3
2015-12-08 23:17:35 -05:00
Arfon Smith
d72114083b Bumping version to v4.7.3 2015-12-08 22:30:17 -05:00
Arfon Smith
683925fcd5 Updating grammars 2015-12-08 22:28:46 -05:00
Arfon Smith
1c8bf32d35 Merge pull request #2759 from pchaigno/click
Support for the Click modular router language
2015-12-08 16:08:55 -05:00
Paul Chaignon
28913833f4 Merge branch 'master' into click 2015-12-08 22:00:49 +01:00
Arfon Smith
c6752be546 Merge pull request #2749 from Alhadis/maxscript
Add language support for MAXScript
2015-12-08 08:04:13 -05:00
Arfon Smith
395e474cad Merge pull request #2763 from github/2746-local
Jupyter notebook, version 2
2015-12-08 07:45:57 -05:00
Arfon Smith
16ea189aa6 Colour switch 2015-12-08 07:39:43 -05:00
marcelo-ramires
ac81fc5da9 Changing Jupyter Notebook color to a further darker shade to make it even more different from Mask's one 2015-12-07 14:12:18 -02:00
marcelo-ramires
58191c10b3 Changing Jupyter Notebook color to make it more different from Mask's one 2015-12-07 14:00:18 -02:00
marcelo-ramires
c2ca23d580 Removing extra leading space 2015-12-05 19:38:02 -02:00
marcelo-ramires
b5dfb40c7d Setting Jupyter Notebook's language property tm_scope to source.json 2015-12-05 18:57:40 -02:00
marcelo-ramires
7e647fd915 Renaming the sample folder to match Jupyter Notebook's, making the language type markup, and adding a real sample file instead of a dummy one 2015-12-05 18:48:17 -02:00
Paul Chaignon
5b9f9bc0e6 Grammar for Click from Atom package 2015-12-05 14:03:02 +01:00
Paul Chaignon
b1c057fa30 Support for the Click router config language 2015-12-05 13:58:14 +01:00
marcelo-ramires
ca348dd373 Moving .ipynb extension from python language to a new language called Jupyter Notebook 2015-12-05 03:25:38 -02:00
Arfon Smith
b802045c5c Grammar updates 2015-12-03 17:27:17 -06:00
Arfon Smith
3c244a9501 Merge pull request #2758 from github/2667-local
Add Ur/Web support
2015-12-03 16:03:12 -06:00
Arfon Smith
832a7b9b06 Merge branch 'master' into 2667-local 2015-12-03 15:41:25 -06:00
Arfon Smith
e7d856345f Merge pull request #2757 from scottclowe/octave-alias
Add octave as an alias for Matlab syntax
2015-12-03 15:35:55 -06:00
Scott Lowe
ac559effaa Add octave as an alias for Matlab syntax
Since Octave is a clone of Matlab, the syntax is exactly the same
and hence it is desirable for highlighting to be exactly the same
as well.
Adding octave as an alias for Matlab will trivially provide support
for highlighting Octave code, and will ensure the two languages
always use the same syntax highlighting rules.
2015-12-03 21:00:21 +00:00
Arfon Smith
95d0daba80 Merge pull request #2755 from github/add-elixir-interpreter
Adding elixir as an interpreter
2015-12-02 16:23:14 -06:00
Arfon Smith
a0ad1523a1 Adding elixir as an interpreter 2015-12-02 14:52:29 -06:00
Alhadis
06c049b8c0 Change ".ms" heuristic to accommodate MAXScript
Linguist currently uses the presence of "move" commands to differentiate
a GAS file from Groff. This is problematic with MAXScript, with includes
a built-in function of that name. Furthermore, because of the language's
exhaustive vocabulary, case insensitive nature and flexible syntax, it's
difficult to impose rigid criteria on classifying it.

This commit modifies the heuristic to assume the following flow:

    1. If a line contains ".include" or ".global"/".globl" which doesn't
       follow a non-whitespace character, assume GAS.

    2. Otherwise, if the line starts with a command like ".LG7E0" with a
       possible string of whitespace before it, assume it's also GAS.

       UNLESS either of the following conditions are true:
       2a. The token is enclosed by a string or /* multiline comment */
       2b. The previous line ends with a backslash to denote a statement
           broken between lines, with possible whitespace and/or comment
           sequences between the backslash and the actual newline.

    3. If neither of the above are met, assume the file is MAXScript.

This approach may appear overly-inclusive, but given real-world usage of
MAXScript includes writing brief files with few distinguishing keywords,
it's reasonable to permit this leniency.
2015-11-28 04:40:29 +11:00
marcelo-ramires
24c7380765 Adding .ipynb (Jupyter Notebook) extension to python, and a sample file 2015-11-26 02:55:39 -02:00
Alhadis
73ef1bf156 Update MAXScript submodule to version v1.0
This is the first "real" version of the language package, which I pushed
to Atom's packages repository earlier before.
2015-11-26 05:58:10 +11:00
Arfon Smith
c8b30a62f9 Merge pull request #2741 from github/cut-release-v4.7.2
Cut release v4.7.2
2015-11-23 15:24:29 -06:00
Arfon Smith
48dfdd2dfe Bumping version to v4.7.2 2015-11-23 14:04:48 -06:00
Arfon Smith
68727f724a Grammars update 2015-11-23 13:53:53 -06:00
Alhadis
f46e053633 Darken MAXScript's language colour
Rake's tests are failing because #0AA is too similar to the colour being
used by another language (Dart: #00B4AB). This commit increases contrast
enough to satisfy the build (with 00A6A6 being the closest shade allowed
by the current colour threshold).

See also: github/linguist@3c96f9e
2015-11-23 19:04:09 +11:00
Alhadis
d2e739ba8c Update MAXScript submodule to include license file
See also: Alhadis/language-maxscript@96dbacf5b
2015-11-23 19:02:50 +11:00
Alhadis
37174e1d2c Include MAXScript submodule in grammars directory 2015-11-23 17:34:43 +11:00
Alhadis
cdb5206def Define MAXScript's language traits
The colour chosen to represent the language is taken from Autodesk's own
colouring scheme, which should easily be recognised by their userbase.
2015-11-23 17:14:35 +11:00
Alhadis
d636eaf1e3 Add example MAXScript files from Autodesk reference 2015-11-23 17:12:18 +11:00
Arfon Smith
49f3eb1286 Merge pull request #2736 from ppwwyyxx/patch-1
add jquery.fancybox.css to vendor list
2015-11-22 21:16:45 -06:00
Yuxin Wu
8ab94a8643 Use one line for jquery fancybox in vendor
(just another commit to pass CLA check
2015-11-21 21:55:08 -05:00
Yuxin Wu
f72c337c5b add jquery.fancybox.css to vendor list
fancybox has both js and css
2015-11-21 21:48:03 -05:00
Arfon Smith
d22321de07 Merge pull request #2733 from github/cake
.cake
2015-11-19 20:34:36 -06:00
Arfon Smith
473e5db51f Adding sample for Coffeescript too 2015-11-19 20:24:23 -06:00
Arfon Smith
8b9fc4683a Merge branch 'master' into cake 2015-11-19 20:19:08 -06:00
Arfon Smith
3b4415cc3c Merge pull request #2729 from larsbrinkhoff/fortran
Recognise END statement in FORTRAN files.
2015-11-19 20:07:10 -06:00
Arfon Smith
2afce1754a Merge pull request #2731 from soc/patch-1
Change Scala language color to Scala language's main color
2015-11-19 20:06:22 -06:00
Arfon Smith
f232b93214 Merge pull request #2728 from larsbrinkhoff/fs
Add new .eam.fs sample for Formatted.
2015-11-19 20:05:45 -06:00
soc
db64f192fa Change Scala language color to Scala language's main color 2015-11-19 15:25:55 +01:00
Lars Brinkhoff
ca96ecdc55 Recognise END statement in FORTRAN files. 2015-11-19 08:51:13 +01:00
Lars Brinkhoff
2a06d1aa19 Add new sample for Formatted.
Sample from qingguang/lammps-sph; GPL v2 license.
2015-11-19 07:59:31 +01:00
Arfon Smith
b2fa2a1f46 Merge pull request #2655 from iblech/pickle
Detect Pickle data dumps (.p, .pkl, .pickle)
2015-11-16 17:57:53 -06:00
Ingo Blechschmidt
6839516b5c Only classify .pkl files as Pickle data dumps
It seems to be the dominant extension at the moment, even though several
Python resources use `.p` or `.pickle`. This was discussed in #2655.
2015-11-17 00:05:22 +01:00
Arfon Smith
7247c80fac Merge pull request #2722 from github/cut-release-v4.7.1
Cut release v4.7.1
2015-11-12 19:51:41 -06:00
Arfon Smith
01d05d1d4e Bumping to v4.7.1 2015-11-12 18:43:16 -06:00
Arfon Smith
8db4cc482e Grammar update 2015-11-12 18:42:24 -06:00
Arfon Smith
074f17ed98 Merge pull request #2712 from matiasinsaurralde/master
Support for JSCAD files
2015-11-12 18:18:52 -06:00
Arfon Smith
68b553ea55 Updating grammars 2015-11-10 09:57:04 +00:00
Arfon Smith
fd5da9cb15 Merge pull request #2690 from github/licensee-6
Upgrade to licensee 6
2015-11-10 09:41:09 +00:00
Arfon Smith
d081f687b0 Merge branch 'master' into licensee-6 2015-11-10 09:34:39 +00:00
Arfon Smith
34abe5b983 Merge pull request #2717 from meatballhat/supercollider-grammar
Add SuperCollider grammar
2015-11-10 09:31:24 +00:00
Arfon Smith
5765f1faf1 Merge pull request #2718 from meatballhat/travis-apt-update
Fetch libicu via Travis, switch back to container-based
2015-11-10 09:30:04 +00:00
Dan Buch
550b67215c Fetch libicu via Travis, switch back to container-based
This is a test.  I don't understand the details of how the `bundle config
build.charlock_holmes` bit works/fails, so the intent here is to get a PR posted
for purposes of getting feedback via the full Travis machinery.
2015-11-08 06:41:22 -05:00
Dan Buch
d7b2826113 Add SuperCollider grammar
plus a few minor language support updates including:

- recognize `sclang` and `scsynth` interpreters
- set `tm_scope: source.supercollider`
- reorder extensions so that `.sc` is primary
2015-11-08 06:28:14 -05:00
Arfon Smith
b4f94c7c25 Merge pull request #2706 from redroot/add-csl-as-xml-support
adding csl as an extension for XML, included sample
2015-11-05 09:07:49 -08:00
Arfon Smith
d24677adbb Merge pull request #2716 from github/faster-string-tokenizer
Use negative lookbehind when tokenizing string literals
2015-11-05 08:40:34 -08:00
Arfon Smith
04f981eeac Merge pull request #2714 from github/aroben-patch-1
Remove mentions of treatment of vendored files in diffs
2015-11-05 08:14:26 -08:00
Arfon Smith
b53d84d8ff Merge pull request #2600 from manveru/pony-language
Add Pony language
2015-11-05 08:08:38 -08:00
Adam Roben
fea8bb21a0 Use negative lookbehind when tokenizing string literals
This can double the speed of tokenizing large RTF files that use \'hh
escape sequences.
2015-11-05 10:18:44 -05:00
Adam Roben
996ed8a8b1 Remove mentions of treatment of vendored files in diffs
Vendored files are treated just like any other files when diffing on github.com.
2015-11-04 13:26:24 -05:00
Matias Insaurralde
daef164163 adding jscad sample file 2015-11-03 00:24:15 -03:00
Matias Insaurralde
61a5cab1f2 adding extension for OpenJSCAD 2015-11-03 00:03:00 -03:00
Redth
2fddaaf3d7 Reordered extensions so the primary .cs is first 2015-10-31 12:45:54 -04:00
Redth
741d246581 Add .cake extension for C#
This adds the .cake file extension to the C# language.

Here is a search in the wild: https://github.com/search?q=extension%3Acake+NOT+coffee&type=Code

Cake (C# Make) is a cross platform build automation system with a C# DSL to do things like compiling code, copy files/folders, running unit tests, compress files and build NuGet packages.

You can find out out more about cake here: http://cakebuild.net/
2015-10-30 15:06:38 -04:00
redroot
1b23e81541 adding csl as an extension for XML, included sample 2015-10-30 10:40:15 +00:00
Arfon Smith
362d300cb0 Blob not FileBlob 2015-10-26 09:06:42 +00:00
Dario Bertini
7b185cc2f3 Switch to MagicPython for Python sources 2015-10-23 20:49:05 +01:00
Arfon Smith
932726863f Merge branch 'master' into licensee-6 2015-10-23 10:29:47 +01:00
Arfon Smith
a35a3e98ce Merge pull request #2702 from github/drop-ruby-1.9.3
Dropping support for Ruby 1.9.3
2015-10-23 10:29:13 +01:00
Arfon Smith
7c404e72d2 Dropping support for Ruby 1.9.3 2015-10-23 10:20:31 +01:00
Arfon Smith
8736e2305d Merge pull request #2700 from pchaigno/django-alias
Django as an alias for HTML+Django
2015-10-22 20:39:14 +01:00
Paul Chaignon
a13664698f Django as an alias for HTML+Django 2015-10-22 20:28:40 +02:00
Arfon Smith
6e934067a8 Merge pull request #2698 from phase/master
Change D color to match the website
2015-10-22 09:26:31 +01:00
phase
3040642f97 Change D color to its logo 2015-10-21 16:42:43 -07:00
phase
dd7e44f957 Change D color to match the website
The original yellow color doesn't fit D very well, and it looks an awful lot like the color for JavaScript. This changes it to the color used on the website's sidebar, and nice dark maroon: http://www.colorpicker.com/2e2324
2015-10-21 15:34:25 -07:00
Arfon Smith
6b56a243e7 Merge pull request #2696 from github/cut-linguist-4.7.0
Bumping to version 4.7.0
2015-10-21 10:19:16 +01:00
Arfon Smith
5d08605aef Bumping to version 4.7.0 2015-10-21 09:04:17 +01:00
Arfon Smith
bf705cbaf2 Grammars update 2015-10-21 09:02:56 +01:00
Arfon Smith
fe827896e0 Merge pull request #2681 from miek/kicad-brd-extension
Add .brd extension for KiCad
2015-10-21 08:55:05 +01:00
Arfon Smith
317219e479 Merge branch 'master' into licensee-6 2015-10-21 08:51:10 +01:00
Arfon Smith
64e7df7596 Merge pull request #2694 from github/memory_blob
Memory blob
2015-10-21 08:49:42 +01:00
Arfon Smith
b3ff84872b Merge branch 'master' into memory_blob 2015-10-20 19:24:43 +01:00
Arfon Smith
5d176a781c Fixing the build :-\ 2015-10-20 19:24:04 +01:00
Arfon Smith
e0c97f97ba Merge branch 'master' into memory_blob 2015-10-20 12:36:26 +01:00
Arfon Smith
83f358976e Fixing up some old MemoryBlob references 2015-10-20 12:33:43 +01:00
Arfon Smith
9ee6153891 Merge pull request #2676 from lucky/master
Support for files generated by Racc.
2015-10-19 12:05:12 +01:00
Arfon Smith
825e640061 Merge pull request #2684 from jeffkreeftmeijer/eex
Add EEx (Embedded Elixir)
2015-10-19 12:02:18 +01:00
Arfon Smith
e5ae213839 Merge pull request #2689 from edendramis/master
Add FreeMarker syntax highlighting
2015-10-19 12:00:38 +01:00
Arfon Smith
74e034c689 Merge pull request #2686 from pchaigno/metal
Support for Metal language
2015-10-19 11:49:36 +01:00
Evangelia Dendramis
a55a60a161 removing group and search term 2015-10-16 18:19:53 -07:00
Brandon Keepers
9d865ec018 license of factor grammar is now detected properly 2015-10-16 15:16:04 -04:00
Brandon Keepers
8b01e3dead Upgrade to licensee 6.0.0b1 2015-10-16 15:15:34 -04:00
edendramis
9e3cc01715 adding FreeMarker to grammars.yml 2015-10-16 09:54:17 -07:00
edendramis
0f204767a9 updating examples 2015-10-15 14:48:20 -07:00
edendramis
11e3251efd adding samples 2015-10-15 14:43:02 -07:00
edendramis
1f1416a5f7 adding freemarker grammar 2015-10-15 14:15:27 -07:00
edendramis
b3786f3825 Merge remote-tracking branch 'upstream/master' 2015-10-15 14:07:13 -07:00
Paul Chaignon
09c2eee91e Support for Metal language 2015-10-13 07:57:58 +02:00
Arfon Smith
dc78b14902 Merge pull request #2683 from hipikat/patch-1
Correct typo ("Any information you [c]an add")
2015-10-12 10:09:17 +01:00
Arfon Smith
500ce0959a Merge branch 'master' into memory_blob 2015-10-12 09:49:22 +01:00
Adam Wright
aa0c9e3572 Correct typo ("Any information you [c]an add") 2015-10-12 14:40:18 +08:00
Mike Walters
e6de75d48a Add .brd extension for KiCad 2015-10-11 23:50:29 +01:00
Arfon Smith
a5ad0a34f8 Merge pull request #2675 from fbonzon/master
Add .phps extension for PHP
2015-10-11 21:32:17 +01:00
Arfon Smith
6e609cc4e3 Merge pull request #2680 from k2b6s9j/patch-1
The Crystal Grammar repository has moved.
2015-10-11 21:31:55 +01:00
Kepler Sticka-Jones
27727a927f The Crystal Grammar repository has moved.
And I'm kinda thinking about changing my GitHub name...
2015-10-10 23:49:07 -06:00
Jared Kuolt
5ff580df0a Support for files generated by Racc.
This changeset includes a sample racc file from [this auto-generated
file](44e9bf0440/lib/rjson/parser.rb)
(MIT-licensed).

[Racc](https://github.com/tenderlove/racc) Racc is an LALR(1) parser
generator. It is written in Ruby itself, and generates ruby programs.
2015-10-09 16:20:59 -07:00
Jeff Kreeftmeijer
b34acac722 Add EEx (Embedded Elixir)
EEx is embedded Elixir: http://elixir-lang.org/docs/v1.0/eex/. Here's
some in-the-wild usage on Github: https://github.com/search?p=100&q=extension%3Aeex+NOT+nothack&ref=searchresults&type=Code&utf8=✓

This uses the "html_elixir" Ace mode, which was added in this pull
request on the Ace project: https://github.com/ajaxorg/ace/pull/2696
2015-10-10 00:20:38 +02:00
François B
37840856ed Add .phps extension for PHP
.phps stands for "PHP Source"

Useful to show examples of PHP code. A properly-configured server will
output a .phps file as is, with color-formated source code instead of
the HTML that would normally be generated.

Usage in GitHub:
https://github.com/search?utf8=%E2%9C%93&q=extension%3Aphps+NOT+nothack&
type=Code

Example taken from:
https://github.com/PHPMailer/PHPMailer/blob/master/examples/mail.phps
2015-10-09 14:43:22 +02:00
Brandon Keepers
acfad4371f Mention alphabetical order in contributing docs
Closes #2649
2015-10-07 19:41:37 -04:00
Arfon Smith
ae42cc0307 Merge pull request #2672 from github/cut-release-v4.6.4
Cut release v4.6.4
2015-10-05 11:15:35 +01:00
Arfon Smith
d06860df37 Bumping version to v4.6.4 2015-10-05 09:45:32 +01:00
Arfon Smith
7d5d162f6b Updating FSharp grammars to match 2015-10-05 09:45:05 +01:00
Arfon Smith
d39a75b68b Grammar updates 2015-10-05 09:41:56 +01:00
Arfon Smith
d72f7311f6 Merge pull request #2648 from jaredpetersen/master
Added .pck PLSQL file extension
2015-10-05 09:23:56 +01:00
Arfon Smith
3f81b7c179 Merge pull request #2640 from wizawu/master
Add new extension .tsx for TypeScript
2015-10-05 09:21:46 +01:00
Arfon Smith
33d1255a5a Merge pull request #2671 from pchaigno/change-stata-grammar-repo
Change Stata grammar repo
2015-10-05 09:15:15 +01:00
Paul Chaignon
0ebea6a0ff Use pschumm/Stata.tmbundle 2015-10-04 20:45:33 +02:00
Paul Chaignon
c28da3a4a9 Remove statatmbundle/Stata.tmbundle grammar 2015-10-04 20:42:29 +02:00
Julian Squires
538f479b60 Add sample Ur/Web files
Taken from tokenrove/parsur so I don't have to worry about license
hassles.  (You may relicense these samples as necessary.)

It would be nice to have an example of the embedded SQL syntax in a
sample.
2015-10-03 08:28:44 -04:00
Julian Squires
88cc73fa49 Add language definition for Ur/Web
I have omitted the related .urp extension because these are small
files (projects) in a different syntax.
2015-10-03 08:28:44 -04:00
wizawu
d6d368a65d Replace the sample file for .tsx extension
The sample file is from https://github.com/Microsoft/TypeScript/blob/master/tests/cases/conformance/jsx/tsxAttributeResolution9.tsx
2015-10-03 11:01:22 +08:00
wizawu
c5be9cc3e9 Add .tsx extension for XML
The sample file is from https://github.com/nyxcharon/tiled/blob/master/src/examples/water.tsx
2015-10-02 19:50:10 +08:00
E
c462c2bd31 add FreeMarker to languages.yml 2015-10-01 13:59:52 -07:00
wizawu
3426165621 Add a TypeScript sample with .tsx extension 2015-09-30 13:45:38 +08:00
Vicent Marti
98b99e38bb Merge pull request #2654 from github/vmg/git-linguist-fixes
Small fixes for git-linguist
2015-09-28 11:12:49 +02:00
Vicent Marti
d8e3bec499 Bump version 2015-09-28 01:45:49 -07:00
Vicent Marti
7c759d4d29 git-linguist: Do not write cache if repo is gone 2015-09-28 01:45:49 -07:00
Vicent Marti
41d438b47e repository: Do not attempt to scan large repos 2015-09-28 01:45:49 -07:00
Vicent Marti
41911d6921 git-linguist: Properly handle $GIT_DIR from git 2015-09-28 01:45:49 -07:00
Arfon Smith
dca18d77cb Merge pull request #2656 from iblech/better-test-description
Clarified that only nonprimary extensions should be sorted
2015-09-27 20:34:30 +01:00
Ingo Blechschmidt
040af5dad2 Clarify that only nonprimary extensions should be sorted 2015-09-25 19:23:06 +02:00
Ingo Blechschmidt
01bb6c37ab Detect Pickle data dumps (.p, .pkl, .pickle) 2015-09-25 19:06:50 +02:00
Jared Petersen
c624d68628 Added .pck PLSQL file extension 2015-09-24 07:59:06 -07:00
Arfon Smith
4867c49bd9 Merge pull request #2642 from github/license-in-gemspec
Include LICENSE in gem
2015-09-23 09:19:18 +01:00
Brandon Keepers
a354eddf4b Update github-linguist.gemspec 2015-09-22 16:33:08 -04:00
Vicent Marti
9b78c533a5 Merge pull request #2641 from github/js-syntax-fix
github-linguist-grammars 4.6.2
2015-09-21 21:56:33 +02:00
Mislav Marohnić
090ea576b9 github-linguist-grammars 4.6.2 2015-09-21 21:23:40 +02:00
Mislav Marohnić
6a2d33a4b3 Bump language-javascript for syntax highlighting fix
This is primarily to pull
https://github.com/atom/language-javascript/pull/227

Full changelog:
c5c381e...7b14bbb (diff-46d5c1ca71eaebb92619d6c7abc9388d)
2015-09-21 19:04:30 +02:00
wizawu
b54a9c7412 Add new extension .tsx for TypeScript
TypeScript 1.6 has introduced a new .tsx file extension.
2015-09-21 13:48:30 +08:00
Vicent Marti
2c62da7834 Merge pull request #2636 from github/vmg/git-linguist-oid
git-linguist: Delay loading @commit_oid
2015-09-16 16:48:12 +02:00
Vicent Marti
0145a0adb2 git-linguist: Delay loading @commit_oid 2015-09-16 05:50:35 -07:00
Vicent Marti
473282d64c Merge pull request #2630 from github/vmg/memory
4.6.0: Reduce memory pressure
2015-09-15 11:19:45 +02:00
Vicent Marti
c2c068e9db Bump version to 4.6.0 2015-09-14 08:43:10 -07:00
Vicent Marti
13d1f662d1 Add the git-linguist helper 2015-09-14 08:42:51 -07:00
Arfon Smith
bdd57f58a0 Merge pull request #2625 from github/handlebars-group
Adding Handlebars to the HTML group
2015-09-09 09:18:11 +01:00
Arfon Smith
b1bcabd6e6 Adding Handlebars to the HTML group 2015-09-08 12:25:05 +01:00
Arfon Smith
e128c3fa82 Merge pull request #2622 from miksen/patch-1
Language bar clarification in README.md
2015-09-08 12:08:42 +01:00
Arfon Smith
efac9fe750 Merge pull request #2624 from pchaigno/jsx-grammar
New JSX language under JavaScript group
2015-09-08 11:01:44 +01:00
Arfon Smith
2b8545a8fa Merge pull request #2567 from pcantrell/objc-import-statement
#import "*.h" detection for Objective-C
2015-09-08 10:53:32 +01:00
Vicent Marti
b275b5d728 Soften memory pressure 2015-09-07 22:03:29 +02:00
Paul Chaignon
1f46cfafa7 New JSX language under JavaScript group
A specific grammar is needed to highlight .jsx files
Thus, there are now in a distinct language but still in the JavaScript group
2015-09-05 13:31:17 +02:00
miksen
b1dcdf3418 Language bar clarification in README.md
Clarified what the percentages in the Language bar are based on.
2015-09-04 11:49:10 +02:00
Paul Cantrell
4bfd65deb8 #import "*.h" detection for Objective-C 2015-09-03 22:10:27 -05:00
Paul Chaignon
213cf322f5 Merge branch 'master' into blob_in_memory 2015-09-04 00:55:39 +02:00
Arfon Smith
61102812a0 Merge pull request #2619 from github/linguist-generated
Adding support for generated overrides
2015-09-03 15:02:16 +01:00
Arfon Smith
580cfce7fb Adding support for generated overrides 2015-09-03 14:39:27 +01:00
Arfon Smith
f1383d7a45 Merge pull request #2616 from scttnlsn/patch-1
Ignore spec fixtures
2015-09-02 18:35:07 +01:00
Scott Nelson
e4ce5bfe39 Ignore spec fixtures 2015-09-02 12:52:25 -04:00
ismail-arilik
4d2b38497d Remove color attributes of 'type: data's. 2015-09-02 18:53:29 +03:00
ismail-arilik
fc5ae1cfbc Revert colors of some languages.
Revert colors of some languages which have 'type: data' attribute.
2015-09-02 17:53:58 +03:00
ismail-arilik
7e76d1cc6b Update Pascal color to fix the closeness issue. 2015-09-02 17:01:38 +03:00
ismail-arilik
cf834e8a21 Update some colors to fix closeness. 2015-09-02 16:23:33 +03:00
ismail-arilik
ee61466042 Update some colors to fix closeness. 2015-09-02 15:58:46 +03:00
ismail-arilik
35884d482c Update some colors to fix closeness. 2015-09-02 15:38:41 +03:00
ismail-arilik
802de8112c Update some colors to fix closeness. 2015-09-02 14:39:19 +03:00
ismail-arilik
9a76cfc85f Update some colors to fix closeness.
I have used syntactic color values with respect to the table below:

A | B C | D | E | F G | H | I | J K | L M | N O | P Q | R S | T U | V W | X | Y Z
0     1     2   3     4     5   6   7      8        9      A      B     C       D    E     F

For example for Gradle the color should be 4B0283, for Cuda the color should be 1C201C(for six-letter CudaCu) and for reStructuredText the color should be B3BCBC(for six-letter reStru).
2015-09-02 14:16:12 +03:00
ismail-arilik
dc41dd888d Update Cuda color to fix closeness. 2015-09-02 13:31:51 +03:00
Arfon Smith
6ed64f25a2 Merge pull request #2607 from Alhadis/master
Add .geojson/.topojson as JSON extensions / Fix NCL colour
2015-09-02 10:13:31 +01:00
ismail-arilik
827ad80311 Update colors to fix collision.
Colors basically incremented.
2015-09-02 10:16:37 +03:00
ismail-arilik
9e3d8ac4e9 Update Batchfile color. 2015-09-02 09:58:14 +03:00
Alhadis
114a331106 Add ".topojson" as a JSON extension 2015-09-02 07:04:51 +10:00
Arfon Smith
9aa24a216a Merge pull request #2612 from github/cut-release-v4.5.15
Cut release v4.5.15
2015-09-01 21:04:40 +01:00
ismail-arilik
1b327e29ba Add colors for some languages.
These are effected languages and the reason behind the proposed colors:

- Ant Build System: The color of logo (http://ant.apache.org/images/project-logo.gif).
- AppleScript: AppleScript editor logo (https://en.wikipedia.org/wiki/AppleScript#/media/File:AppleScript_Editor_Logo.png).
- Batchfile: Batch file icon in Windows (https://en.wikipedia.org/wiki/Batch_file#/media/File:Batch_file_icon_in_Windows_Vista.png).
- Bison: A color taken from a bison (https://en.wikipedia.org/wiki/Bison#/media/File:Americanbison.jpg).
- Cucumber: Official logo color (https://cucumber.io/images/cucumber-logo.svg).
- Cuda: Nvidia(creator of CUDA) logo color (http://www.nvidia.com/content/includes/redesign2010/images/redesign10/nvidia_logo.png).
- Gradle: Official Gradle logo color (https://gradle.org/wp-content/uploads/2015/03/GradleLogoReg.png).
- Hack: Hack logo color (http://hacklang.org/wp-content/themes/hack/hack.png).
- Haml: Haml logo color (http://haml.info/images/haml.png).
- LLVM: Eye color of the dragon logo of LLVM (http://llvm.org/img/DragonMedium.png).
- Less: Less logo color (http://lesscss.org/public/img/logo.png).
- Markdown: The Daring Fireball logo color (http://daringfireball.net/graphics/logos/).
- Maven POM: The maven logo color (https://en.wikipedia.org/wiki/Apache_Maven#/media/File:Maven_logo.svg).
- Nginx: The nginx logo color (http://nginx.org/nginx.png).
- NumPy: The NumPy logo color (http://www.numpy.org/_static/numpy_logo.png).
- RDoc: I couldn'd find any logo, so have used the color of the name of RDoc in the official site (http://docs.seattlerb.org/rdoc/).
- SCSS: The Sass logo color (http://sass-lang.com/assets/img/logos/logo-b6e1ef6e.svg).
- Sass: The Sass logo color (http://sass-lang.com/assets/img/logos/logo-b6e1ef6e.svg).
- XML: A random color.
- XSLT: A random color.
- YAML: The color of the name of YAML in the official site (http://yaml.org/).
- Yacc: A random color.
- reStructuredText: The official logo color (http://docutils.sourceforge.net/rst.png).
2015-09-01 21:51:48 +03:00
Arfon Smith
13702451ab Bumping to v4.5.15 2015-09-01 19:13:02 +01:00
Arfon Smith
f0242f6f97 Updating grammars 2015-09-01 19:12:27 +01:00
Arfon Smith
9775820398 Merge pull request #2591 from jtbandes/master
Vendored definitions for Xcode-related files
2015-09-01 18:53:08 +01:00
Arfon Smith
7daf26bcd0 Merge pull request #2604 from larsbrinkhoff/alphabetise-heuristics
Alphabetise heuristics.
2015-09-01 15:25:49 +01:00
Arfon Smith
231f705098 Merge pull request #2606 from thejameskyle/jsproj
Add .jsproj extension
2015-09-01 15:23:53 +01:00
Arfon Smith
893ab8fd8d Merge pull request #2610 from ismail-arilik/patch-1
Add color for the PL/SQL language.
2015-09-01 15:20:49 +01:00
ismail-arilik
5afdd2c533 Add color for the PL/SQL language.
I have added color to the PL/SQL language: #dad8d8. I take this color from a window background which evokes the interface of the language.
2015-09-01 14:23:59 +03:00
Lars Brinkhoff
e4f5c0066a Add checks to keep heuristics alphabetised. 2015-09-01 08:21:34 +02:00
Alhadis
a167f852dd Alphabetise JSON extensions 2015-09-01 07:33:07 +10:00
Alhadis
b428bce126 Quote NCL language's colour value
Without double-quotes, the hex colour is interpreted as a YAML comment.

Originally added in 2d39258.
2015-09-01 07:24:17 +10:00
Alhadis
e62d0e19a5 Add ".geojson" as a JSON extension 2015-09-01 07:12:18 +10:00
James Kyle
9b8bf9068f Move jsproj example to xml directory 2015-08-31 11:35:01 -07:00
James Kyle
6e05edc350 Add .jsproj extension 2015-08-31 10:26:29 -07:00
Lars Brinkhoff
dd8eaf2893 Alphabetise heuristics. 2015-08-31 08:53:51 +02:00
Michael Fellinger
ecc750f445 Merge branch 'master' of https://github.com/github/linguist into origin/patch-1
* 'master' of https://github.com/github/linguist:
  Switch to Apache License.
  also add help for unapproved licenses
  Update X10 grammar license.
  add some help text to license test
  Fix typo in Obj-C heuristic keyword
  Add the X10 language (http://x10-lang.org/).
  Sublime Text workspace files as vendored
  Make Slick regexp more general
  Tests for new vendored files
  Test for new CodeMirror regexp
  New JS vendored files
  Fix CodeMirror regex for vendored files
  added *.lslp to samples/LSL folder
  added *.lslp as LSL(Linden Scripting Language)

Conflicts:
	.gitmodules
2015-08-28 14:08:31 -04:00
Michael Fellinger
cf5268a7d4 add Pony language 2015-08-28 14:04:10 -04:00
Ben Balter
e24efad5ff Merge pull request #2594 from github/license-help
Add some additional help text to license test
2015-08-26 14:55:37 -04:00
Arfon Smith
58a34cdb7d Merge pull request #2589 from mandel/master
Add the X10 language.
2015-08-26 19:36:54 +01:00
Louis Mandel
b1c6b330e9 Switch to Apache License. 2015-08-26 14:26:30 -04:00
Ben Balter
7c3e265033 also add help for unapproved licenses 2015-08-26 12:31:29 -04:00
Louis Mandel
13695a716c Update X10 grammar license. 2015-08-26 09:46:02 -04:00
Ben Balter
c9e43804d6 add some help text to license test 2015-08-26 09:26:04 -04:00
Arfon Smith
1535e3553e Merge pull request #2580 from LeonaMorro/master
add *.lslp as an additional extension for LSL (LindenScriptingLanguage)
2015-08-26 14:09:48 +01:00
Arfon Smith
0ac05bbbeb Merge pull request #2582 from pchaigno/vendor-libraries
Vendored JS files
2015-08-26 14:02:57 +01:00
Arfon Smith
d3f979d640 Merge pull request #2592 from jtbandes/typo
Fix typo in Obj-C heuristic keyword
2015-08-26 12:52:05 +01:00
Jacob Bandes-Storch
0e9ded45dc Fix typo in Obj-C heuristic keyword
`synchronised` → `synchronized`
2015-08-26 00:34:00 -07:00
Jacob Bandes-Storch
a2ca886510 Vendored definitions for Xcode-related files 2015-08-25 23:42:20 -07:00
Louis Mandel
25a1af3775 Add the X10 language (http://x10-lang.org/). 2015-08-24 13:26:43 -04:00
Paul Chaignon
0d8e0a2970 Sublime Text workspace files as vendored 2015-08-24 12:32:26 +02:00
Paul Chaignon
c0fff6c8a8 Make Slick regexp more general 2015-08-21 12:30:01 +02:00
Paul Chaignon
e6b4428614 Tests for new vendored files 2015-08-21 12:24:04 +02:00
Paul Chaignon
4e6e69833d Test for new CodeMirror regexp 2015-08-21 12:15:17 +02:00
Paul Chaignon
1d9faff4c6 New JS vendored files 2015-08-21 12:13:42 +02:00
Paul Chaignon
7025cbe760 Fix CodeMirror regex for vendored files 2015-08-21 12:12:52 +02:00
LeonaMorro
e922b7c2ca added *.lslp to samples/LSL folder 2015-08-21 11:44:23 +02:00
LeonaMorro
96518d2d0f added *.lslp as LSL(Linden Scripting Language) 2015-08-21 11:17:12 +02:00
Arfon Smith
1241b20ba1 Merge pull request #2578 from blakeembrey/correct-raml-type
Make RAML a markup language
2015-08-20 20:56:21 +01:00
Ben Balter
f03f5c1628 Merge pull request #2568 from github/licensee
Use Licensee to classify submodule licenses
2015-08-20 15:42:50 -04:00
Ben Balter
cb550a3662 remove some random submodules 2015-08-20 15:30:51 -04:00
Ben Balter
d1f90d61c5 Merge branch 'master' into licensee 2015-08-20 15:25:15 -04:00
Blake Embrey
16e65fe189 Make RAML a markup language
RAML was originally merged as a data language, but this seems like an incorrect definition. I changed it to be markup instead, which will also result in RAML appearing in repo statistics.
2015-08-20 10:07:44 -07:00
Ben Balter
62a0faa729 let us 2015-08-20 12:23:52 -04:00
Ben Balter
fbb3ab2292 batch license test output 2015-08-20 11:38:31 -04:00
Arfon Smith
b3b75e5ef8 Merge pull request #2574 from github/perl-t
Adding Perl/Perl6 heuristic for '.t'
2015-08-20 10:29:52 +01:00
Arfon Smith
8b36210db5 Merge pull request #2573 from a0viedo/patch-1
relativize link in readme
2015-08-20 10:25:02 +01:00
Arfon Smith
a74f3b3e46 Adding Perl/Perl6 heuristic for '.t' 2015-08-20 10:16:52 +01:00
Alejandro Oviedo
e214a52de5 relativize link in readme
...so it could link properly in other branches and forks.
2015-08-19 19:15:05 -03:00
Arfon Smith
0624a9395c Merge pull request #2571 from pchaigno/prolog-grammar
New grammars for Prolog and ECLiPSe
2015-08-19 21:44:13 +01:00
Arfon Smith
b2e7f7ffa6 Merge pull request #2570 from pchaigno/typescript-grammar
New grammar for Typescript
2015-08-19 21:41:15 +01:00
Arfon Smith
b312b39a10 Merge pull request #2572 from pchaigno/rmarkdown-tmscope
TextMate scope for RMarkdown
2015-08-19 21:38:42 +01:00
Paul Chaignon
80e2d112b2 tm_scope for RMarkdown 2015-08-19 22:07:23 +02:00
Paul Chaignon
519b169df0 New grammar for Typescript from Sublime Text package 2015-08-19 21:30:24 +02:00
Paul Chaignon
5c2cfbc334 Remove Typescript grammar 2015-08-19 21:27:40 +02:00
Paul Chaignon
7d91e4959a Dissociate ECLiPSe from Prolog
ECLiPSe syntax is slightly different from Prolog syntax
ECLiPSe is in the Prolog group so it will only be highlighted differently
2015-08-19 20:56:14 +02:00
Paul Chaignon
0c5aa2a7eb Merge branch 'master' into prolog-grammar 2015-08-19 20:46:15 +02:00
Paul Chaignon
0d7a264981 Update submodule for Prolog grammar 2015-08-19 20:43:16 +02:00
Arfon Smith
52ff2d2e74 Merge pull request #2557 from pchaigno/mozilla-public-license
Recognize the Mozilla Public License for grammars
2015-08-19 19:21:33 +01:00
Ben Balter
8a7ceaa845 bump licensee to support ruby 1.9.3 2015-08-19 13:22:31 -04:00
Ben Balter
fd9ce2d1cf use licensee to classify submodule licenses 2015-08-19 12:54:21 -04:00
Paul Chaignon
2c2b37bec3 Reorganize tests
Rename test_memory_blob.rb to test_blob.rb for consistence with last commit
2015-08-19 18:07:42 +02:00
Paul Chaignon
c777f2d388 Merge branch 'master' into blob_in_memory 2015-08-19 18:02:31 +02:00
Paul Chaignon
eca10056a8 Rename MemoryBlob to Blob 2015-08-19 17:29:35 +02:00
Arfon Smith
c7bab11ebe Merge pull request #2566 from github/cut-release-v4.5.14
v4.5.14 version bump
2015-08-19 10:36:52 +01:00
Arfon Smith
6995fc28b6 v4.5.14 version bump 2015-08-19 07:01:07 +01:00
Arfon Smith
102f14d0e9 Grammars update 2015-08-19 06:59:39 +01:00
Arfon Smith
aac168402b Merge pull request #2565 from pchaigno/aspectj-grammar
Grammar for AspectJ
2015-08-19 06:49:16 +01:00
Paul Chaignon
152d49513f Grammar for AspectJ from Sublime Text package 2015-08-19 00:11:34 +02:00
Arfon Smith
d5564c808d Merge pull request #2560 from larsbrinkhoff/sexp
Add .sexp to Common Lisp.
2015-08-18 21:15:46 +01:00
Lars Brinkhoff
82410e07b2 Add .sexp to Common Lisp.
config.sexp by Jeremie Dimino; Apache License 2.0.
rss.sexp by Dan Lentz; LGPL 2.1.
2015-08-18 12:45:47 +02:00
Arfon Smith
94d90b30b5 Merge pull request #2561 from pchaigno/labview-xml
Highlight LabVIEW files as XML
2015-08-18 12:25:38 +02:00
Paul Chaignon
06997f0da2 Fix scope of grammar for LabVIEW 2015-08-14 14:17:32 +02:00
Paul Chaignon
55aafa416d Highlight LabVIEW files as XML 2015-08-14 13:56:28 +02:00
Paul Chaignon
6226a46988 Recognize the Mozilla Public License for grammars 2015-08-13 17:35:01 +02:00
Paul Chaignon
8d216f0c43 Grammar for Prolog from Sublime Text package
MPLv2 License is currently unrecognized
2015-08-13 17:15:04 +02:00
Paul Chaignon
7f5bb25542 Remove grammar for Prolog from TextMate bundle 2015-08-13 16:56:21 +02:00
Arfon Smith
5fcdf6adc2 Merge pull request #2555 from larsbrinkhoff/zone
Add .arpa to DNS Zone.
2015-08-13 10:18:51 +01:00
Lars Brinkhoff
6a565a849b Add .arpa to DNS Zone.
sample.arpa by Freeswitch project; Mozilla Public License 1.1.
2015-08-13 07:38:17 +02:00
Arfon Smith
66fc67e34c Merge pull request #2554 from github/mcandre-master
DNS Zone files
2015-08-12 18:54:04 +01:00
Arfon Smith
7cf140940e Fixing up the build 2015-08-12 17:20:29 +01:00
Arfon Smith
60e90bab23 Removing un-used Bind bundle 2015-08-12 17:06:39 +01:00
Arfon Smith
4f58258186 Removing erroneous submodule 2015-08-12 17:05:57 +01:00
Arfon Smith
03e2904ebf Merge branch 'master' of https://github.com/mcandre/linguist into mcandre-master 2015-08-12 15:15:28 +01:00
Andrew Pennebaker
bea90b256e use st2-zonefile (MIT licensed) instead of Bind.tmbundle (unlicensed) 2015-08-11 14:01:45 -05:00
Arfon Smith
8eb37ba956 Merge pull request #2541 from github/reworking-documentation-paths
Reworking documentation paths
2015-08-11 09:44:19 +01:00
Arfon Smith
8d20c1fb59 More inclusive documentation matches for License and Readme files 2015-08-11 09:39:41 +01:00
Arfon Smith
9a1abf0c49 Merge branch 'master' into reworking-documentation-paths 2015-08-11 09:10:08 +01:00
Arfon Smith
5d5550c48b Moving vendored definitions to documentation 2015-08-07 10:42:31 +01:00
Arfon Smith
fd570d906a Adding examples path to documentation.yml 2015-08-07 10:35:18 +01:00
Paul Chaignon
5a646384f6 FileBlob extends MemoryBlob 2015-07-12 20:56:51 +02:00
Paul Chaignon
8917f1a91a MemoryBlob class: wrapper around the content of a file
Makes it possible to detect the language of a snippet of code
without having an actual file on disk
Will allow github-markup to use Linguist without restricting its API
2015-07-12 20:28:42 +02:00
Andrew Pennebaker
03369b8a6c use https url for travis support 2015-05-03 12:51:52 -05:00
Andrew Pennebaker
3b2ddb1a18 classify DNS zone as a data format 2015-05-01 11:25:16 -05:00
Andrew Pennebaker
1e20b12241 zone: add ace_mode 2015-04-30 15:40:44 -05:00
Andrew Pennebaker
81c41df15c zone: add tm_scope 2015-04-30 15:39:32 -05:00
Andrew Pennebaker
8b736189e0 better name for DNS zone 2015-04-30 15:34:43 -05:00
Andrew Pennebaker
188d2367df add sample zone file 2015-04-30 15:25:52 -05:00
Andrew Pennebaker
5aeac500da list zone in grammars.yml 2015-04-30 15:24:46 -05:00
Andrew Pennebaker
5730ab28ab list zone in languages.yml 2015-04-30 15:23:31 -05:00
Andrew Pennebaker
1c56b03a28 highlight DNS zone (BIND) files 2015-04-30 15:14:26 -05:00
263 changed files with 46130 additions and 1036 deletions

82
.gitmodules vendored
View File

@@ -25,9 +25,6 @@
[submodule "vendor/grammars/Sublime-REBOL"]
path = vendor/grammars/Sublime-REBOL
url = https://github.com/Oldes/Sublime-REBOL
[submodule "vendor/grammars/Sublime-Inform"]
path = vendor/grammars/Sublime-Inform
url = https://github.com/PogiNate/Sublime-Inform
[submodule "vendor/grammars/autoitv3-tmbundle"]
path = vendor/grammars/autoitv3-tmbundle
url = https://github.com/Red-Nova-Technologies/autoitv3-tmbundle
@@ -85,6 +82,9 @@
[submodule "vendor/grammars/language-shellscript"]
path = vendor/grammars/language-shellscript
url = https://github.com/atom/language-shellscript
[submodule "vendor/grammars/language-supercollider"]
path = vendor/grammars/language-supercollider
url = https://github.com/supercollider/language-supercollider
[submodule "vendor/grammars/language-yaml"]
path = vendor/grammars/language-yaml
url = https://github.com/atom/language-yaml
@@ -169,9 +169,6 @@
[submodule "vendor/grammars/sublime-idris"]
path = vendor/grammars/sublime-idris
url = https://github.com/laughedelic/sublime-idris
[submodule "vendor/grammars/sublime-better-typescript"]
path = vendor/grammars/sublime-better-typescript
url = https://github.com/lavrton/sublime-better-typescript
[submodule "vendor/grammars/moonscript-tmbundle"]
path = vendor/grammars/moonscript-tmbundle
url = https://github.com/leafo/moonscript-tmbundle
@@ -256,9 +253,6 @@
[submodule "vendor/grammars/SublimeXtend"]
path = vendor/grammars/SublimeXtend
url = https://github.com/staltz/SublimeXtend
[submodule "vendor/grammars/Stata.tmbundle"]
path = vendor/grammars/Stata.tmbundle
url = https://github.com/statatmbundle/Stata.tmbundle
[submodule "vendor/grammars/Vala-TMBundle"]
path = vendor/grammars/Vala-TMBundle
url = https://github.com/technosophos/Vala-TMBundle
@@ -346,9 +340,6 @@
[submodule "vendor/grammars/latex.tmbundle"]
path = vendor/grammars/latex.tmbundle
url = https://github.com/textmate/latex.tmbundle
[submodule "vendor/grammars/less.tmbundle"]
path = vendor/grammars/less.tmbundle
url = https://github.com/textmate/less.tmbundle
[submodule "vendor/grammars/lilypond.tmbundle"]
path = vendor/grammars/lilypond.tmbundle
url = https://github.com/textmate/lilypond.tmbundle
@@ -397,9 +388,6 @@
[submodule "vendor/grammars/processing.tmbundle"]
path = vendor/grammars/processing.tmbundle
url = https://github.com/textmate/processing.tmbundle
[submodule "vendor/grammars/prolog.tmbundle"]
path = vendor/grammars/prolog.tmbundle
url = https://github.com/textmate/prolog.tmbundle
[submodule "vendor/grammars/python-django.tmbundle"]
path = vendor/grammars/python-django.tmbundle
url = https://github.com/textmate/python-django.tmbundle
@@ -655,7 +643,7 @@
url = https://github.com/SRI-CSL/SMT.tmbundle.git
[submodule "vendor/grammars/language-crystal"]
path = vendor/grammars/language-crystal
url = https://github.com/k2b6s9j/language-crystal
url = https://github.com/atom-crystal/language-crystal
[submodule "vendor/grammars/language-xbase"]
path = vendor/grammars/language-xbase
url = https://github.com/hernad/atom-language-harbour
@@ -664,7 +652,67 @@
url = https://github.com/rpavlick/language-ncl.git
[submodule "vendor/grammars/atom-language-purescript"]
path = vendor/grammars/atom-language-purescript
url = https://github.com/freebroccolo/atom-language-purescript
url = https://github.com/purescript-contrib/atom-language-purescript
[submodule "vendor/grammars/vue-syntax-highlight"]
path = vendor/grammars/vue-syntax-highlight
url = https://github.com/vuejs/vue-syntax-highlight
[submodule "vendor/grammars/st2-zonefile"]
path = vendor/grammars/st2-zonefile
url = https://github.com/sixty4k/st2-zonefile
[submodule "vendor/grammars/sublimeprolog"]
path = vendor/grammars/sublimeprolog
url = https://github.com/alnkpa/sublimeprolog
[submodule "vendor/grammars/sublime-aspectj"]
path = vendor/grammars/sublime-aspectj
url = https://github.com/pchaigno/sublime-aspectj
[submodule "vendor/grammars/sublime-typescript"]
path = vendor/grammars/sublime-typescript
url = https://github.com/Microsoft/TypeScript-Sublime-Plugin
[submodule "vendor/grammars/sublime-pony"]
path = vendor/grammars/sublime-pony
url = https://github.com/CausalityLtd/sublime-pony
[submodule "vendor/grammars/X10"]
path = vendor/grammars/X10
url = https://github.com/x10-lang/x10-highlighting
[submodule "vendor/grammars/language-babel"]
path = vendor/grammars/language-babel
url = https://github.com/gandm/language-babel
[submodule "vendor/grammars/UrWeb-Language-Definition"]
path = vendor/grammars/UrWeb-Language-Definition
url = https://github.com/gwalborn/UrWeb-Language-Definition.git
[submodule "vendor/grammars/Stata.tmbundle"]
path = vendor/grammars/Stata.tmbundle
url = https://github.com/pschumm/Stata.tmbundle
[submodule "vendor/grammars/FreeMarker.tmbundle"]
path = vendor/grammars/FreeMarker.tmbundle
url = https://github.com/freemarker/FreeMarker.tmbundle
[submodule "vendor/grammars/MagicPython"]
path = vendor/grammars/MagicPython
url = https://github.com/MagicStack/MagicPython
[submodule "vendor/grammars/language-click"]
path = vendor/grammars/language-click
url = https://github.com/stenverbois/language-click.git
[submodule "vendor/grammars/language-maxscript"]
path = vendor/grammars/language-maxscript
url = https://github.com/Alhadis/language-maxscript
[submodule "vendor/grammars/language-renpy"]
path = vendor/grammars/language-renpy
url = https://github.com/williamd1k0/language-renpy.git
[submodule "vendor/grammars/language-inform7"]
path = vendor/grammars/language-inform7
url = https://github.com/erkyrath/language-inform7
[submodule "vendor/grammars/atom-language-stan"]
path = vendor/grammars/atom-language-stan
url = https://github.com/jrnold/atom-language-stan
[submodule "vendor/grammars/language-yang"]
path = vendor/grammars/language-yang
url = https://github.com/DzonyKalafut/language-yang.git
[submodule "vendor/grammars/perl6fe"]
path = vendor/grammars/perl6fe
url = https://github.com/MadcapJake/language-perl6fe.git
[submodule "vendor/grammars/language-less"]
path = vendor/grammars/language-less
url = https://github.com/atom/language-less.git
[submodule "vendor/grammars/language-povray"]
path = vendor/grammars/language-povray
url = https://github.com/c-lipka/language-povray

View File

@@ -1,6 +1,12 @@
language: ruby
sudo: false
addons:
apt:
packages:
- libicu-dev
- libicu48
before_install: script/travis/before_install
rvm:
- 1.9.3
- 2.0.0
- 2.1
- 2.2

View File

@@ -12,7 +12,7 @@ We try only to add new extensions once they have some usage on GitHub. In most c
To add support for a new extension:
0. Add your extension to the language entry in [`languages.yml`][languages].
0. Add your extension to the language entry in [`languages.yml`][languages], keeping the extensions in alphabetical order.
0. Add at least one sample for your extension to the [samples directory][samples] in the correct subdirectory.
0. Open a pull request, linking to a [GitHub search result](https://github.com/search?utf8=%E2%9C%93&q=extension%3Aboot+NOT+nothack&type=Code&ref=searchresults) showing in-the-wild usage.

View File

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

View File

@@ -13,11 +13,11 @@ See [Troubleshooting](#troubleshooting) and [`CONTRIBUTING.md`](/CONTRIBUTING.md
![language stats bar](https://cloud.githubusercontent.com/assets/173/5562290/48e24654-8ddf-11e4-8fe7-735b0ce3a0d3.png)
The Language stats bar is built by aggregating the languages of each file in that repository. If it is reporting a language that you don't expect:
The Language stats bar displays languages percentages for the files in the repository. The percentages are calculated based on the bytes of code for each language as reported by the [List Languages](https://developer.github.com/v3/repos/#list-languages) API. If the bar is reporting a language that you don't expect:
0. Click on the name of the language in the stats bar to see a list of the files that are identified as that language.
0. If you see files that you didn't write, consider moving the files into one of the [paths for vendored code](https://github.com/github/linguist/blob/master/lib/linguist/vendor.yml), or use the [manual overrides](#overrides) feature to ignore them.
0. If the files are being misclassified, search for [open issues][issues] to see if anyone else has already reported the issue. Any information you an add, especially links to public repositories, is helpful.
0. If you see files that you didn't write, consider moving the files into one of the [paths for vendored code](/lib/linguist/vendor.yml), or use the [manual overrides](#overrides) feature to ignore them.
0. If the files are being misclassified, search for [open issues][issues] to see if anyone else has already reported the issue. Any information you can add, especially links to public repositories, is helpful.
0. If there are no reported issues of this misclassification, [open an issue][new-issue] and include a link to the repository or a sample of the code that is being misclassified.
## Overrides
@@ -33,9 +33,9 @@ $ cat .gitattributes
*.rb linguist-language=Java
```
Checking code you didn't write, such as JavaScript libraries, into your git repo is a common practice, but this often inflates your project's language stats and may even cause your project to be labeled as another language. By default, Linguist treats all of the paths defined in [lib/linguist/vendor.yml](https://github.com/github/linguist/blob/master/lib/linguist/vendor.yml) as vendored and therefore doesn't include them in the language statistics for a repository. Vendored files are also hidden by default in diffs on github.com.
Checking code you didn't write, such as JavaScript libraries, into your git repo is a common practice, but this often inflates your project's language stats and may even cause your project to be labeled as another language. By default, Linguist treats all of the paths defined in [lib/linguist/vendor.yml](https://github.com/github/linguist/blob/master/lib/linguist/vendor.yml) as vendored and therefore doesn't include them in the language statistics for a repository.
Use the `linguist-vendored` attribute to vendor or un-vendor paths. Please note, overriding the vendored (or un-vendored) status of a file only affects the language statistics for the repository and not the behavior in diffs on github.com.
Use the `linguist-vendored` attribute to vendor or un-vendor paths.
```
$ cat .gitattributes
@@ -59,6 +59,9 @@ Alternatively, you can use Vim or Emacs style modelines to set the language for
##### Vim
```
# Some examples of various styles:
vim: syntax=java
vim: set syntax=ruby:
vim: set filetype=prolog:
vim: set ft=cpp:
```

138
bin/git-linguist Executable file
View File

@@ -0,0 +1,138 @@
#!/usr/bin/env ruby
require 'linguist'
require 'rugged'
require 'optparse'
require 'json'
require 'tmpdir'
require 'zlib'
class GitLinguist
def initialize(path, commit_oid, incremental = true)
@repo_path = path
@commit_oid = commit_oid
@incremental = incremental
end
def linguist
if @commit_oid.nil?
raise "git-linguist must be called with a specific commit OID to perform language computation"
end
repo = Linguist::Repository.new(rugged, @commit_oid)
if @incremental && stats = load_language_stats
old_commit_oid, old_stats = stats
# A cache with NULL oid means that we want to froze
# these language stats in place and stop computing
# them (for performance reasons)
return old_stats if old_commit_oid == NULL_OID
repo.load_existing_stats(old_commit_oid, old_stats)
end
result = yield repo
save_language_stats(@commit_oid, repo.cache)
result
end
def load_language_stats
version, oid, stats = load_cache
if version == LANGUAGE_STATS_CACHE_VERSION && oid && stats
[oid, stats]
end
end
def save_language_stats(oid, stats)
cache = [LANGUAGE_STATS_CACHE_VERSION, oid, stats]
write_cache(cache)
end
def clear_language_stats
File.unlink(cache_file)
rescue Errno::ENOENT
end
def disable_language_stats
save_language_stats(NULL_OID, {})
end
protected
NULL_OID = ("0" * 40).freeze
LANGUAGE_STATS_CACHE = 'language-stats.cache'
LANGUAGE_STATS_CACHE_VERSION = "v3:#{Linguist::VERSION}"
def rugged
@rugged ||= Rugged::Repository.bare(@repo_path)
end
def cache_file
File.join(@repo_path, LANGUAGE_STATS_CACHE)
end
def write_cache(object)
return unless File.directory? @repo_path
begin
tmp_path = Dir::Tmpname.make_tmpname(cache_file, nil)
File.open(tmp_path, "wb") do |f|
marshal = Marshal.dump(object)
f.write(Zlib::Deflate.deflate(marshal))
end
File.rename(tmp_path, cache_file)
rescue => e
(File.unlink(tmp_path) rescue nil)
raise e
end
end
def load_cache
marshal = File.open(cache_file, "rb") { |f| Zlib::Inflate.inflate(f.read) }
Marshal.load(marshal)
rescue SystemCallError, ::Zlib::DataError, ::Zlib::BufError, TypeError
nil
end
end
def git_linguist(args)
incremental = true
commit = nil
parser = OptionParser.new do |opts|
opts.banner = "Usage: git-linguist [OPTIONS] stats|breakdown|dump-cache|clear|disable"
opts.on("-f", "--force", "Force a full rescan") { incremental = false }
opts.on("--commit=COMMIT", "Commit to index") { |v| commit = v}
end
parser.parse!(args)
git_dir = `git rev-parse --git-dir`.strip
raise "git-linguist must be ran in a Git repository" unless $?.success?
wrapper = GitLinguist.new(git_dir, commit, incremental)
case args.pop
when "stats"
wrapper.linguist do |linguist|
puts JSON.dump(linguist.languages)
end
when "breakdown"
wrapper.linguist do |linguist|
puts JSON.dump(linguist.breakdown_by_file)
end
when "dump-cache"
puts JSON.dump(wrapper.load_language_stats)
when "clear"
wrapper.clear_language_stats
when "disable"
wrapper.disable_language_stats
else
$stderr.print(parser.help)
exit 1
end
end
git_linguist(ARGV)

View File

@@ -10,8 +10,8 @@ Gem::Specification.new do |s|
s.homepage = "https://github.com/github/linguist"
s.license = "MIT"
s.files = Dir['lib/**/*'] - ['lib/linguist/grammars.rb']
s.executables << 'linguist'
s.files = Dir['lib/**/*'] - ['lib/linguist/grammars.rb'] + ['LICENSE']
s.executables = ['linguist', 'git-linguist']
s.add_dependency 'charlock_holmes', '~> 0.7.3'
s.add_dependency 'escape_utils', '~> 1.1.0'
@@ -24,4 +24,6 @@ Gem::Specification.new do |s|
s.add_development_dependency 'rake'
s.add_development_dependency 'yajl-ruby'
s.add_development_dependency 'color-proximity', '~> 0.2.1'
s.add_development_dependency 'licensee', '6.0.0b1'
end

64
grammars.yml Normal file → Executable file
View File

@@ -42,6 +42,8 @@ vendor/grammars/Docker.tmbundle:
- source.dockerfile
vendor/grammars/Elm.tmLanguage:
- source.elm
vendor/grammars/FreeMarker.tmbundle:
- text.html.ftl
vendor/grammars/G-Code/:
- source.LS
- source.MCPOST
@@ -67,6 +69,9 @@ vendor/grammars/Lean.tmbundle:
- source.lean
vendor/grammars/LiveScript.tmbundle:
- source.livescript
vendor/grammars/MagicPython:
- source.python
- source.regexp.python
vendor/grammars/Modelica/:
- source.modelica
vendor/grammars/NSIS:
@@ -92,7 +97,7 @@ vendor/grammars/Scalate.tmbundle:
- text.html.ssp
vendor/grammars/Slash.tmbundle:
- text.html.slash
vendor/grammars/Stata.tmbundle:
vendor/grammars/Stata.tmbundle/:
- source.mata
- source.stata
vendor/grammars/Stylus/:
@@ -101,8 +106,6 @@ vendor/grammars/Sublime-Coq:
- source.coq
vendor/grammars/Sublime-HTTP:
- source.httpspec
vendor/grammars/Sublime-Inform:
- source.Inform7
vendor/grammars/Sublime-Lasso:
- file.lasso
vendor/grammars/Sublime-Logos:
@@ -140,10 +143,14 @@ vendor/grammars/TXL/:
- source.txl
vendor/grammars/Textmate-Gosu-Bundle:
- source.gosu.2
vendor/grammars/UrWeb-Language-Definition:
- source.ur
vendor/grammars/VBDotNetSyntax:
- source.vbnet
vendor/grammars/Vala-TMBundle:
- source.vala
vendor/grammars/X10:
- source.x10
vendor/grammars/abap.tmbundle:
- source.abap
vendor/grammars/actionscript3-tmbundle:
@@ -176,8 +183,13 @@ vendor/grammars/assembly.tmbundle:
- source.x86asm
vendor/grammars/atom-fsharp/:
- source.fsharp
- source.fsharp.fsi
- source.fsharp.fsl
- source.fsharp.fsx
vendor/grammars/atom-language-purescript/:
- source.purescript
vendor/grammars/atom-language-stan/:
- source.stan
vendor/grammars/atom-salt:
- source.python.salt
- source.yaml.salt
@@ -295,8 +307,8 @@ vendor/grammars/io.tmbundle:
vendor/grammars/ioke-outdated:
- source.ioke
vendor/grammars/jade-tmbundle:
- source.jade
- source.pyjade
- text.jade
vendor/grammars/jasmin-sublime:
- source.jasmin
vendor/grammars/java.tmbundle:
@@ -312,6 +324,11 @@ vendor/grammars/json.tmbundle:
- source.json
vendor/grammars/kotlin-sublime-package:
- source.Kotlin
vendor/grammars/language-babel/:
- source.js.jsx
- source.regexp.babel
vendor/grammars/language-click/:
- source.click
vendor/grammars/language-clojure:
- source.clojure
vendor/grammars/language-coffee-script:
@@ -328,26 +345,39 @@ vendor/grammars/language-gfm:
- source.gfm
vendor/grammars/language-hy:
- source.hy
vendor/grammars/language-inform7:
- source.inform7
vendor/grammars/language-javascript:
- source.js
- source.js.regexp
- source.js.regexp.replacement
vendor/grammars/language-jsoniq/:
- source.jq
- source.xq
vendor/grammars/language-less/:
- source.css.less
vendor/grammars/language-maxscript:
- source.maxscript
vendor/grammars/language-ncl:
- source.ncl
vendor/grammars/language-povray:
- source.pov-ray sdl
vendor/grammars/language-python:
- source.python
- source.regexp.python
- text.python.console
- text.python.traceback
vendor/grammars/language-renpy:
- source.renpy
vendor/grammars/language-shellscript:
- source.shell
- text.shell-session
vendor/grammars/language-supercollider:
- source.supercollider
vendor/grammars/language-xbase:
- source.harbour
vendor/grammars/language-yaml:
- source.yaml
vendor/grammars/language-yang/:
- source.yang
vendor/grammars/latex.tmbundle:
- text.bibtex
- text.log.latex
@@ -355,8 +385,6 @@ vendor/grammars/latex.tmbundle:
- text.tex.latex
- text.tex.latex.beamer
- text.tex.latex.memoir
vendor/grammars/less.tmbundle:
- source.css.less
vendor/grammars/lilypond.tmbundle:
- source.lilypond
vendor/grammars/liquid.tmbundle:
@@ -419,6 +447,10 @@ vendor/grammars/pascal.tmbundle:
vendor/grammars/perl.tmbundle/:
- source.perl
- source.perl.6
vendor/grammars/perl6fe:
- source.meta-info
- source.perl6fe
- source.regexp.perl6fe
vendor/grammars/php-smarty.tmbundle:
- text.html.smarty
vendor/grammars/php.tmbundle:
@@ -431,8 +463,6 @@ vendor/grammars/powershell:
- source.powershell
vendor/grammars/processing.tmbundle:
- source.processing
vendor/grammars/prolog.tmbundle:
- source.prolog
vendor/grammars/protobuf-tmbundle:
- source.protobuf
vendor/grammars/puppet-textmate-bundle:
@@ -470,6 +500,8 @@ vendor/grammars/smalltalk-tmbundle:
- source.smalltalk
vendor/grammars/sql.tmbundle:
- source.sql
vendor/grammars/st2-zonefile:
- text.zone_file
vendor/grammars/standard-ml.tmbundle:
- source.cm
- source.ml
@@ -477,10 +509,10 @@ vendor/grammars/sublime-MuPAD:
- source.mupad
vendor/grammars/sublime-apl/:
- source.apl
vendor/grammars/sublime-aspectj/:
- source.aspectj
vendor/grammars/sublime-befunge:
- source.befunge
vendor/grammars/sublime-better-typescript:
- source.ts
vendor/grammars/sublime-bsv:
- source.bsv
vendor/grammars/sublime-cirru:
@@ -504,6 +536,8 @@ vendor/grammars/sublime-nix:
vendor/grammars/sublime-opal/:
- source.opal
- source.opalsysdefs
vendor/grammars/sublime-pony:
- source.pony
vendor/grammars/sublime-robot-plugin:
- text.robot
vendor/grammars/sublime-rust:
@@ -519,6 +553,9 @@ vendor/grammars/sublime-text-ox/:
- source.ox
vendor/grammars/sublime-text-pig-latin/:
- source.pig_latin
vendor/grammars/sublime-typescript/:
- source.ts
- source.tsx
vendor/grammars/sublime-varnish:
- source.varnish.vcl
vendor/grammars/sublime_cobol:
@@ -529,6 +566,9 @@ vendor/grammars/sublime_cobol:
vendor/grammars/sublime_man_page_support:
- source.man
- text.groff
vendor/grammars/sublimeprolog/:
- source.prolog
- source.prolog.eclipse
vendor/grammars/sublimetext-cuda-cpp:
- source.cuda-c++
vendor/grammars/swift.tmbundle:

View File

@@ -13,8 +13,8 @@ class << Linguist
def instrument(*args, &bk)
if instrumenter
instrumenter.instrument(*args, &bk)
else
yield if block_given?
elsif block_given?
yield
end
end
end

73
lib/linguist/blob.rb Normal file
View File

@@ -0,0 +1,73 @@
require 'linguist/blob_helper'
module Linguist
# A Blob is a wrapper around the content of a file to make it quack
# like a Grit::Blob. It provides the basic interface: `name`,
# `data`, `path` and `size`.
class Blob
include BlobHelper
# Public: Initialize a new Blob.
#
# path - A path String (does not necessarily exists on the file system).
# content - Content of the file.
#
# Returns a Blob.
def initialize(path, content)
@path = path
@content = content
end
# Public: Filename
#
# Examples
#
# Blob.new("/path/to/linguist/lib/linguist.rb", "").path
# # => "/path/to/linguist/lib/linguist.rb"
#
# Returns a String
attr_reader :path
# Public: File name
#
# Returns a String
def name
File.basename(@path)
end
# Public: File contents.
#
# Returns a String.
def data
@content
end
# Public: Get byte size
#
# Returns an Integer.
def size
@content.bytesize
end
# Public: Get file extension.
#
# Returns a String.
def extension
extensions.last || ""
end
# Public: Return an array of the file extensions
#
# >> Linguist::Blob.new("app/views/things/index.html.erb").extensions
# => [".html.erb", ".erb"]
#
# Returns an Array
def extensions
basename, *segments = name.downcase.split(".")
segments.map.with_index do |segment, index|
"." + segments[index..-1].join(".")
end
end
end
end

View File

@@ -13,6 +13,7 @@
- (^|/)[Dd]ocumentation/
- (^|/)javadoc/
- ^man/
- ^[Ee]xamples/
## Documentation files ##
@@ -21,4 +22,9 @@
- (^|/)COPYING(\.|$)
- (^|/)INSTALL(\.|$)
- (^|/)LICEN[CS]E(\.|$)
- (^|/)[Ll]icen[cs]e(\.|$)
- (^|/)README(\.|$)
- (^|/)[Rr]eadme(\.|$)
# Samples folders
- ^[Ss]amples/

View File

@@ -1,10 +1,11 @@
require 'linguist/blob_helper'
require 'linguist/blob'
module Linguist
# A FileBlob is a wrapper around a File object to make it quack
# like a Grit::Blob. It provides the basic interface: `name`,
# `data`, `path` and `size`.
class FileBlob
class FileBlob < Blob
include BlobHelper
# Public: Initialize a new FileBlob from a path
@@ -18,20 +19,6 @@ module Linguist
@path = base_path ? path.sub("#{base_path}/", '') : path
end
# Public: Filename
#
# Examples
#
# FileBlob.new("/path/to/linguist/lib/linguist.rb").path
# # => "/path/to/linguist/lib/linguist.rb"
#
# FileBlob.new("/path/to/linguist/lib/linguist.rb",
# "/path/to/linguist").path
# # => "lib/linguist.rb"
#
# Returns a String
attr_reader :path
# Public: Read file permissions
#
# Returns a String like '100644'
@@ -39,13 +26,6 @@ module Linguist
File.stat(@fullpath).mode.to_s(8)
end
# Public: File name
#
# Returns a String
def name
File.basename(@fullpath)
end
# Public: Read file contents.
#
# Returns a String.
@@ -59,26 +39,5 @@ module Linguist
def size
File.size(@fullpath)
end
# Public: Get file extension.
#
# Returns a String.
def extension
extensions.last || ""
end
# Public: Return an array of the file extensions
#
# >> Linguist::FileBlob.new("app/views/things/index.html.erb").extensions
# => [".html.erb", ".erb"]
#
# Returns an Array
def extensions
basename, *segments = name.downcase.split(".")
segments.map.with_index do |segment, index|
"." + segments[index..-1].join(".")
end
end
end
end

View File

@@ -71,7 +71,10 @@ module Linguist
generated_jni_header? ||
vcr_cassette? ||
generated_module? ||
generated_unity3d_meta?
generated_unity3d_meta? ||
generated_racc? ||
generated_jflex? ||
generated_grammarkit?
end
# Internal: Is the blob an Xcode file?
@@ -241,22 +244,26 @@ module Linguist
return lines[0].include?("Code generated by")
end
PROTOBUF_EXTENSIONS = ['.py', '.java', '.h', '.cc', '.cpp']
# Internal: Is the blob a C++, Java or Python source file generated by the
# Protocol Buffer compiler?
#
# Returns true of false.
def generated_protocol_buffer?
return false unless ['.py', '.java', '.h', '.cc', '.cpp'].include?(extname)
return false unless PROTOBUF_EXTENSIONS.include?(extname)
return false unless lines.count > 1
return lines[0].include?("Generated by the protocol buffer compiler. DO NOT EDIT!")
end
APACHE_THRIFT_EXTENSIONS = ['.rb', '.py', '.go', '.js', '.m', '.java', '.h', '.cc', '.cpp']
# Internal: Is the blob generated by Apache Thrift compiler?
#
# Returns true or false
def generated_apache_thrift?
return false unless ['.rb', '.py', '.go', '.js', '.m', '.java', '.h', '.cc', '.cpp'].include?(extname)
return false unless APACHE_THRIFT_EXTENSIONS.include?(extname)
return false unless lines.count > 1
return lines[0].include?("Autogenerated by Thrift Compiler") || lines[1].include?("Autogenerated by Thrift Compiler")
@@ -355,5 +362,45 @@ module Linguist
return false unless lines.count > 1
return lines[0].include?("fileFormatVersion: ")
end
# Internal: Is this a Racc-generated file?
#
# A Racc-generated file contains:
# # This file is automatically generated by Racc x.y.z
# on the third line.
#
# Return true or false
def generated_racc?
return false unless extname == '.rb'
return false unless lines.count > 2
return lines[2].start_with?("# This file is automatically generated by Racc")
end
# Internal: Is this a JFlex-generated file?
#
# A JFlex-generated file contains:
# /* The following code was generated by JFlex x.y.z on d/at/e ti:me */
# on the first line.
#
# Return true or false
def generated_jflex?
return false unless extname == '.java'
return false unless lines.count > 1
return lines[0].start_with?("/* The following code was generated by JFlex ")
end
# Internal: Is this a GrammarKit-generated file?
#
# A GrammarKit-generated file typically contain:
# // This is a generated file. Not intended for manual editing.
# on the first line. This is not always the case, as it's possible to
# customize the class header.
#
# Return true or false
def generated_grammarkit?
return false unless extname == '.java'
return false unless lines.count > 1
return lines[0].start_with?("// This is a generated file. Not intended for manual editing.")
end
end
end

View File

@@ -33,7 +33,7 @@ module Linguist
#
# Examples
#
# disambiguate "Perl", "Prolog" do |data|
# disambiguate ".pm" do |data|
# if data.include?("use strict")
# Language["Perl"]
# elsif /^[^#]+:-/.match(data)
@@ -56,7 +56,8 @@ module Linguist
# Internal: Check if this heuristic matches the candidate languages.
def matches?(filename)
@extensions.any? { |ext| filename.downcase.end_with?(ext) }
filename = filename.downcase
@extensions.any? { |ext| filename.end_with?(ext) }
end
# Internal: Perform the heuristic
@@ -65,7 +66,17 @@ module Linguist
end
# Common heuristics
ObjectiveCRegex = /^[ \t]*@(interface|class|protocol|property|end|synchronised|selector|implementation)\b/
ObjectiveCRegex = /^\s*(@(interface|class|protocol|property|end|synchronised|selector|implementation)\b|#import\s+.+\.h[">])/
disambiguate ".asc" do |data|
if /^(----[- ]BEGIN|ssh-(rsa|dss)) /.match(data)
Language["Public Key"]
elsif /^[=-]+(\s|\n)|{{[A-Za-z]/.match(data)
Language["AsciiDoc"]
elsif /^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])/.match(data)
Language["AGS Script"]
end
end
disambiguate ".bb" do |data|
if /^\s*; /.match(data) || data.include?("End Function")
@@ -75,67 +86,9 @@ module Linguist
end
end
disambiguate ".cs" do |data|
if /![\w\s]+methodsFor: /.match(data)
Language["Smalltalk"]
elsif /^\s*namespace\s*[\w\.]+\s*{/.match(data) || /^\s*\/\//.match(data)
Language["C#"]
end
end
disambiguate ".h" do |data|
if ObjectiveCRegex.match(data)
Language["Objective-C"]
elsif (/^\s*#\s*include <(cstdint|string|vector|map|list|array|bitset|queue|stack|forward_list|unordered_map|unordered_set|(i|o|io)stream)>/.match(data) ||
/^\s*template\s*</.match(data) || /^[ \t]*try/.match(data) || /^[ \t]*catch\s*\(/.match(data) || /^[ \t]*(class|(using[ \t]+)?namespace)\s+\w+/.match(data) || /^[ \t]*(private|public|protected):$/.match(data) || /std::\w+/.match(data))
Language["C++"]
end
end
disambiguate ".pl" do |data|
if /^(use v6|(my )?class|module)/.match(data)
Language["Perl6"]
elsif /use strict|use\s+v?5\./.match(data)
Language["Perl"]
elsif /^[^#]+:-/.match(data)
Language["Prolog"]
end
end
disambiguate ".pm" do |data|
if /^(use v6|(my )?class|module)/.match(data)
Language["Perl6"]
elsif /use strict|use\s+v?5\./.match(data)
Language["Perl"]
end
end
disambiguate ".ecl" do |data|
if /^[^#]+:-/.match(data)
Language["Prolog"]
elsif data.include?(":=")
Language["ECL"]
end
end
disambiguate ".pro" do |data|
if /^[^#]+:-/.match(data)
Language["Prolog"]
elsif data.include?("last_client=")
Language["INI"]
elsif data.include?("HEADERS") && data.include?("SOURCES")
Language["QMake"]
elsif /^\s*function[ \w,]+$/.match(data)
Language["IDL"]
end
end
disambiguate ".tst" do |data|
if (data.include?("gap> "))
Language["GAP"]
# Heads up - we don't usually write heuristics like this (with no regex match)
else
Language["Scilab"]
disambiguate ".ch" do |data|
if /^\s*#\s*(if|ifdef|ifndef|define|command|xcommand|translate|xtranslate|include|pragma|undef)\b/i.match(data)
Language["xBase"]
end
end
@@ -149,40 +102,50 @@ module Linguist
end
end
disambiguate ".php" do |data|
if data.include?("<?hh")
Language["Hack"]
elsif /<?[^h]/.match(data)
Language["PHP"]
disambiguate ".cs" do |data|
if /![\w\s]+methodsFor: /.match(data)
Language["Smalltalk"]
elsif /^\s*namespace\s*[\w\.]+\s*{/.match(data) || /^\s*\/\//.match(data)
Language["C#"]
end
end
disambiguate ".sc" do |data|
if /\^(this|super)\./.match(data) || /^\s*(\+|\*)\s*\w+\s*{/.match(data) || /^\s*~\w+\s*=\./.match(data)
Language["SuperCollider"]
elsif /^\s*import (scala|java)\./.match(data) || /^\s*val\s+\w+\s*=/.match(data) || /^\s*class\b/.match(data)
Language["Scala"]
disambiguate ".d" do |data|
if /^module /.match(data)
Language["D"]
elsif /^((dtrace:::)?BEGIN|provider |#pragma (D (option|attributes)|ident)\s)/.match(data)
Language["DTrace"]
elsif /(\/.*:( .* \\)$| : \\$|^ : |: \\$)/.match(data)
Language["Makefile"]
end
end
disambiguate ".asc" do |data|
if /^(----[- ]BEGIN|ssh-(rsa|dss)) /.match(data)
Language["Public Key"]
elsif /^[=-]+(\s|\n)|{{[A-Za-z]/.match(data)
Language["AsciiDoc"]
elsif /^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])/.match(data)
Language["AGS Script"]
disambiguate ".ecl" do |data|
if /^[^#]+:-/.match(data)
Language["ECLiPSe"]
elsif data.include?(":=")
Language["ECL"]
end
end
disambiguate ".for", ".f" do |data|
if /^: /.match(data)
Language["Forth"]
elsif /^([c*][^a-z]| (subroutine|program)\s|\s*!)/i.match(data)
elsif /^([c*][^abd-z]| (subroutine|program|end)\s|\s*!)/i.match(data)
Language["FORTRAN"]
end
end
disambiguate ".fr" do |data|
if /^(: |also |new-device|previous )/.match(data)
Language["Forth"]
elsif /^\s*(import|module|package|data|type) /.match(data)
Language["Frege"]
else
Language["Text"]
end
end
disambiguate ".fs" do |data|
if /^(: |new-device)/.match(data)
Language["Forth"]
@@ -195,6 +158,47 @@ module Linguist
end
end
disambiguate ".gs" do |data|
Language["Gosu"] if /^uses java\./.match(data)
end
disambiguate ".h" do |data|
if ObjectiveCRegex.match(data)
Language["Objective-C"]
elsif (/^\s*#\s*include <(cstdint|string|vector|map|list|array|bitset|queue|stack|forward_list|unordered_map|unordered_set|(i|o|io)stream)>/.match(data) ||
/^\s*template\s*</.match(data) || /^[ \t]*try/.match(data) || /^[ \t]*catch\s*\(/.match(data) || /^[ \t]*(class|(using[ \t]+)?namespace)\s+\w+/.match(data) || /^[ \t]*(private|public|protected):$/.match(data) || /std::\w+/.match(data))
Language["C++"]
end
end
disambiguate ".l" do |data|
if /\(def(un|macro)\s/.match(data)
Language["Common Lisp"]
elsif /^(%[%{}]xs|<.*>)/.match(data)
Language["Lex"]
elsif /^\.[a-z][a-z](\s|$)/i.match(data)
Language["Groff"]
elsif /^\((de|class|rel|code|data|must)\s/.match(data)
Language["PicoLisp"]
end
end
disambiguate ".ls" do |data|
if /^\s*package\s*[\w\.\/\*\s]*\s*{/.match(data)
Language["LoomScript"]
else
Language["LiveScript"]
end
end
disambiguate ".lsp", ".lisp" do |data|
if /^\s*\((defun|in-package|defpackage) /i.match(data)
Language["Common Lisp"]
elsif /^\s*\(define /.match(data)
Language["NewLisp"]
end
end
disambiguate ".m" do |data|
if ObjectiveCRegex.match(data)
Language["Objective-C"]
@@ -213,41 +217,123 @@ module Linguist
end
end
disambiguate ".gs" do |data|
Language["Gosu"] if /^uses java\./.match(data)
end
disambiguate ".ls" do |data|
if /^\s*package\s*[\w\.\/\*\s]*\s*{/.match(data)
Language["LoomScript"]
else
Language["LiveScript"]
disambiguate ".ml" do |data|
if /(^\s*module)|let rec |match\s+(\S+\s)+with/.match(data)
Language["OCaml"]
elsif /=> |case\s+(\S+\s)+of/.match(data)
Language["Standard ML"]
end
end
disambiguate ".lsp", ".lisp" do |data|
if /^\s*\((defun|in-package|defpackage) /i.match(data)
Language["Common Lisp"]
elsif /^\s*\(define /.match(data)
disambiguate ".mod" do |data|
if data.include?('<!ENTITY ')
Language["XML"]
elsif /MODULE\s\w+\s*;/i.match(data) || /^\s*END \w+;$/i.match(data)
Language["Modula-2"]
else
[Language["Linux Kernel Module"], Language["AMPL"]]
end
end
disambiguate ".ms" do |data|
if /^[.'][a-z][a-z](\s|$)/i.match(data)
Language["Groff"]
elsif /(?<!\S)\.(include|globa?l)\s/.match(data) || /(?<!\/\*)(\A|\n)\s*\.[A-Za-z]/.match(data.gsub(/"([^\\"]|\\.)*"|'([^\\']|\\.)*'|\\\s*(?:--.*)?\n/, ""))
Language["GAS"]
else
Language["MAXScript"]
end
end
disambiguate ".n" do |data|
if /^[.']/.match(data)
Language["Groff"]
elsif /^(module|namespace|using)\s/.match(data)
Language["Nemerle"]
end
end
disambiguate ".ncl" do |data|
if data.include?("THE_TITLE")
Language["Text"]
end
end
disambiguate ".nl" do |data|
if /^(b|g)[0-9]+ /.match(data)
Language["NL"]
else
Language["NewLisp"]
end
end
disambiguate ".ts" do |data|
if data.include?("<TS ")
Language["XML"]
else
Language["TypeScript"]
disambiguate ".php" do |data|
if data.include?("<?hh")
Language["Hack"]
elsif /<?[^h]/.match(data)
Language["PHP"]
end
end
disambiguate ".fr" do |data|
if /^(: |also |new-device|previous )/.match(data)
Language["Forth"]
elsif /^\s*(import|module|package|data|type) /.match(data)
Language["Frege"]
disambiguate ".pl" do |data|
if /^[^#]+:-/.match(data)
Language["Prolog"]
elsif /use strict|use\s+v?5\./.match(data)
Language["Perl"]
elsif /^(use v6|(my )?class|module)/.match(data)
Language["Perl6"]
end
end
disambiguate ".pm", ".t" do |data|
if /use strict|use\s+v?5\./.match(data)
Language["Perl"]
elsif /^(use v6|(my )?class|module)/.match(data)
Language["Perl6"]
end
end
disambiguate ".pod" do |data|
if /^=\w+$/.match(data)
Language["Pod"]
else
Language["Text"]
Language["Perl"]
end
end
disambiguate ".pro" do |data|
if /^[^#]+:-/.match(data)
Language["Prolog"]
elsif data.include?("last_client=")
Language["INI"]
elsif data.include?("HEADERS") && data.include?("SOURCES")
Language["QMake"]
elsif /^\s*function[ \w,]+$/.match(data)
Language["IDL"]
end
end
disambiguate ".r" do |data|
if /\bRebol\b/i.match(data)
Language["Rebol"]
elsif data.include?("<-")
Language["R"]
end
end
disambiguate ".rs" do |data|
if /^(use |fn |mod |pub |macro_rules|impl|#!?\[)/.match(data)
Language["Rust"]
elsif /#include|#pragma\s+(rs|version)|__attribute__/.match(data)
Language["RenderScript"]
end
end
disambiguate ".sc" do |data|
if /\^(this|super)\./.match(data) || /^\s*(\+|\*)\s*\w+\s*{/.match(data) || /^\s*~\w+\s*=\./.match(data)
Language["SuperCollider"]
elsif /^\s*import (scala|java)\./.match(data) || /^\s*val\s+\w+\s*=/.match(data) || /^\s*class\b/.match(data)
Language["Scala"]
end
end
@@ -267,95 +353,20 @@ module Linguist
end
end
disambiguate ".d" do |data|
if /^module /.match(data)
Language["D"]
elsif /^((dtrace:::)?BEGIN|provider |#pragma (D (option|attributes)|ident)\s)/.match(data)
Language["DTrace"]
elsif /(\/.*:( .* \\)$| : \\$|^ : |: \\$)/.match(data)
Language["Makefile"]
end
end
disambiguate ".ml" do |data|
if /(^\s*module)|let rec |match\s+(\S+\s)+with/.match(data)
Language["OCaml"]
elsif /=> |case\s+(\S+\s)+of/.match(data)
Language["Standard ML"]
end
end
disambiguate ".mod" do |data|
if data.include?('<!ENTITY ')
disambiguate ".ts" do |data|
if data.include?("<TS ")
Language["XML"]
elsif /MODULE\s\w+\s*;/i.match(data) || /^\s*END \w+;$/i.match(data)
Language["Modula-2"]
else
[Language["Linux Kernel Module"], Language["AMPL"]]
Language["TypeScript"]
end
end
disambiguate ".ncl" do |data|
if data.include?("THE_TITLE")
Language["Text"]
end
end
disambiguate ".nl" do |data|
if /^(b|g)[0-9]+ /.match(data)
Language["NL"]
disambiguate ".tst" do |data|
if (data.include?("gap> "))
Language["GAP"]
# Heads up - we don't usually write heuristics like this (with no regex match)
else
Language["NewLisp"]
end
end
disambiguate ".rs" do |data|
if /^(use |fn |mod |pub |macro_rules|impl|#!?\[)/.match(data)
Language["Rust"]
elsif /#include|#pragma\s+(rs|version)|__attribute__/.match(data)
Language["RenderScript"]
end
end
disambiguate ".l" do |data|
if /\(def(un|macro)\s/.match(data)
Language["Common Lisp"]
elsif /^(%[%{}]xs|<.*>)/.match(data)
Language["Lex"]
elsif /^\.[a-z][a-z](\s|$)/i.match(data)
Language["Groff"]
elsif /^\((de|class|rel|code|data|must)\s/.match(data)
Language["PicoLisp"]
end
end
disambiguate ".n" do |data|
if /^[.']/.match(data)
Language["Groff"]
elsif /^(module|namespace|using)\s/.match(data)
Language["Nemerle"]
end
end
disambiguate ".ms" do |data|
if /^[.'][a-z][a-z](\s|$)/i.match(data)
Language["Groff"]
elsif /((^|\s)move?[. ])|\.(include|globa?l)\s/.match(data)
Language["GAS"]
end
end
disambiguate ".ch" do |data|
if /^\s*#\s*(if|ifdef|ifndef|define|command|xcommand|translate|xtranslate|include|pragma|undef)\b/i.match(data)
Language["xBase"]
end
end
disambiguate ".r" do |data|
if /\bRebol\b/i.match(data)
Language["Rebol"]
elsif data.include?("<-")
Language["R"]
Language["Scilab"]
end
end
end

270
lib/linguist/languages.yml Normal file → Executable file
View File

@@ -8,7 +8,8 @@
# Use "text" if a mode does not exist.
# wrap - Boolean wrap to enable line wrapping (default: false)
# extensions - An Array of associated extensions (the first one is
# considered the primary extension)
# considered the primary extension, the others should be
# listed alphabetically)
# interpreters - An Array of associated interpreters
# searchable - Boolean flag to enable searching (defaults to true)
# search_term - Deprecated: Some languages maybe indexed under a
@@ -141,7 +142,7 @@ Agda:
Alloy:
type: programming # 'modeling' would be more appropiate
color: "#cc5c24"
color: "#64C800"
extensions:
- .als
ace_mode: text
@@ -182,6 +183,7 @@ AppleScript:
interpreters:
- osascript
ace_mode: applescript
color: "#101F1F"
Arc:
type: programming
@@ -214,7 +216,7 @@ AspectJ:
color: "#a957b0"
extensions:
- .aj
tm_scope: none
tm_scope: source.aspectj
ace_mode: text
Assembly:
@@ -289,6 +291,7 @@ Batchfile:
- .cmd
tm_scope: source.dosbatch
ace_mode: batchfile
color: "#C1F12E"
Befunge:
type: programming
@@ -303,6 +306,7 @@ Bison:
extensions:
- .bison
ace_mode: text
color: "#6A463F"
BitBake:
type: programming
@@ -392,6 +396,7 @@ C#:
- csharp
extensions:
- .cs
- .cake
- .cshtml
- .csx
@@ -469,6 +474,13 @@ CSS:
color: "#563d7c"
extensions:
- .css
CSV:
type: data
ace_mode: text
tm_scope: none
extensions:
- .csv
Cap'n Proto:
type: programming
@@ -539,6 +551,14 @@ Clean:
tm_scope: none
ace_mode: text
Click:
type: programming
color: "#E4E6F3"
extensions:
- .click
tm_scope: source.click
ace_mode: text
Clojure:
type: programming
ace_mode: clojure
@@ -567,6 +587,7 @@ CoffeeScript:
extensions:
- .coffee
- ._coffee
- .cake
- .cjsx
- .cson
- .iced
@@ -616,6 +637,7 @@ Common Lisp:
- .lsp
- .ny
- .podsl
- .sexp
interpreters:
- lisp
- sbcl
@@ -626,7 +648,7 @@ Common Lisp:
Component Pascal:
type: programming
color: "#b0ce4e"
color: "#B0CE4E"
extensions:
- .cp
- .cps
@@ -689,6 +711,7 @@ Cucumber:
aliases:
- gherkin
ace_mode: text
color: "#5B2063"
Cuda:
type: programming
@@ -697,6 +720,7 @@ Cuda:
- .cuh
tm_scope: source.cuda-c++
ace_mode: c_cpp
color: "#3A4E3A"
Cycript:
type: programming
@@ -718,7 +742,7 @@ Cython:
D:
type: programming
color: "#fcd46d"
color: "#ba595e"
extensions:
- .d
- .di
@@ -750,6 +774,14 @@ DM:
tm_scope: source.c++
ace_mode: c_cpp
DNS Zone:
type: data
extensions:
- .zone
- .arpa
tm_scope: text.zone_file
ace_mode: text
DTrace:
type: programming
aliases:
@@ -781,7 +813,6 @@ Dart:
Diff:
type: data
color: "#88dddd"
extensions:
- .diff
- .patch
@@ -834,6 +865,14 @@ ECL:
tm_scope: none
ace_mode: text
ECLiPSe:
type: programming
group: prolog
extensions:
- .ecl
tm_scope: source.prolog.eclipse
ace_mode: prolog
Eagle:
type: markup
color: "#814C05"
@@ -867,6 +906,8 @@ Elixir:
ace_mode: elixir
filenames:
- mix.lock
interpreters:
- elixir
Elm:
type: programming
@@ -909,6 +950,8 @@ Erlang:
- .es
- .escript
- .hrl
- .xrl
- .yrl
filenames:
- rebar.config
- rebar.config.lock
@@ -994,6 +1037,7 @@ Formatted:
type: data
extensions:
- .for
- .eam.fs
tm_scope: none
ace_mode: text
@@ -1011,6 +1055,16 @@ Forth:
- .fs
ace_mode: forth
FreeMarker:
type: programming
color: "#0050b2"
aliases:
- ftl
extensions:
- .ftl
tm_scope: text.html.ftl
ace_mode: ftl
Frege:
type: programming
color: "#00cafe"
@@ -1300,11 +1354,22 @@ HTML+Django:
- .mustache
- .jinja
aliases:
- django
- html+django/jinja
- html+jinja
- htmldjango
ace_mode: django
HTML+EEX:
type: markup
tm_scope: text.html.elixir
group: HTML
aliases:
- eex
extensions:
- .eex
ace_mode: text
HTML+ERB:
type: markup
tm_scope: text.html.erb
@@ -1314,7 +1379,7 @@ HTML+ERB:
extensions:
- .erb
- .erb.deface
ace_mode: html_ruby
ace_mode: text
HTML+PHP:
type: markup
@@ -1338,6 +1403,7 @@ Hack:
- .hh
- .php
tm_scope: text.html.php
color: "#878787"
Haml:
group: HTML
@@ -1346,10 +1412,12 @@ Haml:
- .haml
- .haml.deface
ace_mode: haml
color: "#ECE2A9"
Handlebars:
type: markup
color: "#01a9d6"
group: HTML
aliases:
- hbs
- htmlbars
@@ -1457,7 +1525,7 @@ Inform 7:
extensions:
- .ni
- .i7x
tm_scope: source.Inform7
tm_scope: source.inform7
aliases:
- i7
- inform7
@@ -1528,7 +1596,9 @@ JSON:
searchable: false
extensions:
- .json
- .geojson
- .lock
- .topojson
filenames:
- .jshintrc
- composer.lock
@@ -1556,12 +1626,20 @@ JSONiq:
- .jq
tm_scope: source.jq
JSX:
type: programming
group: JavaScript
extensions:
- .jsx
tm_scope: source.js.jsx
ace_mode: javascript
Jade:
group: HTML
type: markup
extensions:
- .jade
tm_scope: source.jade
tm_scope: text.jade
ace_mode: jade
Jasmin:
@@ -1606,10 +1684,10 @@ JavaScript:
- .gs
- .jake
- .jsb
- .jscad
- .jsfl
- .jsm
- .jss
- .jsx
- .njs
- .pac
- .sjs
@@ -1641,6 +1719,18 @@ Julia:
color: "#a270ba"
ace_mode: julia
Jupyter Notebook:
type: markup
ace_mode: json
tm_scope: source.json
color: "#DA5B0B"
extensions:
- .ipynb
filenames:
- Notebook
aliases:
- IPython Notebook
KRL:
type: programming
color: "#28431f"
@@ -1653,6 +1743,7 @@ KiCad:
type: programming
extensions:
- .sch
- .brd
- .kicad_pcb
tm_scope: none
ace_mode: text
@@ -1688,6 +1779,7 @@ LLVM:
extensions:
- .ll
ace_mode: text
color: "#185619"
LOLCODE:
type: programming
@@ -1702,6 +1794,7 @@ LSL:
ace_mode: lsl
extensions:
- .lsl
- .lslp
interpreters:
- lsl
color: '#3d9970'
@@ -1710,8 +1803,8 @@ LabVIEW:
type: programming
extensions:
- .lvproj
tm_scope: none
ace_mode: text
tm_scope: text.xml
ace_mode: xml
Lasso:
type: programming
@@ -1750,6 +1843,7 @@ Less:
- .less
tm_scope: source.css.less
ace_mode: less
color: "#A1D9A1"
Lex:
type: programming
@@ -1901,6 +1995,15 @@ M:
tm_scope: source.lisp
ace_mode: lisp
MAXScript:
type: programming
color: "#00a6a6"
extensions:
- .ms
- .mcr
tm_scope: source.maxscript
ace_mode: text
MTML:
type: markup
color: "#b7e1f4"
@@ -1933,6 +2036,8 @@ Makefile:
- GNUmakefile
- Kbuild
- Makefile
- Makefile.am
- Makefile.in
- Makefile.inc
- makefile
interpreters:
@@ -1959,6 +2064,7 @@ Markdown:
- .mkdown
- .ron
tm_scope: source.gfm
color: "#083FA1"
Mask:
type: markup
@@ -1975,6 +2081,7 @@ Mathematica:
- .cdf
- .m
- .ma
- .mt
- .nb
- .nbp
- .wl
@@ -1986,6 +2093,8 @@ Mathematica:
Matlab:
type: programming
color: "#bb92ac"
aliases:
- octave
extensions:
- .matlab
- .m
@@ -2019,6 +2128,7 @@ MediaWiki:
wrap: true
extensions:
- .mediawiki
- .wiki
tm_scope: text.html.mediawiki
ace_mode: text
@@ -2034,6 +2144,14 @@ Mercury:
tm_scope: source.mercury
ace_mode: prolog
Metal:
type: programming
color: "#8f14e9"
extensions:
- .metal
tm_scope: source.c++
ace_mode: c_cpp
MiniD: # Legacy
type: programming
searchable: false
@@ -2109,7 +2227,7 @@ Myghty:
NCL:
type: programming
color: #28431f
color: "#28431f"
extensions:
- .ncl
tm_scope: source.ncl
@@ -2186,6 +2304,7 @@ Nginx:
aliases:
- nginx configuration file
ace_mode: text
color: "#9469E9"
Nimrod:
type: programming
@@ -2244,6 +2363,7 @@ NumPy:
- .numsc
tm_scope: none
ace_mode: text
color: "#9C8AF9"
OCaml:
type: programming
@@ -2412,6 +2532,7 @@ PHP:
- .php3
- .php4
- .php5
- .phps
- .phpt
filenames:
- Phakefile
@@ -2425,8 +2546,10 @@ PLSQL:
type: programming
ace_mode: sql
tm_scope: source.plsql.oracle
color: "#dad8d8"
extensions:
- .pls
- .pck
- .pkb
- .pks
- .plb
@@ -2441,6 +2564,16 @@ PLpgSQL:
extensions:
- .sql
POV-Ray SDL:
type: programming
aliases:
- pov-ray
- povray
extensions:
- .pov
- .inc
ace_mode: text
Pan:
type: programming
color: '#cc0000'
@@ -2491,7 +2624,7 @@ Parrot Internal Representation:
Pascal:
type: programming
color: "#b0ce4e"
color: "#E3F171"
extensions:
- .pas
- .dfm
@@ -2540,9 +2673,16 @@ Perl6:
- Rexfile
interpreters:
- perl6
tm_scope: source.perl.6
tm_scope: source.perl6fe
ace_mode: perl
Pickle:
type: data
extensions:
- .pkl
tm_scope: none
ace_mode: text
PicoLisp:
type: programming
extensions:
@@ -2587,6 +2727,13 @@ PogoScript:
tm_scope: source.pogoscript
ace_mode: text
Pony:
type: programming
extensions:
- .pony
tm_scope: source.pony
ace_mode: text
PostScript:
type: markup
extensions:
@@ -2619,11 +2766,13 @@ Prolog:
color: "#74283c"
extensions:
- .pl
- .ecl
- .pro
- .prolog
- .yap
interpreters:
- swipl
- yap
tm_scope: source.prolog
ace_mode: prolog
Propeller Spin:
@@ -2692,6 +2841,7 @@ Python:
color: "#3572A5"
extensions:
- .py
- .bzl
- .cgi
- .fcgi
- .gyp
@@ -2745,7 +2895,7 @@ QMake:
R:
type: programming
color: "#198ce7"
color: "#198CE7"
aliases:
- R
- Rscript
@@ -2761,7 +2911,7 @@ R:
ace_mode: r
RAML:
type: data
type: markup
ace_mode: yaml
tm_scope: source.yaml
color: "#77d9fb"
@@ -2775,6 +2925,7 @@ RDoc:
extensions:
- .rdoc
tm_scope: text.rdoc
color: "#8E84BF"
REALbasic:
type: programming
@@ -2804,7 +2955,7 @@ RMarkdown:
ace_mode: markdown
extensions:
- .rmd
tm_scope: none
tm_scope: source.gfm
Racket:
type: programming
@@ -2870,6 +3021,17 @@ Redcode:
tm_scope: none
ace_mode: text
Ren'Py:
type: programming
group: Python
aliases:
- renpy
color: "#ff7f7f"
extensions:
- .rpy
tm_scope: source.renpy
ace_mode: python
RenderScript:
type: programming
extensions:
@@ -2955,6 +3117,7 @@ Rust:
color: "#dea584"
extensions:
- .rs
- .rs.in
ace_mode: rust
SAS:
@@ -2972,6 +3135,7 @@ SCSS:
ace_mode: scss
extensions:
- .scss
color: "#CF649A"
SMT:
type: programming
@@ -3074,11 +3238,12 @@ Sass:
extensions:
- .sass
ace_mode: sass
color: "#CF649A"
Scala:
type: programming
ace_mode: scala
color: "#7dd3b0"
color: "#DC322F"
extensions:
- .scala
- .sbt
@@ -3131,6 +3296,7 @@ Shell:
color: "#89e051"
aliases:
- sh
- shell-script
- bash
- zsh
extensions:
@@ -3141,6 +3307,7 @@ Shell:
- .command
- .fcgi
- .ksh
- .sh.in
- .tmux
- .tool
- .zsh
@@ -3230,6 +3397,14 @@ Squirrel:
tm_scope: source.c++
ace_mode: c_cpp
Stan:
type: programming
color: "#b2011d"
extensions:
- .stan
ace_mode: text
tm_scope: source.stan
Standard ML:
type: programming
color: "#dc566d"
@@ -3267,9 +3442,12 @@ SuperCollider:
type: programming
color: "#46390b"
extensions:
- .scd
- .sc
tm_scope: none
- .scd
interpreters:
- sclang
- scsynth
tm_scope: source.supercollider
ace_mode: text
Swift:
@@ -3412,6 +3590,7 @@ TypeScript:
- ts
extensions:
- .ts
- .tsx
tm_scope: source.ts
ace_mode: typescript
@@ -3427,7 +3606,6 @@ Unified Parallel C:
Unity3D Asset:
type: data
ace_mode: yaml
color: "#ab69a1"
extensions:
- .anim
- .asset
@@ -3437,6 +3615,13 @@ Unity3D Asset:
- .unity
tm_scope: source.yaml
Uno:
type: programming
extensions:
- .uno
ace_mode: csharp
tm_scope: source.cs
UnrealScript:
type: programming
color: "#a54c4d"
@@ -3445,6 +3630,17 @@ UnrealScript:
tm_scope: source.java
ace_mode: java
UrWeb:
type: programming
aliases:
- Ur/Web
- Ur
extensions:
- .ur
- .urs
tm_scope: source.ur
ace_mode: text
VCL:
group: Perl
type: programming
@@ -3550,6 +3746,16 @@ WebIDL:
tm_scope: source.webidl
ace_mode: text
X10:
type: programming
aliases:
- xten
ace_mode: text
extensions:
- .x10
color: "#4B6BEF"
tm_scope: source.x10
XC:
type: programming
color: "#99DA07"
@@ -3572,6 +3778,7 @@ XML:
- .ccxml
- .clixml
- .cproject
- .csl
- .csproj
- .ct
- .dita
@@ -3587,6 +3794,7 @@ XML:
- .iml
- .ivy
- .jelly
- .jsproj
- .kml
- .launch
- .mdpolicy
@@ -3617,8 +3825,10 @@ XML:
- .tmSnippet
- .tmTheme
- .ts
- .tsx
- .ui
- .urdf
- .ux
- .vbproj
- .vcxproj
- .vxml
@@ -3635,6 +3845,7 @@ XML:
- .xliff
- .xmi
- .xml.dist
- .xproj
- .xsd
- .xul
- .zcml
@@ -3691,6 +3902,7 @@ XSLT:
- .xsl
tm_scope: text.xml.xsl
ace_mode: xml
color: "#EB8CEB"
Xojo:
type: programming
@@ -3724,6 +3936,13 @@ YAML:
- .yaml-tmlanguage
ace_mode: yaml
YANG:
type: data
extensions:
- .yang
tm_scope: source.yang
ace_mode: text
Yacc:
type: programming
extensions:
@@ -3732,6 +3951,7 @@ Yacc:
- .yy
tm_scope: source.bison
ace_mode: text
color: "#4B6C4B"
Zephir:
type: programming
@@ -3771,7 +3991,6 @@ eC:
edn:
type: data
ace_mode: clojure
color: "#db5855"
extensions:
- .edn
tm_scope: source.clojure
@@ -3813,7 +4032,10 @@ reStructuredText:
extensions:
- .rst
- .rest
- .rest.txt
- .rst.txt
ace_mode: text
color: "#B3BCBC"
wisp:
type: programming

View File

@@ -4,7 +4,11 @@ require 'rugged'
module Linguist
class LazyBlob
GIT_ATTR = ['linguist-documentation', 'linguist-language', 'linguist-vendored']
GIT_ATTR = ['linguist-documentation',
'linguist-language',
'linguist-vendored',
'linguist-generated']
GIT_ATTR_OPTS = { :priority => [:index], :skip_system => true }
GIT_ATTR_FLAGS = Rugged::Repository::Attributes.parse_opts(GIT_ATTR_OPTS)
@@ -31,14 +35,6 @@ module Linguist
name, GIT_ATTR, GIT_ATTR_FLAGS)
end
def vendored?
if attr = git_attributes['linguist-vendored']
return boolean_attribute(attr)
else
return super
end
end
def documentation?
if attr = git_attributes['linguist-documentation']
boolean_attribute(attr)
@@ -47,6 +43,22 @@ module Linguist
end
end
def generated?
if attr = git_attributes['linguist-generated']
boolean_attribute(attr)
else
super
end
end
def vendored?
if attr = git_attributes['linguist-vendored']
return boolean_attribute(attr)
else
super
end
end
def language
return @language if defined?(@language)
@@ -67,11 +79,15 @@ module Linguist
@size
end
def cleanup!
@data.clear if @data
end
protected
# Returns true if the attribute is present and not the string "false".
def boolean_attribute(attr)
attr != "false"
def boolean_attribute(attribute)
attribute != "false"
end
def load_blob!

View File

@@ -126,12 +126,13 @@ module Linguist
end
protected
MAX_TREE_SIZE = 100_000
def compute_stats(old_commit_oid, cache = nil)
return {} if current_tree.count_recursive(MAX_TREE_SIZE) >= MAX_TREE_SIZE
old_tree = old_commit_oid && Rugged::Commit.lookup(repository, old_commit_oid).tree
read_index
diff = Rugged::Tree.diff(repository, old_tree, current_tree)
# Clear file map and fetch full diff if any .gitattributes files are changed
@@ -157,8 +158,11 @@ module Linguist
blob = Linguist::LazyBlob.new(repository, delta.new_file[:oid], new, mode.to_s(8))
next unless blob.include_in_language_stats?
file_map[new] = [blob.language.group.name, blob.size]
if blob.include_in_language_stats?
file_map[new] = [blob.language.group.name, blob.size]
end
blob.cleanup!
end
end

View File

@@ -1,8 +1,19 @@
module Linguist
module Strategy
class Modeline
EmacsModeline = /-\*-\s*(?:(?!mode)[\w-]+\s*:\s*(?:[\w+-]+)\s*;?\s*)*(?:mode\s*:)?\s*([\w+-]+)\s*(?:;\s*(?!mode)[\w-]+\s*:\s*[\w+-]+\s*)*;?\s*-\*-/i
VimModeline = /vim:\s*set.*\s(?:ft|filetype)=(\w+)\s?.*:/i
EMACS_MODELINE = /-\*-\s*(?:(?!mode)[\w-]+\s*:\s*(?:[\w+-]+)\s*;?\s*)*(?:mode\s*:)?\s*([\w+-]+)\s*(?:;\s*(?!mode)[\w-]+\s*:\s*[\w+-]+\s*)*;?\s*-\*-/i
# First form vim modeline
# [text]{white}{vi:|vim:|ex:}[white]{options}
# ex: 'vim: syntax=ruby'
VIM_MODELINE_1 = /(?:vim|vi|ex):\s*(?:ft|filetype|syntax)=(\w+)\s?/i
# Second form vim modeline (compatible with some versions of Vi)
# [text]{white}{vi:|vim:|Vim:|ex:}[white]se[t] {options}:[text]
# ex: 'vim set syntax=ruby:'
VIM_MODELINE_2 = /(?:vim|vi|Vim|ex):\s*se(?:t)?.*\s(?:ft|filetype|syntax)=(\w+)\s?.*:/i
MODELINES = [EMACS_MODELINE, VIM_MODELINE_1, VIM_MODELINE_2]
# Public: Detects language based on Vim and Emacs modelines
#
@@ -22,7 +33,7 @@ module Linguist
#
# Returns a String or nil
def self.modeline(data)
match = data.match(EmacsModeline) || data.match(VimModeline)
match = MODELINES.map { |regex| data.match(regex) }.reject(&:nil?).first
match[1] if match
end
end

View File

@@ -86,13 +86,13 @@ module Linguist
if s.peek(1) == "\""
s.getch
else
s.skip_until(/[^\\]"/)
s.skip_until(/(?<!\\)"/)
end
elsif s.scan(/'/)
if s.peek(1) == "'"
s.getch
else
s.skip_until(/[^\\]'/)
s.skip_until(/(?<!\\)'/)
end
# Skip number literals

View File

@@ -78,6 +78,9 @@
# Haxelib projects often contain a neko bytecode file named run.n
- run.n$
# Bootstrap Datepicker
- bootstrap-datepicker/
## Commonly Bundled JavaScript frameworks ##
# jQuery
@@ -88,6 +91,34 @@
- (^|/)jquery\-ui(\-\d\.\d+(\.\d+)?)?(\.\w+)?\.(js|css)$
- (^|/)jquery\.(ui|effects)\.([^.]*)\.(js|css)$
# jQuery Gantt
- jquery.fn.gantt.js
# jQuery fancyBox
- jquery.fancybox.(js|css)
# Fuel UX
- fuelux.js
# jQuery File Upload
- (^|/)jquery\.fileupload(-\w+)?\.js$
# Slick
- (^|/)slick\.\w+.js$
# Leaflet plugins
- (^|/)Leaflet\.Coordinates-\d+\.\d+\.\d+\.src\.js$
- leaflet.draw-src.js
- leaflet.draw.css
- Control.FullScreen.css
- Control.FullScreen.js
- leaflet.spin.js
- wicket-leaflet.js
# Sublime Text workspace files
- .sublime-project
- .sublime-workspace
# Prototype
- (^|/)prototype(.*)\.js$
- (^|/)effects\.js$
@@ -122,7 +153,7 @@
- (^|/)Chart\.js$
# Codemirror
- (^|/)[Cc]ode[Mm]irror/(lib|mode|theme|addon|keymap|demo)
- (^|/)[Cc]ode[Mm]irror/(\d+\.\d+/)?(lib|mode|theme|addon|keymap|demo)
# SyntaxHighlighter - http://alexgorbatchev.com/
- (^|/)shBrush([^.]*)\.js$
@@ -164,6 +195,11 @@
## Obj-C ##
# Xcode
- \.xctemplate/
- \.imageset/
# Carthage
- ^Carthage/
@@ -179,6 +215,10 @@
# Fabric
- Fabric.framework/
# git config files
- gitattributes$
- gitignore$
- gitmodules$
## Groovy ##
@@ -224,21 +264,9 @@
# Html5shiv
- (^|/)html5shiv\.js$
# Samples folders
- ^[Ss]amples/
# LICENSE, README, git config files
- ^COPYING$
- LICENSE$
- License$
- gitattributes$
- gitignore$
- gitmodules$
- ^README$
- ^readme$
# Test fixtures
- ^[Tt]ests?/fixtures/
- ^[Ss]pecs?/fixtures/
# PhoneGap/Cordova
- (^|/)cordova([^.]*)\.js$

View File

@@ -1,3 +1,3 @@
module Linguist
VERSION = "4.5.13"
VERSION = "4.7.6"
end

86
samples/C#/build.cake Normal file
View File

@@ -0,0 +1,86 @@
///////////////////////////////////////////////////////////////////////////////
// ARGUMENTS
///////////////////////////////////////////////////////////////////////////////
var target = Argument<string>("target", "Default");
var configuration = Argument<string>("configuration", "Release");
///////////////////////////////////////////////////////////////////////////////
// GLOBAL VARIABLES
///////////////////////////////////////////////////////////////////////////////
var solutions = GetFiles("./**/*.sln");
var solutionPaths = solutions.Select(solution => solution.GetDirectory());
///////////////////////////////////////////////////////////////////////////////
// SETUP / TEARDOWN
///////////////////////////////////////////////////////////////////////////////
Setup(() =>
{
// Executed BEFORE the first task.
Information("Running tasks...");
});
Teardown(() =>
{
// Executed AFTER the last task.
Information("Finished running tasks.");
});
///////////////////////////////////////////////////////////////////////////////
// TASK DEFINITIONS
///////////////////////////////////////////////////////////////////////////////
Task("Clean")
.Does(() =>
{
// Clean solution directories.
foreach(var path in solutionPaths)
{
Information("Cleaning {0}", path);
CleanDirectories(path + "/**/bin/" + configuration);
CleanDirectories(path + "/**/obj/" + configuration);
}
});
Task("Restore")
.Does(() =>
{
// Restore all NuGet packages.
foreach(var solution in solutions)
{
Information("Restoring {0}...", solution);
NuGetRestore(solution);
}
});
Task("Build")
.IsDependentOn("Clean")
.IsDependentOn("Restore")
.Does(() =>
{
// Build all solutions.
foreach(var solution in solutions)
{
Information("Building {0}", solution);
MSBuild(solution, settings =>
settings.SetPlatformTarget(PlatformTarget.MSIL)
.WithProperty("TreatWarningsAsErrors","true")
.WithTarget("Build")
.SetConfiguration(configuration));
}
});
///////////////////////////////////////////////////////////////////////////////
// TARGETS
///////////////////////////////////////////////////////////////////////////////
Task("Default")
.IsDependentOn("Build");
///////////////////////////////////////////////////////////////////////////////
// EXECUTION
///////////////////////////////////////////////////////////////////////////////
RunTarget(target);

View File

@@ -1,3 +1,3 @@
Year,Make,Model,Length
1997,Ford,E350,2.34
2000,Mercury,Cougar,2.38
2000,Mercury,Cougar,2.38
1 Year Make Model Length
2 1997 Ford E350 2.34
3 2000 Mercury Cougar 2.38

133
samples/Click/sr2.click Normal file
View File

@@ -0,0 +1,133 @@
rates :: AvailableRates
elementclass sr2 {
$sr2_ip, $sr2_nm, $wireless_mac, $gateway, $probes|
arp :: ARPTable();
lt :: LinkTable(IP $sr2_ip);
gw :: SR2GatewaySelector(ETHTYPE 0x062c,
IP $sr2_ip,
ETH $wireless_mac,
LT lt,
ARP arp,
PERIOD 15,
GW $gateway);
gw -> SR2SetChecksum -> [0] output;
set_gw :: SR2SetGateway(SEL gw);
es :: SR2ETTStat(ETHTYPE 0x0641,
ETH $wireless_mac,
IP $sr2_ip,
PERIOD 30000,
TAU 300000,
ARP arp,
PROBES $probes,
ETT metric,
RT rates);
metric :: SR2ETTMetric(LT lt);
forwarder :: SR2Forwarder(ETHTYPE 0x0643,
IP $sr2_ip,
ETH $wireless_mac,
ARP arp,
LT lt);
querier :: SR2Querier(ETH $wireless_mac,
SR forwarder,
LT lt,
ROUTE_DAMPENING true,
TIME_BEFORE_SWITCH 5,
DEBUG true);
query_forwarder :: SR2MetricFlood(ETHTYPE 0x0644,
IP $sr2_ip,
ETH $wireless_mac,
LT lt,
ARP arp,
DEBUG false);
query_responder :: SR2QueryResponder(ETHTYPE 0x0645,
IP $sr2_ip,
ETH $wireless_mac,
LT lt,
ARP arp,
DEBUG true);
query_responder -> SR2SetChecksum -> [0] output;
query_forwarder -> SR2SetChecksum -> SR2Print(forwarding) -> [0] output;
query_forwarder [1] -> query_responder;
data_ck :: SR2SetChecksum()
input [1]
-> host_cl :: IPClassifier(dst net $sr2_ip mask $sr2_nm,
-)
-> querier
-> data_ck;
host_cl [1] -> [0] set_gw [0] -> querier;
forwarder[0]
-> dt ::DecIPTTL
-> data_ck
-> [2] output;
dt[1]
-> Print(ttl-error)
-> ICMPError($sr2_ip, timeexceeded, 0)
-> querier;
// queries
querier [1] -> [1] query_forwarder;
es -> SetTimestamp() -> [1] output;
forwarder[1] //ip packets to me
-> SR2StripHeader()
-> CheckIPHeader()
-> from_gw_cl :: IPClassifier(src net $sr2_ip mask $sr2_nm,
-)
-> [3] output;
from_gw_cl [1] -> [1] set_gw [1] -> [3] output;
input [0]
-> ncl :: Classifier(
12/0643 , //sr2_forwarder
12/0644 , //sr2
12/0645 , //replies
12/0641 , //sr2_es
12/062c , //sr2_gw
);
ncl[0] -> SR2CheckHeader() -> [0] forwarder;
ncl[1] -> SR2CheckHeader() -> PrintSR(query) -> query_forwarder
ncl[2] -> SR2CheckHeader() -> query_responder;
ncl[3] -> es;
ncl[4] -> SR2CheckHeader() -> gw;
}
Idle -> s :: sr2(2.0.0.1, 255.0.0.0, 00:00:00:00:00:01, false, "12 60 12 1500") -> Discard;
Idle -> [1] s;
s[1] -> Discard;
s[2] -> Discard;
s[3] -> Discard;

View File

@@ -0,0 +1,142 @@
// This Click configuration implements a firewall and NAT, roughly based on the
// mazu-nat.click example.
//
// This example assumes there is one interface that is IP-aliased. In this
// example, eth0 and eth0:0 have IP addresses 66.68.65.90 and 192.168.1.1,
// respectively. There is a local network, 192.168.1.0/24, and an upstream
// gateway, 66.58.65.89. Traffic from the local network is NATed.
//
// Connections can be initiated from the NAT box itself, also.
//
// For bugs, suggestions, and, corrections, please email me.
//
// Author: Thomer M. Gil (click@thomer.com)
AddressInfo(
eth0-in 192.168.1.1 192.168.1.0/24 00:0d:87:9d:1c:e9,
eth0-ex 66.58.65.90 00:0d:87:9d:1c:e9,
gw-addr 66.58.65.89 00:20:6f:14:54:c2
);
elementclass SniffGatewayDevice {
$device |
from :: FromDevice($device)
-> t1 :: Tee
-> output;
input -> q :: Queue(1024)
-> t2 :: PullTee
-> to :: ToDevice($device);
t1[1] -> ToHostSniffers;
t2[1] -> ToHostSniffers($device);
ScheduleInfo(from .1, to 1);
}
device :: SniffGatewayDevice(eth0);
arpq_in :: ARPQuerier(eth0-in) -> device;
ip_to_extern :: GetIPAddress(16)
-> CheckIPHeader
-> EtherEncap(0x800, eth0-ex, gw-addr)
-> device;
ip_to_host :: EtherEncap(0x800, gw-addr, eth0-ex)
-> ToHost;
ip_to_intern :: GetIPAddress(16)
-> CheckIPHeader
-> arpq_in;
arp_class :: Classifier(
12/0806 20/0001, // [0] ARP requests
12/0806 20/0002, // [1] ARP replies to host
12/0800); // [2] IP packets
device -> arp_class;
// ARP crap
arp_class[0] -> ARPResponder(eth0-in, eth0-ex) -> device;
arp_class[1] -> arp_t :: Tee;
arp_t[0] -> ToHost;
arp_t[1] -> [1]arpq_in;
// IP packets
arp_class[2] -> Strip(14)
-> CheckIPHeader
-> ipclass :: IPClassifier(dst host eth0-ex,
dst host eth0-in,
src net eth0-in);
// Define pattern NAT
iprw :: IPRewriterPatterns(NAT eth0-ex 50000-65535 - -);
// Rewriting rules for UDP/TCP packets
// output[0] rewritten to go into the wild
// output[1] rewritten to come back from the wild or no match
rw :: IPRewriter(pattern NAT 0 1,
pass 1);
// Rewriting rules for ICMP packets
irw :: ICMPPingRewriter(eth0-ex, -);
irw[0] -> ip_to_extern;
irw[1] -> icmp_me_or_intern :: IPClassifier(dst host eth0-ex, -);
icmp_me_or_intern[0] -> ip_to_host;
icmp_me_or_intern[1] -> ip_to_intern;
// Rewriting rules for ICMP error packets
ierw :: ICMPRewriter(rw irw);
ierw[0] -> icmp_me_or_intern;
ierw[1] -> icmp_me_or_intern;
// Packets directed at eth0-ex.
// Send it through IPRewriter(pass). If there was a mapping, it will be
// rewritten such that dst is eth0-in:net, otherwise dst will still be for
// eth0-ex.
ipclass[0] -> [1]rw;
// packets that were rewritten, heading into the wild world.
rw[0] -> ip_to_extern;
// packets that come back from the wild or are not part of an established
// connection.
rw[1] -> established_class :: IPClassifier(dst host eth0-ex,
dst net eth0-in);
// not established yet or returning packets for a connection that was
// established from this host itself.
established_class[0] ->
firewall :: IPClassifier(dst tcp port ssh,
dst tcp port smtp,
dst tcp port domain,
dst udp port domain,
icmp type echo-reply,
proto icmp,
port > 4095,
-);
firewall[0] -> ip_to_host; // ssh
firewall[1] -> ip_to_host; // smtp
firewall[2] -> ip_to_host; // domain (t)
firewall[3] -> ip_to_host; // domain (u)
firewall[4] -> [0]irw; // icmp reply
firewall[5] -> [0]ierw; // other icmp
firewall[6] -> ip_to_host; // port > 4095, probably for connection
// originating from host itself
firewall[7] -> Discard; // don't allow incoming for port <= 4095
// established connection
established_class[1] -> ip_to_intern;
// To eth0-in. Only accept from inside network.
ipclass[1] -> IPClassifier(src net eth0-in) -> ip_to_host;
// Packets from eth0-in:net either stay on local network or go to the wild.
// Those that go into the wild need to go through the appropriate rewriting
// element. (Either UDP/TCP rewriter or ICMP rewriter.)
ipclass[2] -> inter_class :: IPClassifier(dst net eth0-in, -);
inter_class[0] -> ip_to_intern;
inter_class[1] -> ip_udp_class :: IPClassifier(tcp or udp,
icmp type echo);
ip_udp_class[0] -> [0]rw;
ip_udp_class[1] -> [0]irw;

View File

@@ -0,0 +1,17 @@
fs = require 'fs'
{print} = require 'sys'
{spawn} = require 'child_process'
build = (callback) ->
coffee = spawn 'coffee', ['-c', '-o', '.', '.']
coffee.stderr.on 'data', (data) ->
process.stderr.write data.toString()
coffee.stdout.on 'data', (data) ->
print data.toString()
coffee.on 'exit', (code) ->
callback?() if code is 0
task 'build', 'Build from source', ->
build()

View File

@@ -0,0 +1,2 @@
((exe_name hello)
(link_order (world hello)))

View File

@@ -0,0 +1,103 @@
(:TURTLE
(:@PREFIX "rdf:" "<http://www.w3.org/1999/02/22-rdf-syntax-ns#>")
(:@PREFIX "owl:" "<http://www.w3.org/2002/07/owl#>")
(:@PREFIX "dc:" "<http://purl.org/dc/elements/1.1/>")
(:@PREFIX "xsd:" "<http://www.w3.org/2001/XMLSchema#>")
(:@PREFIX "rdfs:" "<http://www.w3.org/2000/01/rdf-schema#>")
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/channel>")
(:PREDICATE-OBJECT-LIST
(:URIREF #1="<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>")
(:OBJECTS
(:QNAME "rdfs:Class")))
(:PREDICATE-OBJECT-LIST
(:QNAME "rdfs:comment")
(:OBJECTS
(:STRING "An RSS information channel.")))
(:PREDICATE-OBJECT-LIST
(:QNAME "rdfs:isDefinedBy")
(:OBJECTS
(:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST
(:QNAME "rdfs:label")
(:OBJECTS
(:STRING "Channel"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/description>")
(:PREDICATE-OBJECT-LIST
(:URIREF #1#)
(:OBJECTS
(:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS (:STRING "A short text description of the subject.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Description")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:subPropertyOf") (:OBJECTS (:QNAME "dc:description"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/image>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdfs:Class")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment") (:OBJECTS (:STRING "An RSS image.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Image"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/item>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdfs:Class")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment") (:OBJECTS (:STRING "An RSS item.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Item"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/items>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS
(:STRING "Points to a list of rss:item elements that are members of the subject channel.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Items"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/link>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS (:STRING "The URL to which an HTML rendering of the subject will link.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Link")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:subPropertyOf") (:OBJECTS (:QNAME "dc:identifier"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/name>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS (:STRING "The text input field's (variable) name.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Name"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/textinput>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdfs:Class")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment") (:OBJECTS (:STRING "An RSS text input.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Text Input"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/title>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS (:STRING "A descriptive title for the channel.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "Title")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:subPropertyOf") (:OBJECTS (:QNAME "dc:title"))))
(:TRIPLES (:URIREF "<http://purl.org/rss/1.0/url>")
(:PREDICATE-OBJECT-LIST (:URIREF #1#) (:OBJECTS (:QNAME "rdf:Property")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:comment")
(:OBJECTS
(:STRING
"The URL of the image to used in the 'src' attribute of the channel's image tag when rendered as HTML.")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:isDefinedBy")
(:OBJECTS (:URIREF "<http://purl.org/rss/1.0/>")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:label") (:OBJECTS (:STRING "URL")))
(:PREDICATE-OBJECT-LIST (:QNAME "rdfs:subPropertyOf") (:OBJECTS (:QNAME "dc:identifier")))))

View File

@@ -0,0 +1,13 @@
$ORIGIN 0.0.0.c.2.1.0.3.0.0.2.1.e.f.f.3.ip6.arpa.
$TTL 60
@ IN SOA ns root (
2002042901 ; SERIAL
7200 ; REFRESH
600 ; RETRY
36000000 ; EXPIRE
120 ; MINIMUM
)
NS ns.example.com.
c.a.7.e.d.7.e.f.f.f.0.2.8.0.a.0 PTR sip01.example.com.

View File

@@ -0,0 +1,12 @@
$TTL 3d
@ IN SOA root.localhost. root.sneaky.net. (
2015042907 ; serial
3d ; refresh
1h ; retry
12d ; expire
2h ; negative response TTL
)
IN NS root.localhost.
IN NS localhost. ; secondary name server is preferably externally maintained
www IN A 3.141.59.26

View File

@@ -0,0 +1,856 @@
Nonterminals
grammar expr_list
expr container_expr block_expr access_expr
no_parens_expr no_parens_zero_expr no_parens_one_expr no_parens_one_ambig_expr
bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr max_expr
unmatched_op_expr matched_op_expr no_parens_op_expr no_parens_many_expr
comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol capture_op_eol
add_op_eol mult_op_eol two_op_eol three_op_eol pipe_op_eol stab_op_eol
arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol
type_op_eol rel_op_eol
open_paren close_paren empty_paren eoe
list list_args open_bracket close_bracket
tuple open_curly close_curly
bit_string open_bit close_bit
map map_op map_close map_args map_expr struct_op
assoc_op_eol assoc_expr assoc_base assoc_update assoc_update_kw assoc
container_args_base container_args
call_args_parens_expr call_args_parens_base call_args_parens parens_call
call_args_no_parens_one call_args_no_parens_ambig call_args_no_parens_expr
call_args_no_parens_comma_expr call_args_no_parens_all call_args_no_parens_many
call_args_no_parens_many_strict
stab stab_eoe stab_expr stab_op_eol_and_expr stab_parens_many
kw_eol kw_base kw call_args_no_parens_kw_expr call_args_no_parens_kw
dot_op dot_alias dot_alias_container
dot_identifier dot_op_identifier dot_do_identifier
dot_paren_identifier dot_bracket_identifier
do_block fn_eoe do_eoe end_eoe block_eoe block_item block_list
.
Terminals
identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier
paren_identifier do_identifier block_identifier
fn 'end' aliases
number atom atom_safe atom_unsafe bin_string list_string sigil
dot_call_op op_identifier
comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op
type_op dual_op add_op mult_op two_op three_op pipe_op stab_op when_op assoc_op
capture_op rel_op
'true' 'false' 'nil' 'do' eol ';' ',' '.'
'(' ')' '[' ']' '{' '}' '<<' '>>' '%{}' '%'
.
Rootsymbol grammar.
%% Two shift/reduce conflicts coming from call_args_parens.
Expect 2.
%% Changes in ops and precedence should be reflected on lib/elixir/lib/macro.ex
%% Note though the operator => in practice has lower precedence than all others,
%% its entry in the table is only to support the %{user | foo => bar} syntax.
Left 5 do.
Right 10 stab_op_eol. %% ->
Left 20 ','.
Nonassoc 30 capture_op_eol. %% &
Left 40 in_match_op_eol. %% <-, \\ (allowed in matches along =)
Right 50 when_op_eol. %% when
Right 60 type_op_eol. %% ::
Right 70 pipe_op_eol. %% |
Right 80 assoc_op_eol. %% =>
Right 90 match_op_eol. %% =
Left 130 or_op_eol. %% ||, |||, or
Left 140 and_op_eol. %% &&, &&&, and
Left 150 comp_op_eol. %% ==, !=, =~, ===, !==
Left 160 rel_op_eol. %% <, >, <=, >=
Left 170 arrow_op_eol. %% |>, <<<, >>>, ~>>, <<~, ~>, <~, <~>, <|>
Left 180 in_op_eol. %% in
Left 190 three_op_eol. %% ^^^
Right 200 two_op_eol. %% ++, --, .., <>
Left 210 add_op_eol. %% +, -
Left 220 mult_op_eol. %% *, /
Nonassoc 300 unary_op_eol. %% +, -, !, ^, not, ~~~
Left 310 dot_call_op.
Left 310 dot_op. %% .
Nonassoc 320 at_op_eol. %% @
Nonassoc 330 dot_identifier.
%%% MAIN FLOW OF EXPRESSIONS
grammar -> eoe : nil.
grammar -> expr_list : to_block('$1').
grammar -> eoe expr_list : to_block('$2').
grammar -> expr_list eoe : to_block('$1').
grammar -> eoe expr_list eoe : to_block('$2').
grammar -> '$empty' : nil.
% Note expressions are on reverse order
expr_list -> expr : ['$1'].
expr_list -> expr_list eoe expr : ['$3'|'$1'].
expr -> matched_expr : '$1'.
expr -> no_parens_expr : '$1'.
expr -> unmatched_expr : '$1'.
%% In Elixir we have three main call syntaxes: with parentheses,
%% without parentheses and with do blocks. They are represented
%% in the AST as matched, no_parens and unmatched.
%%
%% Calls without parentheses are further divided according to how
%% problematic they are:
%%
%% (a) no_parens_one: a call with one unproblematic argument
%% (e.g. `f a` or `f g a` and similar) (includes unary operators)
%%
%% (b) no_parens_many: a call with several arguments (e.g. `f a, b`)
%%
%% (c) no_parens_one_ambig: a call with one argument which is
%% itself a no_parens_many or no_parens_one_ambig (e.g. `f g a, b`
%% or `f g h a, b` and similar)
%%
%% Note, in particular, that no_parens_one_ambig expressions are
%% ambiguous and are interpreted such that the outer function has
%% arity 1 (e.g. `f g a, b` is interpreted as `f(g(a, b))` rather
%% than `f(g(a), b)`). Hence the name, no_parens_one_ambig.
%%
%% The distinction is required because we can't, for example, have
%% a function call with a do block as argument inside another do
%% block call, unless there are parentheses:
%%
%% if if true do true else false end do #=> invalid
%% if(if true do true else false end) do #=> valid
%%
%% Similarly, it is not possible to nest calls without parentheses
%% if their arity is more than 1:
%%
%% foo a, bar b, c #=> invalid
%% foo(a, bar b, c) #=> invalid
%% foo bar a, b #=> valid
%% foo a, bar(b, c) #=> valid
%%
%% So the different grammar rules need to take into account
%% if calls without parentheses are do blocks in particular
%% segments and act accordingly.
matched_expr -> matched_expr matched_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
matched_expr -> unary_op_eol matched_expr : build_unary_op('$1', '$2').
matched_expr -> at_op_eol matched_expr : build_unary_op('$1', '$2').
matched_expr -> capture_op_eol matched_expr : build_unary_op('$1', '$2').
matched_expr -> no_parens_one_expr : '$1'.
matched_expr -> no_parens_zero_expr : '$1'.
matched_expr -> access_expr : '$1'.
matched_expr -> access_expr kw_identifier : throw_invalid_kw_identifier('$2').
unmatched_expr -> matched_expr unmatched_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
unmatched_expr -> unmatched_expr matched_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
unmatched_expr -> unmatched_expr unmatched_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
unmatched_expr -> unmatched_expr no_parens_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
unmatched_expr -> unary_op_eol expr : build_unary_op('$1', '$2').
unmatched_expr -> at_op_eol expr : build_unary_op('$1', '$2').
unmatched_expr -> capture_op_eol expr : build_unary_op('$1', '$2').
unmatched_expr -> block_expr : '$1'.
no_parens_expr -> matched_expr no_parens_op_expr : build_op(element(1, '$2'), '$1', element(2, '$2')).
no_parens_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2').
no_parens_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2').
no_parens_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2').
no_parens_expr -> no_parens_one_ambig_expr : '$1'.
no_parens_expr -> no_parens_many_expr : '$1'.
block_expr -> parens_call call_args_parens do_block : build_identifier('$1', '$2' ++ '$3').
block_expr -> parens_call call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3' ++ '$4').
block_expr -> dot_do_identifier do_block : build_identifier('$1', '$2').
block_expr -> dot_identifier call_args_no_parens_all do_block : build_identifier('$1', '$2' ++ '$3').
matched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> add_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> two_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> three_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}.
matched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}.
%% Warn for no parens subset
matched_op_expr -> arrow_op_eol no_parens_one_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.
unmatched_op_expr -> match_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> add_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> mult_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> two_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> three_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> and_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> or_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> in_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> in_match_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> type_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> when_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> pipe_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> comp_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> rel_op_eol unmatched_expr : {'$1', '$2'}.
unmatched_op_expr -> arrow_op_eol unmatched_expr : {'$1', '$2'}.
no_parens_op_expr -> match_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> add_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> mult_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> two_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> three_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> and_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> or_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> in_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> in_match_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> type_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> pipe_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> comp_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> rel_op_eol no_parens_expr : {'$1', '$2'}.
no_parens_op_expr -> arrow_op_eol no_parens_expr : {'$1', '$2'}.
%% Warn for no parens subset
no_parens_op_expr -> arrow_op_eol no_parens_one_ambig_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.
no_parens_op_expr -> arrow_op_eol no_parens_many_expr : warn_pipe('$1', '$2'), {'$1', '$2'}.
%% Allow when (and only when) with keywords
no_parens_op_expr -> when_op_eol call_args_no_parens_kw : {'$1', '$2'}.
no_parens_one_ambig_expr -> dot_op_identifier call_args_no_parens_ambig : build_identifier('$1', '$2').
no_parens_one_ambig_expr -> dot_identifier call_args_no_parens_ambig : build_identifier('$1', '$2').
no_parens_many_expr -> dot_op_identifier call_args_no_parens_many_strict : build_identifier('$1', '$2').
no_parens_many_expr -> dot_identifier call_args_no_parens_many_strict : build_identifier('$1', '$2').
no_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_identifier('$1', '$2').
no_parens_one_expr -> dot_identifier call_args_no_parens_one : build_identifier('$1', '$2').
no_parens_zero_expr -> dot_do_identifier : build_identifier('$1', nil).
no_parens_zero_expr -> dot_identifier : build_identifier('$1', nil).
%% From this point on, we just have constructs that can be
%% used with the access syntax. Notice that (dot_)identifier
%% is not included in this list simply because the tokenizer
%% marks identifiers followed by brackets as bracket_identifier.
access_expr -> bracket_at_expr : '$1'.
access_expr -> bracket_expr : '$1'.
access_expr -> at_op_eol number : build_unary_op('$1', ?exprs('$2')).
access_expr -> unary_op_eol number : build_unary_op('$1', ?exprs('$2')).
access_expr -> capture_op_eol number : build_unary_op('$1', ?exprs('$2')).
access_expr -> fn_eoe stab end_eoe : build_fn('$1', reverse('$2')).
access_expr -> open_paren stab close_paren : build_stab(reverse('$2')).
access_expr -> open_paren stab ';' close_paren : build_stab(reverse('$2')).
access_expr -> open_paren ';' stab ';' close_paren : build_stab(reverse('$3')).
access_expr -> open_paren ';' stab close_paren : build_stab(reverse('$3')).
access_expr -> open_paren ';' close_paren : build_stab([]).
access_expr -> empty_paren : nil.
access_expr -> number : ?exprs('$1').
access_expr -> list : element(1, '$1').
access_expr -> map : '$1'.
access_expr -> tuple : '$1'.
access_expr -> 'true' : ?id('$1').
access_expr -> 'false' : ?id('$1').
access_expr -> 'nil' : ?id('$1').
access_expr -> bin_string : build_bin_string('$1').
access_expr -> list_string : build_list_string('$1').
access_expr -> bit_string : '$1'.
access_expr -> sigil : build_sigil('$1').
access_expr -> max_expr : '$1'.
%% Aliases and properly formed calls. Used by map_expr.
max_expr -> atom : ?exprs('$1').
max_expr -> atom_safe : build_quoted_atom('$1', true).
max_expr -> atom_unsafe : build_quoted_atom('$1', false).
max_expr -> parens_call call_args_parens : build_identifier('$1', '$2').
max_expr -> parens_call call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3').
max_expr -> dot_alias : '$1'.
bracket_arg -> open_bracket kw close_bracket : build_list('$1', '$2').
bracket_arg -> open_bracket container_expr close_bracket : build_list('$1', '$2').
bracket_arg -> open_bracket container_expr ',' close_bracket : build_list('$1', '$2').
bracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1', nil), '$2').
bracket_expr -> access_expr bracket_arg : build_access('$1', '$2').
bracket_at_expr -> at_op_eol dot_bracket_identifier bracket_arg :
build_access(build_unary_op('$1', build_identifier('$2', nil)), '$3').
bracket_at_expr -> at_op_eol access_expr bracket_arg :
build_access(build_unary_op('$1', '$2'), '$3').
%% Blocks
do_block -> do_eoe 'end' : [[{do, nil}]].
do_block -> do_eoe stab end_eoe : [[{do, build_stab(reverse('$2'))}]].
do_block -> do_eoe block_list 'end' : [[{do, nil}|'$2']].
do_block -> do_eoe stab_eoe block_list 'end' : [[{do, build_stab(reverse('$2'))}|'$3']].
eoe -> eol : '$1'.
eoe -> ';' : '$1'.
eoe -> eol ';' : '$1'.
fn_eoe -> 'fn' : '$1'.
fn_eoe -> 'fn' eoe : '$1'.
do_eoe -> 'do' : '$1'.
do_eoe -> 'do' eoe : '$1'.
end_eoe -> 'end' : '$1'.
end_eoe -> eoe 'end' : '$2'.
block_eoe -> block_identifier : '$1'.
block_eoe -> block_identifier eoe : '$1'.
stab -> stab_expr : ['$1'].
stab -> stab eoe stab_expr : ['$3'|'$1'].
stab_eoe -> stab : '$1'.
stab_eoe -> stab eoe : '$1'.
%% Here, `element(1, Token)` is the stab operator,
%% while `element(2, Token)` is the expression.
stab_expr -> expr :
'$1'.
stab_expr -> stab_op_eol_and_expr :
build_op(element(1, '$1'), [], element(2, '$1')).
stab_expr -> empty_paren stab_op_eol_and_expr :
build_op(element(1, '$2'), [], element(2, '$2')).
stab_expr -> call_args_no_parens_all stab_op_eol_and_expr :
build_op(element(1, '$2'), unwrap_when(unwrap_splice('$1')), element(2, '$2')).
stab_expr -> stab_parens_many stab_op_eol_and_expr :
build_op(element(1, '$2'), unwrap_splice('$1'), element(2, '$2')).
stab_expr -> stab_parens_many when_op expr stab_op_eol_and_expr :
build_op(element(1, '$4'), [{'when', meta_from_token('$2'), unwrap_splice('$1') ++ ['$3']}], element(2, '$4')).
stab_op_eol_and_expr -> stab_op_eol expr : {'$1', '$2'}.
stab_op_eol_and_expr -> stab_op_eol : warn_empty_stab_clause('$1'), {'$1', nil}.
block_item -> block_eoe stab_eoe : {?exprs('$1'), build_stab(reverse('$2'))}.
block_item -> block_eoe : {?exprs('$1'), nil}.
block_list -> block_item : ['$1'].
block_list -> block_item block_list : ['$1'|'$2'].
%% Helpers
open_paren -> '(' : '$1'.
open_paren -> '(' eol : '$1'.
close_paren -> ')' : '$1'.
close_paren -> eol ')' : '$2'.
empty_paren -> open_paren ')' : '$1'.
open_bracket -> '[' : '$1'.
open_bracket -> '[' eol : '$1'.
close_bracket -> ']' : '$1'.
close_bracket -> eol ']' : '$2'.
open_bit -> '<<' : '$1'.
open_bit -> '<<' eol : '$1'.
close_bit -> '>>' : '$1'.
close_bit -> eol '>>' : '$2'.
open_curly -> '{' : '$1'.
open_curly -> '{' eol : '$1'.
close_curly -> '}' : '$1'.
close_curly -> eol '}' : '$2'.
% Operators
add_op_eol -> add_op : '$1'.
add_op_eol -> add_op eol : '$1'.
add_op_eol -> dual_op : '$1'.
add_op_eol -> dual_op eol : '$1'.
mult_op_eol -> mult_op : '$1'.
mult_op_eol -> mult_op eol : '$1'.
two_op_eol -> two_op : '$1'.
two_op_eol -> two_op eol : '$1'.
three_op_eol -> three_op : '$1'.
three_op_eol -> three_op eol : '$1'.
pipe_op_eol -> pipe_op : '$1'.
pipe_op_eol -> pipe_op eol : '$1'.
capture_op_eol -> capture_op : '$1'.
capture_op_eol -> capture_op eol : '$1'.
unary_op_eol -> unary_op : '$1'.
unary_op_eol -> unary_op eol : '$1'.
unary_op_eol -> dual_op : '$1'.
unary_op_eol -> dual_op eol : '$1'.
match_op_eol -> match_op : '$1'.
match_op_eol -> match_op eol : '$1'.
and_op_eol -> and_op : '$1'.
and_op_eol -> and_op eol : '$1'.
or_op_eol -> or_op : '$1'.
or_op_eol -> or_op eol : '$1'.
in_op_eol -> in_op : '$1'.
in_op_eol -> in_op eol : '$1'.
in_match_op_eol -> in_match_op : '$1'.
in_match_op_eol -> in_match_op eol : '$1'.
type_op_eol -> type_op : '$1'.
type_op_eol -> type_op eol : '$1'.
when_op_eol -> when_op : '$1'.
when_op_eol -> when_op eol : '$1'.
stab_op_eol -> stab_op : '$1'.
stab_op_eol -> stab_op eol : '$1'.
at_op_eol -> at_op : '$1'.
at_op_eol -> at_op eol : '$1'.
comp_op_eol -> comp_op : '$1'.
comp_op_eol -> comp_op eol : '$1'.
rel_op_eol -> rel_op : '$1'.
rel_op_eol -> rel_op eol : '$1'.
arrow_op_eol -> arrow_op : '$1'.
arrow_op_eol -> arrow_op eol : '$1'.
% Dot operator
dot_op -> '.' : '$1'.
dot_op -> '.' eol : '$1'.
dot_identifier -> identifier : '$1'.
dot_identifier -> matched_expr dot_op identifier : build_dot('$2', '$1', '$3').
dot_alias -> aliases : {'__aliases__', meta_from_token('$1', 0), ?exprs('$1')}.
dot_alias -> matched_expr dot_op aliases : build_dot_alias('$2', '$1', '$3').
dot_alias -> matched_expr dot_op dot_alias_container : build_dot_container('$2', '$1', '$3').
dot_alias_container -> open_curly '}' : [].
dot_alias_container -> open_curly container_args close_curly : '$2'.
dot_op_identifier -> op_identifier : '$1'.
dot_op_identifier -> matched_expr dot_op op_identifier : build_dot('$2', '$1', '$3').
dot_do_identifier -> do_identifier : '$1'.
dot_do_identifier -> matched_expr dot_op do_identifier : build_dot('$2', '$1', '$3').
dot_bracket_identifier -> bracket_identifier : '$1'.
dot_bracket_identifier -> matched_expr dot_op bracket_identifier : build_dot('$2', '$1', '$3').
dot_paren_identifier -> paren_identifier : '$1'.
dot_paren_identifier -> matched_expr dot_op paren_identifier : build_dot('$2', '$1', '$3').
parens_call -> dot_paren_identifier : '$1'.
parens_call -> matched_expr dot_call_op : {'.', meta_from_token('$2'), ['$1']}. % Fun/local calls
% Function calls with no parentheses
call_args_no_parens_expr -> matched_expr : '$1'.
call_args_no_parens_expr -> no_parens_expr : throw_no_parens_many_strict('$1').
call_args_no_parens_comma_expr -> matched_expr ',' call_args_no_parens_expr : ['$3', '$1'].
call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3'|'$1'].
call_args_no_parens_all -> call_args_no_parens_one : '$1'.
call_args_no_parens_all -> call_args_no_parens_ambig : '$1'.
call_args_no_parens_all -> call_args_no_parens_many : '$1'.
call_args_no_parens_one -> call_args_no_parens_kw : ['$1'].
call_args_no_parens_one -> matched_expr : ['$1'].
call_args_no_parens_ambig -> no_parens_expr : ['$1'].
call_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw : ['$1', '$3'].
call_args_no_parens_many -> call_args_no_parens_comma_expr : reverse('$1').
call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3'|'$1']).
call_args_no_parens_many_strict -> call_args_no_parens_many : '$1'.
call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : throw_no_parens_strict('$1').
call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : throw_no_parens_strict('$1').
stab_parens_many -> open_paren call_args_no_parens_kw close_paren : ['$2'].
stab_parens_many -> open_paren call_args_no_parens_many close_paren : '$2'.
% Containers
container_expr -> matched_expr : '$1'.
container_expr -> unmatched_expr : '$1'.
container_expr -> no_parens_expr : throw_no_parens_container_strict('$1').
container_args_base -> container_expr : ['$1'].
container_args_base -> container_args_base ',' container_expr : ['$3'|'$1'].
container_args -> container_args_base : lists:reverse('$1').
container_args -> container_args_base ',' : lists:reverse('$1').
container_args -> container_args_base ',' kw : lists:reverse(['$3'|'$1']).
% Function calls with parentheses
call_args_parens_expr -> matched_expr : '$1'.
call_args_parens_expr -> unmatched_expr : '$1'.
call_args_parens_expr -> no_parens_expr : throw_no_parens_many_strict('$1').
call_args_parens_base -> call_args_parens_expr : ['$1'].
call_args_parens_base -> call_args_parens_base ',' call_args_parens_expr : ['$3'|'$1'].
call_args_parens -> empty_paren : [].
call_args_parens -> open_paren no_parens_expr close_paren : ['$2'].
call_args_parens -> open_paren kw close_paren : ['$2'].
call_args_parens -> open_paren call_args_parens_base close_paren : reverse('$2').
call_args_parens -> open_paren call_args_parens_base ',' kw close_paren : reverse(['$4'|'$2']).
% KV
kw_eol -> kw_identifier : ?exprs('$1').
kw_eol -> kw_identifier eol : ?exprs('$1').
kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true).
kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true).
kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false).
kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false).
kw_base -> kw_eol container_expr : [{'$1', '$2'}].
kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'}|'$1'].
kw -> kw_base : reverse('$1').
kw -> kw_base ',' : reverse('$1').
call_args_no_parens_kw_expr -> kw_eol matched_expr : {'$1', '$2'}.
call_args_no_parens_kw_expr -> kw_eol no_parens_expr : {'$1', '$2'}.
call_args_no_parens_kw -> call_args_no_parens_kw_expr : ['$1'].
call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1'|'$3'].
% Lists
list_args -> kw : '$1'.
list_args -> container_args_base : reverse('$1').
list_args -> container_args_base ',' : reverse('$1').
list_args -> container_args_base ',' kw : reverse('$1', '$3').
list -> open_bracket ']' : build_list('$1', []).
list -> open_bracket list_args close_bracket : build_list('$1', '$2').
% Tuple
tuple -> open_curly '}' : build_tuple('$1', []).
tuple -> open_curly container_args close_curly : build_tuple('$1', '$2').
% Bitstrings
bit_string -> open_bit '>>' : build_bit('$1', []).
bit_string -> open_bit container_args close_bit : build_bit('$1', '$2').
% Map and structs
%% Allow unquote/@something/aliases inside maps and structs.
map_expr -> max_expr : '$1'.
map_expr -> dot_identifier : build_identifier('$1', nil).
map_expr -> at_op_eol map_expr : build_unary_op('$1', '$2').
assoc_op_eol -> assoc_op : '$1'.
assoc_op_eol -> assoc_op eol : '$1'.
assoc_expr -> matched_expr assoc_op_eol matched_expr : {'$1', '$3'}.
assoc_expr -> unmatched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}.
assoc_expr -> matched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}.
assoc_expr -> unmatched_expr assoc_op_eol matched_expr : {'$1', '$3'}.
assoc_expr -> map_expr : '$1'.
assoc_update -> matched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.
assoc_update -> unmatched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}.
assoc_update_kw -> matched_expr pipe_op_eol kw : {'$2', '$1', '$3'}.
assoc_update_kw -> unmatched_expr pipe_op_eol kw : {'$2', '$1', '$3'}.
assoc_base -> assoc_expr : ['$1'].
assoc_base -> assoc_base ',' assoc_expr : ['$3'|'$1'].
assoc -> assoc_base : reverse('$1').
assoc -> assoc_base ',' : reverse('$1').
map_op -> '%{}' : '$1'.
map_op -> '%{}' eol : '$1'.
map_close -> kw close_curly : '$1'.
map_close -> assoc close_curly : '$1'.
map_close -> assoc_base ',' kw close_curly : reverse('$1', '$3').
map_args -> open_curly '}' : build_map('$1', []).
map_args -> open_curly map_close : build_map('$1', '$2').
map_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', []).
map_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', []).
map_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', '$4').
map_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', []).
struct_op -> '%' : '$1'.
map -> map_op map_args : '$2'.
map -> struct_op map_expr map_args : {'%', meta_from_token('$1'), ['$2', '$3']}.
map -> struct_op map_expr eol map_args : {'%', meta_from_token('$1'), ['$2', '$4']}.
Erlang code.
-define(file(), get(elixir_parser_file)).
-define(id(Token), element(1, Token)).
-define(location(Token), element(2, Token)).
-define(exprs(Token), element(3, Token)).
-define(meta(Node), element(2, Node)).
-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')).
%% The following directive is needed for (significantly) faster
%% compilation of the generated .erl file by the HiPE compiler
-compile([{hipe, [{regalloc, linear_scan}]}]).
-import(lists, [reverse/1, reverse/2]).
meta_from_token(Token, Counter) -> [{counter, Counter}|meta_from_token(Token)].
meta_from_token(Token) -> meta_from_location(?location(Token)).
meta_from_location({Line, Column, EndColumn})
when is_integer(Line), is_integer(Column), is_integer(EndColumn) -> [{line, Line}].
%% Operators
build_op({_Kind, Location, 'in'}, {UOp, _, [Left]}, Right) when ?rearrange_uop(UOp) ->
{UOp, meta_from_location(Location), [{'in', meta_from_location(Location), [Left, Right]}]};
build_op({_Kind, Location, Op}, Left, Right) ->
{Op, meta_from_location(Location), [Left, Right]}.
build_unary_op({_Kind, Location, Op}, Expr) ->
{Op, meta_from_location(Location), [Expr]}.
build_list(Marker, Args) ->
{Args, ?location(Marker)}.
build_tuple(_Marker, [Left, Right]) ->
{Left, Right};
build_tuple(Marker, Args) ->
{'{}', meta_from_token(Marker), Args}.
build_bit(Marker, Args) ->
{'<<>>', meta_from_token(Marker), Args}.
build_map(Marker, Args) ->
{'%{}', meta_from_token(Marker), Args}.
build_map_update(Marker, {Pipe, Left, Right}, Extra) ->
{'%{}', meta_from_token(Marker), [build_op(Pipe, Left, Right ++ Extra)]}.
%% Blocks
build_block([{Op, _, [_]}]=Exprs) when ?rearrange_uop(Op) -> {'__block__', [], Exprs};
build_block([{unquote_splicing, _, Args}]=Exprs) when
length(Args) =< 2 -> {'__block__', [], Exprs};
build_block([Expr]) -> Expr;
build_block(Exprs) -> {'__block__', [], Exprs}.
%% Dots
build_dot_alias(Dot, {'__aliases__', _, Left}, {'aliases', _, Right}) ->
{'__aliases__', meta_from_token(Dot), Left ++ Right};
build_dot_alias(_Dot, Atom, {'aliases', _, _} = Token) when is_atom(Atom) ->
throw_bad_atom(Token);
build_dot_alias(Dot, Other, {'aliases', _, Right}) ->
{'__aliases__', meta_from_token(Dot), [Other|Right]}.
build_dot_container(Dot, Left, Right) ->
Meta = meta_from_token(Dot),
{{'.', Meta, [Left, '{}']}, Meta, Right}.
build_dot(Dot, Left, Right) ->
{'.', meta_from_token(Dot), [Left, extract_identifier(Right)]}.
extract_identifier({Kind, _, Identifier}) when
Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier;
Kind == do_identifier; Kind == op_identifier ->
Identifier.
%% Identifiers
build_nested_parens(Dot, Args1, Args2) ->
Identifier = build_identifier(Dot, Args1),
Meta = ?meta(Identifier),
{Identifier, Meta, Args2}.
build_identifier({'.', Meta, _} = Dot, Args) ->
FArgs = case Args of
nil -> [];
_ -> Args
end,
{Dot, Meta, FArgs};
build_identifier({op_identifier, Location, Identifier}, [Arg]) ->
{Identifier, [{ambiguous_op, nil}|meta_from_location(Location)], [Arg]};
build_identifier({_, Location, Identifier}, Args) ->
{Identifier, meta_from_location(Location), Args}.
%% Fn
build_fn(Op, [{'->', _, [_, _]}|_] = Stab) ->
{fn, meta_from_token(Op), build_stab(Stab)};
build_fn(Op, _Stab) ->
throw(meta_from_token(Op), "expected clauses to be defined with -> inside: ", "'fn'").
%% Access
build_access(Expr, {List, Location}) ->
Meta = meta_from_location(Location),
{{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}.
%% Interpolation aware
build_sigil({sigil, Location, Sigil, Parts, Modifiers}) ->
Meta = meta_from_location(Location),
{list_to_atom("sigil_" ++ [Sigil]), Meta, [{'<<>>', Meta, string_parts(Parts)}, Modifiers]}.
build_bin_string({bin_string, _Location, [H]}) when is_binary(H) ->
H;
build_bin_string({bin_string, Location, Args}) ->
{'<<>>', meta_from_location(Location), string_parts(Args)}.
build_list_string({list_string, _Location, [H]}) when is_binary(H) ->
elixir_utils:characters_to_list(H);
build_list_string({list_string, Location, Args}) ->
Meta = meta_from_location(Location),
{{'.', Meta, ['Elixir.String', to_char_list]}, Meta, [{'<<>>', Meta, string_parts(Args)}]}.
build_quoted_atom({_, _Location, [H]}, Safe) when is_binary(H) ->
Op = binary_to_atom_op(Safe), erlang:Op(H, utf8);
build_quoted_atom({_, Location, Args}, Safe) ->
Meta = meta_from_location(Location),
{{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, Meta, [{'<<>>', Meta, string_parts(Args)}, utf8]}.
binary_to_atom_op(true) -> binary_to_existing_atom;
binary_to_atom_op(false) -> binary_to_atom.
string_parts(Parts) ->
[string_part(Part) || Part <- Parts].
string_part(Binary) when is_binary(Binary) ->
Binary;
string_part({Location, Tokens}) ->
Form = string_tokens_parse(Tokens),
Meta = meta_from_location(Location),
{'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, Meta, [Form]}, {binary, Meta, nil}]}.
string_tokens_parse(Tokens) ->
case parse(Tokens) of
{ok, Forms} -> Forms;
{error, _} = Error -> throw(Error)
end.
%% Keywords
build_stab([{'->', Meta, [Left, Right]}|T]) ->
build_stab(Meta, T, Left, [Right], []);
build_stab(Else) ->
build_block(Else).
build_stab(Old, [{'->', New, [Left, Right]}|T], Marker, Temp, Acc) ->
H = {'->', Old, [Marker, build_block(reverse(Temp))]},
build_stab(New, T, Left, [Right], [H|Acc]);
build_stab(Meta, [H|T], Marker, Temp, Acc) ->
build_stab(Meta, T, Marker, [H|Temp], Acc);
build_stab(Meta, [], Marker, Temp, Acc) ->
H = {'->', Meta, [Marker, build_block(reverse(Temp))]},
reverse([H|Acc]).
%% Every time the parser sees a (unquote_splicing())
%% it assumes that a block is being spliced, wrapping
%% the splicing in a __block__. But in the stab clause,
%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such
%% case, we don't actually want the block, since it is
%% an arg style call. unwrap_splice unwraps the splice
%% from such blocks.
unwrap_splice([{'__block__', [], [{unquote_splicing, _, _}] = Splice}]) ->
Splice;
unwrap_splice(Other) -> Other.
unwrap_when(Args) ->
case elixir_utils:split_last(Args) of
{Start, {'when', Meta, [_, _] = End}} ->
[{'when', Meta, Start ++ End}];
{_, _} ->
Args
end.
to_block([One]) -> One;
to_block(Other) -> {'__block__', [], reverse(Other)}.
%% Warnings and errors
throw(Meta, Error, Token) ->
Line =
case lists:keyfind(line, 1, Meta) of
{line, L} -> L;
false -> 0
end,
throw({error, {Line, ?MODULE, [Error, Token]}}).
throw_bad_atom(Token) ->
throw(meta_from_token(Token), "atom cannot be followed by an alias. If the '.' was meant to be "
"part of the atom's name, the atom name must be quoted. Syntax error before: ", "'.'").
throw_no_parens_strict(Token) ->
throw(meta_from_token(Token), "unexpected parentheses. If you are making a "
"function call, do not insert spaces between the function name and the "
"opening parentheses. Syntax error before: ", "'('").
throw_no_parens_many_strict(Node) ->
throw(?meta(Node),
"unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n"
"This error happens when you have nested function calls without parentheses. "
"For example:\n\n"
" one a, two b, c, d\n\n"
"In the example above, we don't know if the parameters \"c\" and \"d\" apply "
"to the function \"one\" or \"two\". You can solve this by explicitly adding "
"parentheses:\n\n"
" one a, two(b, c, d)\n\n"
"Elixir cannot compile otherwise. Syntax error before: ", "','").
throw_no_parens_container_strict(Node) ->
throw(?meta(Node),
"unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n"
"This error may happen when you forget a comma in a list or other container:\n\n"
" [a, b c, d]\n\n"
"Or when you have ambiguous calls:\n\n"
" [one, two three, four, five]\n\n"
"In the example above, we don't know if the parameters \"four\" and \"five\" "
"belongs to the list or the function \"two\". You can solve this by explicitly "
"adding parentheses:\n\n"
" [one, two(three, four), five]\n\n"
"Elixir cannot compile otherwise. Syntax error before: ", "','").
throw_invalid_kw_identifier({_, _, do} = Token) ->
throw(meta_from_token(Token), elixir_tokenizer:invalid_do_error("unexpected keyword \"do:\""), "'do:'");
throw_invalid_kw_identifier({_, _, KW} = Token) ->
throw(meta_from_token(Token), "syntax error before: ", "'" ++ atom_to_list(KW) ++ "':").
%% TODO: Make those warnings errors.
warn_empty_stab_clause({stab_op, {Line, _Begin, _End}, '->'}) ->
elixir_errors:warn(Line, ?file(),
"an expression is always required on the right side of ->. "
"Please provide a value after ->").
warn_pipe({arrow_op, {Line, _Begin, _End}, Op}, {_, [_|_], [_|_]}) ->
elixir_errors:warn(Line, ?file(),
io_lib:format(
"you are piping into a function call without parentheses, which may be ambiguous. "
"Please wrap the function you are piping into in parentheses. For example:\n\n"
" foo 1 ~ts bar 2 ~ts baz 3\n\n"
"Should be written as:\n\n"
" foo(1) ~ts bar(2) ~ts baz(3)\n",
[Op, Op, Op, Op]
)
);
warn_pipe(_Token, _) ->
ok.

256
samples/Erlang/lfe_scan.xrl Normal file
View File

@@ -0,0 +1,256 @@
%% Copyright (c) 2008-2013 Robert Virding
%%
%% 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.
%% File : lfe_scan.xrl
%% Author : Robert Virding
%% Purpose : Token definitions for Lisp Flavoured Erlang.
Definitions.
B = [01]
O = [0-7]
D = [0-9]
H = [0-9a-fA-F]
B36 = [0-9a-zA-Z]
U = [A-Z]
L = [a-z]
A = ({U}|{L})
DEL = [][()}{";\000-\s]
SYM = [^][()}{";\000-\s\177-\237]
SSYM = [^][()}{"|;#`',\000-\s\177-\237]
WS = ([\000-\s]|;[^\n]*)
Rules.
%% Bracketed Comments using #| foo |#
#{D}*\|[^\|]*\|+([^#\|][^\|]*\|+)*# :
block_comment(string:substr(TokenChars, 3)).
%% Separators
' : {token,{'\'',TokenLine}}.
` : {token,{'`',TokenLine}}.
, : {token,{',',TokenLine}}.
,@ : {token,{',@',TokenLine}}.
\. : {token,{'.',TokenLine}}.
[][()}{] : {token,{list_to_atom(TokenChars),TokenLine}}.
#{D}*[bB]\( : {token,{'#B(',TokenLine}}.
#{D}*[mM]\( : {token,{'#M(',TokenLine}}.
#{D}*\( : {token,{'#(',TokenLine}}.
#{D}*\. : {token,{'#.',TokenLine}}.
#{D}*` : {token,{'#`',TokenLine}}.
#{D}*; : {token,{'#;',TokenLine}}.
#{D}*, : {token,{'#,',TokenLine}}.
#{D}*,@ : {token,{'#,@',TokenLine}}.
%% Characters
#{D}*\\(x{H}+|.) : char_token(skip_past(TokenChars, $\\, $\\), TokenLine).
%% Based numbers
#{D}*\*{SYM}+ : base_token(skip_past(TokenChars, $*, $*), 2, TokenLine).
#{D}*[bB]{SYM}+ : base_token(skip_past(TokenChars, $b, $B), 2, TokenLine).
#{D}*[oO]{SYM}+ : base_token(skip_past(TokenChars, $o, $O), 8, TokenLine).
#{D}*[dD]{SYM}+ : base_token(skip_past(TokenChars, $d, $D), 10, TokenLine).
#{D}*[xX]{SYM}+ : base_token(skip_past(TokenChars, $x, $X), 16, TokenLine).
#{D}*[rR]{SYM}+ :
%% Scan over digit chars to get base.
{Base,[_|Ds]} = base1(tl(TokenChars), 10, 0),
base_token(Ds, Base, TokenLine).
%% String
"(\\x{H}+;|\\.|[^"\\])*" :
%% Strip quotes.
S = string:substr(TokenChars, 2, TokenLen - 2),
{token,{string,TokenLine,chars(S)}}.
%% Binary string
#"(\\x{H}+;|\\.|[^"\\])*" :
%% Strip quotes.
S = string:substr(TokenChars, 3, TokenLen - 3),
Bin = unicode:characters_to_binary(chars(S), utf8, utf8),
{token,{binary,TokenLine,Bin}}.
%% Symbols
\|(\\x{H}+;|\\.|[^|\\])*\| :
%% Strip quotes.
S = string:substr(TokenChars, 2, TokenLen - 2),
symbol_token(chars(S), TokenLine).
%% Funs
#'{SSYM}{SYM}*/{D}+ :
%% Strip sharpsign single-quote.
FunStr = string:substr(TokenChars,3),
{token,{'#\'',TokenLine,FunStr}}.
%% Atoms
[+-]?{D}+ :
case catch {ok,list_to_integer(TokenChars)} of
{ok,I} -> {token,{number,TokenLine,I}};
_ -> {error,"illegal integer"}
end.
[+-]?{D}+\.{D}+([eE][+-]?{D}+)? :
case catch {ok,list_to_float(TokenChars)} of
{ok,F} -> {token,{number,TokenLine,F}};
_ -> {error,"illegal float"}
end.
{SSYM}{SYM}* :
symbol_token(TokenChars, TokenLine).
{WS}+ : skip_token.
Erlang code.
%% Copyright (c) 2008-2013 Robert Virding
%%
%% 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.
%% File : lfe_scan.erl
%% Author : Robert Virding
%% Purpose : Token definitions for Lisp Flavoured Erlang.
-export([start_symbol_char/1,symbol_char/1]).
-import(string, [substr/2,substr/3]).
%% start_symbol_char(Char) -> true | false.
%% symbol_char(Char) -> true | false.
%% Define start symbol chars and symbol chars.
start_symbol_char($#) -> false;
start_symbol_char($`) -> false;
start_symbol_char($') -> false; %'
start_symbol_char($,) -> false;
start_symbol_char($|) -> false; %Symbol quote character
start_symbol_char(C) -> symbol_char(C).
symbol_char($() -> false;
symbol_char($)) -> false;
symbol_char($[) -> false;
symbol_char($]) -> false;
symbol_char(${) -> false;
symbol_char($}) -> false;
symbol_char($") -> false;
symbol_char($;) -> false;
symbol_char(C) -> ((C > $\s) and (C =< $~)) orelse (C > $\240).
%% symbol_token(Chars, Line) -> {token,{symbol,Line,Symbol}} | {error,E}.
%% Build a symbol from list of legal characters, else error.
symbol_token(Cs, L) ->
case catch {ok,list_to_atom(Cs)} of
{ok,S} -> {token,{symbol,L,S}};
_ -> {error,"illegal symbol"}
end.
%% base_token(Chars, Base, Line) -> Integer.
%% Convert a string of Base characters into a number. We only allow
%% base betqeen 2 and 36, and an optional sign character first.
base_token(_, B, _) when B < 2; B > 36 ->
{error,"illegal number base"};
base_token([$+|Cs], B, L) -> base_token(Cs, B, +1, L);
base_token([$-|Cs], B, L) -> base_token(Cs, B, -1, L);
base_token(Cs, B, L) -> base_token(Cs, B, +1, L).
base_token(Cs, B, S, L) ->
case base1(Cs, B, 0) of
{N,[]} -> {token,{number,L,S*N}};
{_,_} -> {error,"illegal based number"}
end.
base1([C|Cs], Base, SoFar) when C >= $0, C =< $9, C < Base + $0 ->
Next = SoFar * Base + (C - $0),
base1(Cs, Base, Next);
base1([C|Cs], Base, SoFar) when C >= $a, C =< $z, C < Base + $a - 10 ->
Next = SoFar * Base + (C - $a + 10),
base1(Cs, Base, Next);
base1([C|Cs], Base, SoFar) when C >= $A, C =< $Z, C < Base + $A - 10 ->
Next = SoFar * Base + (C - $A + 10),
base1(Cs, Base, Next);
base1([C|Cs], _Base, SoFar) -> {SoFar,[C|Cs]};
base1([], _Base, N) -> {N,[]}.
-define(IS_UNICODE(C), ((C >= 0) and (C =< 16#10FFFF))).
%% char_token(InputChars, Line) -> {token,{number,L,N}} | {error,E}.
%% Convert an input string into the corresponding character. For a
%% sequence of hex characters we check resultant is code is in the
%% unicode range.
char_token([$x,C|Cs], L) ->
case base1([C|Cs], 16, 0) of
{N,[]} when ?IS_UNICODE(N) -> {token,{number,L,N}};
_ -> {error,"illegal character"}
end;
char_token([C], L) -> {token,{number,L,C}}.
%% chars(InputChars) -> Chars.
%% Convert an input string into the corresponding string characters.
%% We know that the input string is correct.
chars([$\\,$x,C|Cs0]) ->
case hex_char(C) of
true ->
case base1([C|Cs0], 16, 0) of
{N,[$;|Cs1]} -> [N|chars(Cs1)];
_Other -> [escape_char($x)|chars([C|Cs0])]
end;
false -> [escape_char($x)|chars([C|Cs0])]
end;
chars([$\\,C|Cs]) -> [escape_char(C)|chars(Cs)];
chars([C|Cs]) -> [C|chars(Cs)];
chars([]) -> [].
hex_char(C) when C >= $0, C =< $9 -> true;
hex_char(C) when C >= $a, C =< $f -> true;
hex_char(C) when C >= $A, C =< $F -> true;
hex_char(_) -> false.
escape_char($b) -> $\b; %\b = BS
escape_char($t) -> $\t; %\t = TAB
escape_char($n) -> $\n; %\n = LF
escape_char($v) -> $\v; %\v = VT
escape_char($f) -> $\f; %\f = FF
escape_char($r) -> $\r; %\r = CR
escape_char($e) -> $\e; %\e = ESC
escape_char($s) -> $\s; %\s = SPC
escape_char($d) -> $\d; %\d = DEL
escape_char(C) -> C.
%% Block Comment:
%% Provide a sensible error when people attempt to include nested
%% comments because currently the parser cannot process them without
%% a rebuild. But simply exploding on a '#|' is not going to be that
%% helpful.
block_comment(TokenChars) ->
%% Check we're not opening another comment block.
case string:str(TokenChars, "#|") of
0 -> skip_token; %% No nesting found
_ -> {error, "illegal nested block comment"}
end.
%% skip_until(String, Char1, Char2) -> String.
%% skip_past(String, Char1, Char2) -> String.
%% skip_until([C|_]=Cs, C1, C2) when C =:= C1 ; C =:= C2 -> Cs;
%% skip_until([_|Cs], C1, C2) -> skip_until(Cs, C1, C2);
%% skip_until([], _, _) -> [].
skip_past([C|Cs], C1, C2) when C =:= C1 ; C =:= C2 -> Cs;
skip_past([_|Cs], C1, C2) -> skip_past(Cs, C1, C2);
skip_past([], _, _) -> [].

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,31 @@
<#import "layout.ftl" as layout>
<#assign results = [
{
"title": "Example Result",
"description": "Lorem ipsum dolor sit amet, pede id pellentesque, sollicitudin turpis sed in sed sed, libero dictum."
}
] />
<@layout.page title="FreeMarker Example">
<#if results?size == 0>
There were no results.
<#else>
<ul>
<#list results as result>
<li>
<strong>${result.title}</strong>
<p>${result.description}</p>
</li>
</#list>
</ul>
</#if>
<#-- This is a FreeMarker comment -->
<@currentTime />
</@layout.page>
<#macro currentTime>
${.now?string.full}
</#macro>

View File

@@ -0,0 +1,32 @@
<#ftl strip_text=true />
<#macro page title>
<!doctype html>
<html lang="${.lang}">
<head>
<title>${title}</title>
<@metaTags />
</head>
<body>
<#nested />
<@footer />
</body>
</html>
</#macro>
<#---
Default meta tags
-->
<#macro metaTags>
<#compress>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="format-detection" content="telephone=no">
</#compress>
</#macro>
<#macro footer>
<p>This page is using FreeMarker v${.version}</p>
</#macro>

View File

@@ -0,0 +1,26 @@
<h1>Listing Books</h1>
<table>
<tr>
<th>Title</th>
<th>Summary</th>
<th></th>
<th></th>
<th></th>
</tr>
<%= for book <- @books do %>
<tr>
<%# comment %>
<td><%= book.title %></td>
<td><%= book.content %></td>
<td><%= link "Show", to: book_path(@conn, :show, book) %></td>
<td><%= link "Edit", to: book_path(@conn, :edit, book) %></td>
<td><%= link "Delete", to: book_path(@conn, :delete, book), method: :delete, data: [confirm: "Are you sure?"] %></td>
</tr>
<% end %>
</table>
<br />
<%= link "New book", to: book_path(@conn, :new) %>

View File

@@ -1,6 +1,74 @@
Version 1 of Trivial Extension by Andrew Plotkin begins here.
Version 2 of Trivial Extension by Andrew Plotkin begins here.
"This is the rubric of the extension."
"provided for the Linguist package by Andrew Plotkin"
[Note the two special quoted lines above.]
A cow is a kind of animal. A cow can be purple.
Understand "cow" as a cow.
Understand "purple" as a purple cow.
Check pushing a cow:
instead say "Cow-tipping, at your age?[paragraph break]Inconceivable."
[Here are the possible levels of heading:]
Volume One
Text-line is always "A line of text."
Book 2
Part the third - indented headings still count
Chapter IV - not for release
[Heading labels are case-insensitive.]
section foobar
[A line beginning "Volume" that does not have blank lines before and after it is *not* a header line. So the following should all be part of section foobar. Sadly, the "Volume is..." line gets colored as a header, because Atom's regexp model can't recognize "thing with blank lines before and after"!]
Measure is a kind of value.
Volume is a measure. Length is a measure.
Area is a measure.
[And now some Inform 6 inclusions.]
To say em -- running on:
(- style underline; -).
To say /em -- running on:
(- style roman; -).
Include (-
! Inform 6 comments start with a ! mark and run to the end of the line.
Global cowcount;
[ inform6func arg;
print "Here is some text; ", (address) 'dictword', ".^";
cowcount++; ! increment this variable
];
Object i6cow
with name 'cow' 'animal',
with description "It looks like a cow.",
has animate scenery;
-) after "Global Variables" in "Output.i6t".
Trivial Extension ends here.
---- DOCUMENTATION ----
Everything after the "---- DOCUMENTATION ----" line is documentation, so it should have the comment style.
However, tab-indented lines are sample Inform code within the documentation:
Horns are a kind of thing. Every cow has horns.
say "Moo[if the noun is purple] indigo[end if]."
So we need to allow for that.

View File

@@ -2,11 +2,61 @@
Include Trivial Extension by Andrew Plotkin.
Volume 1 - overview
Chapter - setting the scene
The Kitchen is a room.
[This kitchen is modelled after the one in Zork, although it lacks the detail to establish this to the player.]
[Comment: this kitchen is modelled after the one in Zork, although it lacks the detail to establish this to the player.]
Section - the kitchen table
The spicerack is a container in the Kitchen.
Table of Spices
Name Flavor
"cinnamon" 5
"nutmeg" 4
"szechuan pepper" 8
The description of the spicerack is "It's mostly empty."
Chapter - a character
A purple cow called Gelett is in the Kitchen.
[This comment spans multiple lines..
...and this line contains [nested square[] brackets]...
...which is legal in Inform 7.]
Instead of examining Gelett:
say "You'd rather see than be one."
Instead of examining Gelett:
say "You'd rather see than be one."
Check smelling Gelett:
say "This text contains several lines.
A blank line is displayed as a paragraph break,
but a simple line break is not.";
stop the action.
Section - cow catching
Gelett has a number called the mooness.
Instead of taking Gelett:
increment the mooness of Gelett;
if the mooness of Gelett is one:
say "Gelett moos once.";
else:
say "Gelett moos [mooness of Gelett in words] times.";
Volume 2 - the turn cycle
Every turn:
say "A turn passes[one of][or] placidly[or] idly[or] tediously[at random]."

82
samples/JSON/geo.geojson Normal file
View File

@@ -0,0 +1,82 @@
{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"properties": {
"name": "Australia Post - North Ryde BC",
"geo": [-33.787792, 151.13288],
"streetAddress": "11 Waterloo Road",
"addressLocality": "Macquarie Park",
"addressRegion": "New South Wales",
"addressCountry": "Australia",
"postalCode": "2113"
},
"geometry": {
"type": "Point",
"coordinates": [151.13288, -33.787792, 0]
}
},
{
"type": "Feature",
"properties": {
"name": "George Weston Foods Limited",
"geo": [-37.8263884, 144.9105381],
"streetAddress": "Level 3, 187 Todd Road",
"addressLocality": "Port Melbourne",
"addressRegion": "Victoria",
"addressCountry": "Australia",
"postalCode": "3207"
},
"geometry": {
"type": "Polygon",
"coordinates": [
[
[144.9097088901841, -37.82622654171794, 0],
[144.9099724266943, -37.82679388891783, 0],
[144.9110127325916, -37.82651526396403, 0],
[144.9112227645738, -37.82655667152123, 0],
[144.9113739439796, -37.82618552508767, 0],
[144.9112740633105, -37.82615750100924, 0],
[144.9111355846674, -37.82584493693527, 0],
[144.9097088901841, -37.82622654171794, 0]
]
]
}
},
{
"type": "Feature",
"properties": {
"name": "George Weston Foods Limited",
"geo": [-37.05202791502396, 144.2085614999388],
"streetAddress": "67 Richards Road",
"addressLocality": "Castlemaine",
"addressRegion": "Victoria",
"addressCountry": "Australia",
"postalCode": "3450"
},
"geometry": {
"type": "Polygon",
"coordinates": [
[
[144.2052428913937, -37.04906391287216, 0],
[144.205540392692, -37.05049727485623, 0],
[144.2059800881858, -37.05066835966983, 0],
[144.206490656024, -37.05279538900776, 0],
[144.2064525845008, -37.05366195881602, 0],
[144.2084322301922, -37.0538920493147, 0],
[144.2084811895712, -37.05266519735124, 0],
[144.2079784002005, -37.05041270555773, 0],
[144.2074017905817, -37.04817406993293, 0],
[144.2061363939852, -37.04834972871226, 0],
[144.2052428913937, -37.04906391287216, 0]
]
]
}
}
]
}

File diff suppressed because one or more lines are too long

23
samples/JSX/sample.jsx Normal file
View File

@@ -0,0 +1,23 @@
'use strict';
const React = require('react')
module.exports = React.createClass({
render: function() {
let {feeds, log} = this.props;
log.info(feeds);
return <div className="feed-list">
<h3>News Feed's</h3>
<ul>
{feeds.map(function(feed) {
return <li key={feed.name} className={feed.fetched ? 'loaded' : 'loading'}>
{feed.data && feed.data.length > 0 ?
<span>{feed.name} <span className='light'>({feed.data.length})</span></span>
: 'feed.name' }
</li>
})}
</ul>
</div>;
}
});

View File

@@ -0,0 +1,625 @@
// This is a generated file. Not intended for manual editing.
package org.intellij.grammar.parser;
import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static org.intellij.grammar.psi.BnfTypes.*;
import static org.intellij.grammar.parser.GeneratedParserUtilBase.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.lang.ASTNode;
import com.intellij.psi.tree.TokenSet;
import com.intellij.lang.PsiParser;
import com.intellij.lang.LightPsiParser;
@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class GrammarParser implements PsiParser, LightPsiParser {
public ASTNode parse(IElementType t, PsiBuilder b) {
parseLight(t, b);
return b.getTreeBuilt();
}
public void parseLight(IElementType t, PsiBuilder b) {
boolean r;
b = adapt_builder_(t, b, this, EXTENDS_SETS_);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
if (t == BNF_ATTR) {
r = attr(b, 0);
}
else if (t == BNF_ATTR_PATTERN) {
r = attr_pattern(b, 0);
}
else if (t == BNF_ATTR_VALUE) {
r = attr_value(b, 0);
}
else if (t == BNF_ATTRS) {
r = attrs(b, 0);
}
else if (t == BNF_CHOICE) {
r = choice(b, 0);
}
else if (t == BNF_EXPRESSION) {
r = expression(b, 0);
}
else if (t == BNF_LITERAL_EXPRESSION) {
r = literal_expression(b, 0);
}
else if (t == BNF_MODIFIER) {
r = modifier(b, 0);
}
else if (t == BNF_PAREN_EXPRESSION) {
r = paren_expression(b, 0);
}
else if (t == BNF_PREDICATE) {
r = predicate(b, 0);
}
else if (t == BNF_PREDICATE_SIGN) {
r = predicate_sign(b, 0);
}
else if (t == BNF_QUANTIFIED) {
r = quantified(b, 0);
}
else if (t == BNF_QUANTIFIER) {
r = quantifier(b, 0);
}
else if (t == BNF_REFERENCE_OR_TOKEN) {
r = reference_or_token(b, 0);
}
else if (t == BNF_RULE) {
r = rule(b, 0);
}
else if (t == BNF_SEQUENCE) {
r = sequence(b, 0);
}
else if (t == BNF_STRING_LITERAL_EXPRESSION) {
r = string_literal_expression(b, 0);
}
else {
r = parse_root_(t, b, 0);
}
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return grammar(b, l + 1);
}
public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
create_token_set_(BNF_LITERAL_EXPRESSION, BNF_STRING_LITERAL_EXPRESSION),
create_token_set_(BNF_CHOICE, BNF_EXPRESSION, BNF_LITERAL_EXPRESSION, BNF_PAREN_EXPRESSION,
BNF_PREDICATE, BNF_QUANTIFIED, BNF_REFERENCE_OR_TOKEN, BNF_SEQUENCE,
BNF_STRING_LITERAL_EXPRESSION),
};
/* ********************************************************** */
// id attr_pattern? '=' attr_value ';'?
public static boolean attr(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, "<attr>");
r = consumeToken(b, BNF_ID);
p = r; // pin = 1
r = r && report_error_(b, attr_1(b, l + 1));
r = p && report_error_(b, consumeToken(b, BNF_OP_EQ)) && r;
r = p && report_error_(b, attr_value(b, l + 1)) && r;
r = p && attr_4(b, l + 1) && r;
exit_section_(b, l, m, BNF_ATTR, r, p, attr_recover_until_parser_);
return r || p;
}
// attr_pattern?
private static boolean attr_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_1")) return false;
attr_pattern(b, l + 1);
return true;
}
// ';'?
private static boolean attr_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_4")) return false;
consumeToken(b, BNF_SEMICOLON);
return true;
}
/* ********************************************************** */
// '(' string ')'
public static boolean attr_pattern(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_pattern")) return false;
if (!nextTokenIs(b, BNF_LEFT_PAREN)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_PAREN);
r = r && consumeToken(b, BNF_STRING);
r = r && consumeToken(b, BNF_RIGHT_PAREN);
exit_section_(b, m, BNF_ATTR_PATTERN, r);
return r;
}
/* ********************************************************** */
// !'}'
static boolean attr_recover_until(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_recover_until")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_RIGHT_BRACE);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// (reference_or_token | literal_expression) !'='
public static boolean attr_value(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<attr value>");
r = attr_value_0(b, l + 1);
r = r && attr_value_1(b, l + 1);
exit_section_(b, l, m, BNF_ATTR_VALUE, r, false, null);
return r;
}
// reference_or_token | literal_expression
private static boolean attr_value_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = reference_or_token(b, l + 1);
if (!r) r = literal_expression(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !'='
private static boolean attr_value_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value_1")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_OP_EQ);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// '{' attr* '}'
public static boolean attrs(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attrs")) return false;
if (!nextTokenIs(b, BNF_LEFT_BRACE)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_LEFT_BRACE);
p = r; // pin = 1
r = r && report_error_(b, attrs_1(b, l + 1));
r = p && consumeToken(b, BNF_RIGHT_BRACE) && r;
exit_section_(b, l, m, BNF_ATTRS, r, p, null);
return r || p;
}
// attr*
private static boolean attrs_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attrs_1")) return false;
int c = current_position_(b);
while (true) {
if (!attr(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "attrs_1", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// '{' sequence ('|' sequence)* '}' | sequence choice_tail*
public static boolean choice(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<choice>");
r = choice_0(b, l + 1);
if (!r) r = choice_1(b, l + 1);
exit_section_(b, l, m, BNF_CHOICE, r, false, null);
return r;
}
// '{' sequence ('|' sequence)* '}'
private static boolean choice_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_BRACE);
r = r && sequence(b, l + 1);
r = r && choice_0_2(b, l + 1);
r = r && consumeToken(b, BNF_RIGHT_BRACE);
exit_section_(b, m, null, r);
return r;
}
// ('|' sequence)*
private static boolean choice_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0_2")) return false;
int c = current_position_(b);
while (true) {
if (!choice_0_2_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "choice_0_2", c)) break;
c = current_position_(b);
}
return true;
}
// '|' sequence
private static boolean choice_0_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_OP_OR);
r = r && sequence(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// sequence choice_tail*
private static boolean choice_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = sequence(b, l + 1);
r = r && choice_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// choice_tail*
private static boolean choice_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_1_1")) return false;
int c = current_position_(b);
while (true) {
if (!choice_tail(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "choice_1_1", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// '|' sequence
static boolean choice_tail(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_tail")) return false;
if (!nextTokenIs(b, BNF_OP_OR)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_OP_OR);
p = r; // pin = 1
r = r && sequence(b, l + 1);
exit_section_(b, l, m, null, r, p, null);
return r || p;
}
/* ********************************************************** */
// choice?
public static boolean expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "expression")) return false;
Marker m = enter_section_(b, l, _COLLAPSE_, "<expression>");
choice(b, l + 1);
exit_section_(b, l, m, BNF_EXPRESSION, true, false, null);
return true;
}
/* ********************************************************** */
// (attrs | rule) *
static boolean grammar(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "grammar")) return false;
int c = current_position_(b);
while (true) {
if (!grammar_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "grammar", c)) break;
c = current_position_(b);
}
return true;
}
// attrs | rule
private static boolean grammar_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "grammar_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = attrs(b, l + 1);
if (!r) r = rule(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// string_literal_expression | number
public static boolean literal_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "literal_expression")) return false;
if (!nextTokenIs(b, "<literal expression>", BNF_NUMBER, BNF_STRING)) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<literal expression>");
r = string_literal_expression(b, l + 1);
if (!r) r = consumeToken(b, BNF_NUMBER);
exit_section_(b, l, m, BNF_LITERAL_EXPRESSION, r, false, null);
return r;
}
/* ********************************************************** */
// 'private' | 'external' | 'wrapped'
public static boolean modifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "modifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<modifier>");
r = consumeToken(b, "private");
if (!r) r = consumeToken(b, "external");
if (!r) r = consumeToken(b, "wrapped");
exit_section_(b, l, m, BNF_MODIFIER, r, false, null);
return r;
}
/* ********************************************************** */
// quantified | predicate
static boolean option(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "option")) return false;
boolean r;
Marker m = enter_section_(b);
r = quantified(b, l + 1);
if (!r) r = predicate(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// '(' expression ')'
public static boolean paren_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "paren_expression")) return false;
if (!nextTokenIs(b, BNF_LEFT_PAREN)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_LEFT_PAREN);
p = r; // pin = 1
r = r && report_error_(b, expression(b, l + 1));
r = p && consumeToken(b, BNF_RIGHT_PAREN) && r;
exit_section_(b, l, m, BNF_PAREN_EXPRESSION, r, p, null);
return r || p;
}
/* ********************************************************** */
// predicate_sign simple
public static boolean predicate(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "predicate")) return false;
if (!nextTokenIs(b, "<predicate>", BNF_OP_NOT, BNF_OP_AND)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<predicate>");
r = predicate_sign(b, l + 1);
r = r && simple(b, l + 1);
exit_section_(b, l, m, BNF_PREDICATE, r, false, null);
return r;
}
/* ********************************************************** */
// '&' | '!'
public static boolean predicate_sign(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "predicate_sign")) return false;
if (!nextTokenIs(b, "<predicate sign>", BNF_OP_NOT, BNF_OP_AND)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<predicate sign>");
r = consumeToken(b, BNF_OP_AND);
if (!r) r = consumeToken(b, BNF_OP_NOT);
exit_section_(b, l, m, BNF_PREDICATE_SIGN, r, false, null);
return r;
}
/* ********************************************************** */
// '[' expression ']' | simple quantifier?
public static boolean quantified(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<quantified>");
r = quantified_0(b, l + 1);
if (!r) r = quantified_1(b, l + 1);
exit_section_(b, l, m, BNF_QUANTIFIED, r, false, null);
return r;
}
// '[' expression ']'
private static boolean quantified_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_BRACKET);
r = r && expression(b, l + 1);
r = r && consumeToken(b, BNF_RIGHT_BRACKET);
exit_section_(b, m, null, r);
return r;
}
// simple quantifier?
private static boolean quantified_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple(b, l + 1);
r = r && quantified_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// quantifier?
private static boolean quantified_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_1_1")) return false;
quantifier(b, l + 1);
return true;
}
/* ********************************************************** */
// '?' | '+' | '*'
public static boolean quantifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<quantifier>");
r = consumeToken(b, BNF_OP_OPT);
if (!r) r = consumeToken(b, BNF_OP_ONEMORE);
if (!r) r = consumeToken(b, BNF_OP_ZEROMORE);
exit_section_(b, l, m, BNF_QUANTIFIER, r, false, null);
return r;
}
/* ********************************************************** */
// id
public static boolean reference_or_token(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "reference_or_token")) return false;
if (!nextTokenIs(b, BNF_ID)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_ID);
exit_section_(b, m, BNF_REFERENCE_OR_TOKEN, r);
return r;
}
/* ********************************************************** */
// modifier* id '::=' expression attrs? ';'?
public static boolean rule(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, "<rule>");
r = rule_0(b, l + 1);
r = r && consumeToken(b, BNF_ID);
r = r && consumeToken(b, BNF_OP_IS);
p = r; // pin = 3
r = r && report_error_(b, expression(b, l + 1));
r = p && report_error_(b, rule_4(b, l + 1)) && r;
r = p && rule_5(b, l + 1) && r;
exit_section_(b, l, m, BNF_RULE, r, p, rule_recover_until_parser_);
return r || p;
}
// modifier*
private static boolean rule_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_0")) return false;
int c = current_position_(b);
while (true) {
if (!modifier(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "rule_0", c)) break;
c = current_position_(b);
}
return true;
}
// attrs?
private static boolean rule_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_4")) return false;
attrs(b, l + 1);
return true;
}
// ';'?
private static boolean rule_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_5")) return false;
consumeToken(b, BNF_SEMICOLON);
return true;
}
/* ********************************************************** */
// !'{'
static boolean rule_recover_until(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_recover_until")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_LEFT_BRACE);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// option +
public static boolean sequence(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "sequence")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<sequence>");
r = option(b, l + 1);
int c = current_position_(b);
while (r) {
if (!option(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "sequence", c)) break;
c = current_position_(b);
}
exit_section_(b, l, m, BNF_SEQUENCE, r, false, null);
return r;
}
/* ********************************************************** */
// !(modifier* id '::=' ) reference_or_token | literal_expression | paren_expression
static boolean simple(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0(b, l + 1);
if (!r) r = literal_expression(b, l + 1);
if (!r) r = paren_expression(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !(modifier* id '::=' ) reference_or_token
private static boolean simple_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0_0(b, l + 1);
r = r && reference_or_token(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !(modifier* id '::=' )
private static boolean simple_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !simple_0_0_0(b, l + 1);
exit_section_(b, l, m, null, r, false, null);
return r;
}
// modifier* id '::='
private static boolean simple_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0_0_0_0(b, l + 1);
r = r && consumeToken(b, BNF_ID);
r = r && consumeToken(b, BNF_OP_IS);
exit_section_(b, m, null, r);
return r;
}
// modifier*
private static boolean simple_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0_0_0")) return false;
int c = current_position_(b);
while (true) {
if (!modifier(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "simple_0_0_0_0", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// string
public static boolean string_literal_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "string_literal_expression")) return false;
if (!nextTokenIs(b, BNF_STRING)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_STRING);
exit_section_(b, m, BNF_STRING_LITERAL_EXPRESSION, r);
return r;
}
final static Parser attr_recover_until_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return attr_recover_until(b, l + 1);
}
};
final static Parser rule_recover_until_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return rule_recover_until(b, l + 1);
}
};
}

View File

@@ -0,0 +1,482 @@
/* The following code was generated by JFlex 1.4.3 on 28/01/16 11:27 */
package test;
import com.intellij.lexer.*;
import com.intellij.psi.tree.IElementType;
import static org.intellij.grammar.psi.BnfTypes.*;
/**
* This class is a scanner generated by
* <a href="http://www.jflex.de/">JFlex</a> 1.4.3
* on 28/01/16 11:27 from the specification file
* <tt>/home/abigail/code/intellij-grammar-kit-test/src/test/_GrammarLexer.flex</tt>
*/
public class _GrammarLexer implements FlexLexer {
/** initial size of the lookahead buffer */
private static final int ZZ_BUFFERSIZE = 16384;
/** lexical states */
public static final int YYINITIAL = 0;
/**
* ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
* ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
* at the beginning of a line
* l is of the form l = 2*k, k a non negative integer
*/
private static final int ZZ_LEXSTATE[] = {
0, 0
};
/**
* Translates characters to character classes
*/
private static final String ZZ_CMAP_PACKED =
"\11\0\1\1\1\1\1\0\1\1\1\1\22\0\1\1\101\0\1\13"+
"\1\0\1\3\1\14\1\0\1\10\1\0\1\2\3\0\1\12\1\7"+
"\3\0\1\6\1\4\1\5\1\11\uff8a\0";
/**
* Translates characters to character classes
*/
private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
/**
* Translates DFA states to action switch labels.
*/
private static final int [] ZZ_ACTION = zzUnpackAction();
private static final String ZZ_ACTION_PACKED_0 =
"\1\0\1\1\1\2\3\1\1\3\10\0\1\4\1\5";
private static int [] zzUnpackAction() {
int [] result = new int[17];
int offset = 0;
offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
return result;
}
private static int zzUnpackAction(String packed, int offset, int [] result) {
int i = 0; /* index in packed string */
int j = offset; /* index in unpacked array */
int l = packed.length();
while (i < l) {
int count = packed.charAt(i++);
int value = packed.charAt(i++);
do result[j++] = value; while (--count > 0);
}
return j;
}
/**
* Translates a state to a row index in the transition table
*/
private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
private static final String ZZ_ROWMAP_PACKED_0 =
"\0\0\0\15\0\32\0\47\0\64\0\101\0\15\0\116"+
"\0\133\0\150\0\165\0\202\0\217\0\234\0\251\0\15"+
"\0\15";
private static int [] zzUnpackRowMap() {
int [] result = new int[17];
int offset = 0;
offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
return result;
}
private static int zzUnpackRowMap(String packed, int offset, int [] result) {
int i = 0; /* index in packed string */
int j = offset; /* index in unpacked array */
int l = packed.length();
while (i < l) {
int high = packed.charAt(i++) << 16;
result[j++] = high | packed.charAt(i++);
}
return j;
}
/**
* The transition table of the DFA
*/
private static final int [] ZZ_TRANS = zzUnpackTrans();
private static final String ZZ_TRANS_PACKED_0 =
"\1\2\1\3\1\4\1\2\1\5\2\2\1\6\5\2"+
"\16\0\1\3\16\0\1\7\16\0\1\10\20\0\1\11"+
"\11\0\1\12\20\0\1\13\4\0\1\14\25\0\1\15"+
"\10\0\1\16\21\0\1\17\10\0\1\20\12\0\1\21"+
"\6\0";
private static int [] zzUnpackTrans() {
int [] result = new int[182];
int offset = 0;
offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result);
return result;
}
private static int zzUnpackTrans(String packed, int offset, int [] result) {
int i = 0; /* index in packed string */
int j = offset; /* index in unpacked array */
int l = packed.length();
while (i < l) {
int count = packed.charAt(i++);
int value = packed.charAt(i++);
value--;
do result[j++] = value; while (--count > 0);
}
return j;
}
/* error codes */
private static final int ZZ_UNKNOWN_ERROR = 0;
private static final int ZZ_NO_MATCH = 1;
private static final int ZZ_PUSHBACK_2BIG = 2;
private static final char[] EMPTY_BUFFER = new char[0];
private static final int YYEOF = -1;
private static java.io.Reader zzReader = null; // Fake
/* error messages for the codes above */
private static final String ZZ_ERROR_MSG[] = {
"Unkown internal scanner error",
"Error: could not match input",
"Error: pushback value was too large"
};
/**
* ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
*/
private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
private static final String ZZ_ATTRIBUTE_PACKED_0 =
"\1\0\1\11\4\1\1\11\10\0\2\11";
private static int [] zzUnpackAttribute() {
int [] result = new int[17];
int offset = 0;
offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
return result;
}
private static int zzUnpackAttribute(String packed, int offset, int [] result) {
int i = 0; /* index in packed string */
int j = offset; /* index in unpacked array */
int l = packed.length();
while (i < l) {
int count = packed.charAt(i++);
int value = packed.charAt(i++);
do result[j++] = value; while (--count > 0);
}
return j;
}
/** the current state of the DFA */
private int zzState;
/** the current lexical state */
private int zzLexicalState = YYINITIAL;
/** this buffer contains the current text to be matched and is
the source of the yytext() string */
private CharSequence zzBuffer = "";
/** this buffer may contains the current text array to be matched when it is cheap to acquire it */
private char[] zzBufferArray;
/** the textposition at the last accepting state */
private int zzMarkedPos;
/** the textposition at the last state to be included in yytext */
private int zzPushbackPos;
/** the current text position in the buffer */
private int zzCurrentPos;
/** startRead marks the beginning of the yytext() string in the buffer */
private int zzStartRead;
/** endRead marks the last character in the buffer, that has been read
from input */
private int zzEndRead;
/**
* zzAtBOL == true <=> the scanner is currently at the beginning of a line
*/
private boolean zzAtBOL = true;
/** zzAtEOF == true <=> the scanner is at the EOF */
private boolean zzAtEOF;
/* user code: */
public _GrammarLexer() {
this((java.io.Reader)null);
}
/**
* Creates a new scanner
*
* @param in the java.io.Reader to read input from.
*/
public _GrammarLexer(java.io.Reader in) {
this.zzReader = in;
}
/**
* Unpacks the compressed character translation table.
*
* @param packed the packed character translation table
* @return the unpacked character translation table
*/
private static char [] zzUnpackCMap(String packed) {
char [] map = new char[0x10000];
int i = 0; /* index in packed string */
int j = 0; /* index in unpacked array */
while (i < 52) {
int count = packed.charAt(i++);
char value = packed.charAt(i++);
do map[j++] = value; while (--count > 0);
}
return map;
}
public final int getTokenStart(){
return zzStartRead;
}
public final int getTokenEnd(){
return getTokenStart() + yylength();
}
public void reset(CharSequence buffer, int start, int end,int initialState){
zzBuffer = buffer;
zzBufferArray = com.intellij.util.text.CharArrayUtil.fromSequenceWithoutCopying(buffer);
zzCurrentPos = zzMarkedPos = zzStartRead = start;
zzPushbackPos = 0;
zzAtEOF = false;
zzAtBOL = true;
zzEndRead = end;
yybegin(initialState);
}
/**
* Refills the input buffer.
*
* @return <code>false</code>, iff there was new input.
*
* @exception java.io.IOException if any I/O-Error occurs
*/
private boolean zzRefill() throws java.io.IOException {
return true;
}
/**
* Returns the current lexical state.
*/
public final int yystate() {
return zzLexicalState;
}
/**
* Enters a new lexical state
*
* @param newState the new lexical state
*/
public final void yybegin(int newState) {
zzLexicalState = newState;
}
/**
* Returns the text matched by the current regular expression.
*/
public final CharSequence yytext() {
return zzBuffer.subSequence(zzStartRead, zzMarkedPos);
}
/**
* Returns the character at position <tt>pos</tt> from the
* matched text.
*
* It is equivalent to yytext().charAt(pos), but faster
*
* @param pos the position of the character to fetch.
* A value from 0 to yylength()-1.
*
* @return the character at position pos
*/
public final char yycharat(int pos) {
return zzBufferArray != null ? zzBufferArray[zzStartRead+pos]:zzBuffer.charAt(zzStartRead+pos);
}
/**
* Returns the length of the matched text region.
*/
public final int yylength() {
return zzMarkedPos-zzStartRead;
}
/**
* Reports an error that occured while scanning.
*
* In a wellformed scanner (no or only correct usage of
* yypushback(int) and a match-all fallback rule) this method
* will only be called with things that "Can't Possibly Happen".
* If this method is called, something is seriously wrong
* (e.g. a JFlex bug producing a faulty scanner etc.).
*
* Usual syntax/scanner level error handling should be done
* in error fallback rules.
*
* @param errorCode the code of the errormessage to display
*/
private void zzScanError(int errorCode) {
String message;
try {
message = ZZ_ERROR_MSG[errorCode];
}
catch (ArrayIndexOutOfBoundsException e) {
message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
}
throw new Error(message);
}
/**
* Pushes the specified amount of characters back into the input stream.
*
* They will be read again by then next call of the scanning method
*
* @param number the number of characters to be read again.
* This number must not be greater than yylength()!
*/
public void yypushback(int number) {
if ( number > yylength() )
zzScanError(ZZ_PUSHBACK_2BIG);
zzMarkedPos -= number;
}
/**
* Resumes scanning until the next regular expression is matched,
* the end of input is encountered or an I/O-Error occurs.
*
* @return the next token
* @exception java.io.IOException if any I/O-Error occurs
*/
public IElementType advance() throws java.io.IOException {
int zzInput;
int zzAction;
// cached fields:
int zzCurrentPosL;
int zzMarkedPosL;
int zzEndReadL = zzEndRead;
CharSequence zzBufferL = zzBuffer;
char[] zzBufferArrayL = zzBufferArray;
char [] zzCMapL = ZZ_CMAP;
int [] zzTransL = ZZ_TRANS;
int [] zzRowMapL = ZZ_ROWMAP;
int [] zzAttrL = ZZ_ATTRIBUTE;
while (true) {
zzMarkedPosL = zzMarkedPos;
zzAction = -1;
zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
zzState = ZZ_LEXSTATE[zzLexicalState];
zzForAction: {
while (true) {
if (zzCurrentPosL < zzEndReadL)
zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++));
else if (zzAtEOF) {
zzInput = YYEOF;
break zzForAction;
}
else {
// store back cached positions
zzCurrentPos = zzCurrentPosL;
zzMarkedPos = zzMarkedPosL;
boolean eof = zzRefill();
// get translated positions and possibly new buffer
zzCurrentPosL = zzCurrentPos;
zzMarkedPosL = zzMarkedPos;
zzBufferL = zzBuffer;
zzEndReadL = zzEndRead;
if (eof) {
zzInput = YYEOF;
break zzForAction;
}
else {
zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++));
}
}
int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
if (zzNext == -1) break zzForAction;
zzState = zzNext;
int zzAttributes = zzAttrL[zzState];
if ( (zzAttributes & 1) == 1 ) {
zzAction = zzState;
zzMarkedPosL = zzCurrentPosL;
if ( (zzAttributes & 8) == 8 ) break zzForAction;
}
}
}
// store back cached position
zzMarkedPos = zzMarkedPosL;
switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
case 1:
{ return com.intellij.psi.TokenType.BAD_CHARACTER;
}
case 6: break;
case 4:
{ return BNF_STRING;
}
case 7: break;
case 5:
{ return BNF_NUMBER;
}
case 8: break;
case 3:
{ return BNF_ID;
}
case 9: break;
case 2:
{ return com.intellij.psi.TokenType.WHITE_SPACE;
}
case 10: break;
default:
if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
zzAtEOF = true;
return null;
}
else {
zzScanError(ZZ_NO_MATCH);
}
}
}
}
}

View File

@@ -0,0 +1,19 @@
// title : OpenJSCAD.org Logo
// author : Rene K. Mueller
// license : MIT License
// revision : 0.003
// tags : Logo,Intersection,Sphere,Cube
// file : logo.jscad
function main() {
return union(
difference(
cube({size: 3, center: true}),
sphere({r:2, center: true})
),
intersection(
sphere({r: 1.3, center: true}),
cube({size: 2.1, center: true})
)
).translate([0,0,1.5]).scale(10);
}

File diff suppressed because one or more lines are too long

14069
samples/KiCad/tc14badge.brd Normal file

File diff suppressed because it is too large Load Diff

74
samples/LSL/LSL.lslp Normal file
View File

@@ -0,0 +1,74 @@
/*
Testing syntax highlighting
for the Linden Scripting Language
*/
integer someIntNormal = 3672;
integer someIntHex = 0x00000000;
integer someIntMath = PI_BY_TWO;
integer event = 5673;// 'event' is invalid.illegal
key someKeyTexture = TEXTURE_DEFAULT;
string someStringSpecial = EOF;
some_user_defined_function_without_return_type(string inputAsString)
{
llSay(PUBLIC_CHANNEL, inputAsString);
}
string user_defined_function_returning_a_string(key inputAsKey)
{
return (string)inputAsKey;
}
default
{
state_entry()
{
key someKey = NULL_KEY;
someKey = llGetOwner();
string someString = user_defined_function_returning_a_string(someKey);
some_user_defined_function_without_return_type(someString);
}
touch_start(integer num_detected)
{
list agentsInRegion = llGetAgentList(AGENT_LIST_REGION, []);
integer numOfAgents = llGetListLength(agentsInRegion);
integer index; // defaults to 0
for (; index <= numOfAgents - 1; index++) // for each agent in region
{
llRegionSayTo(llList2Key(agentsInRegion, index), PUBLIC_CHANNEL, "Hello, Avatar!");
}
}
touch_end(integer num_detected)
{
someIntNormal = 3672;
someIntHex = 0x00000000;
someIntMath = PI_BY_TWO;
event = 5673;// 'event' is invalid.illegal
someKeyTexture = TEXTURE_DEFAULT;
someStringSpecial = EOF;
llSetInventoryPermMask("some item", MASK_NEXT, PERM_ALL);// 'llSetInventoryPermMask' is reserved.godmode
llWhisper(PUBLIC_CHANNEL, "Leaving \"default\" now...");
state other;
}
}
state other
{
state_entry()
{
llWhisper(PUBLIC_CHANNEL, "Entered \"state other\", returning to \"default\" again...");
state default;
}
}

View File

@@ -0,0 +1,29 @@
-- Taken from an example from Autodesk's MAXScript reference:
-- http://help.autodesk.com/view/3DSMAX/2016/ENU/?guid=__files_GUID_84E24969_C175_4389_B9A6_3B2699B66785_htm
macroscript MoveToSurface
category: "HowTo"
(
fn g_filter o = superclassof o == Geometryclass
fn find_intersection z_node node_to_z = (
local testRay = ray node_to_z.pos [0,0,-1]
local nodeMaxZ = z_node.max.z
testRay.pos.z = nodeMaxZ + 0.0001 * abs nodeMaxZ
intersectRay z_node testRay
)
on isEnabled return selection.count > 0
on Execute do (
target_mesh = pickObject message:"Pick Target Surface:" filter:g_filter
if isValidNode target_mesh then (
undo "MoveToSurface" on (
for i in selection do (
int_point = find_intersection target_mesh i
if int_point != undefined then i.pos = int_point.pos
)--end i loop
)--end undo
)--end if
)--end execute
)--end script

View File

@@ -0,0 +1,53 @@
-- Taken from an example from Autodesk's MAXScript reference:
-- http://help.autodesk.com/view/3DSMAX/2016/ENU/?guid=__files_GUID_0876DF46_FAA3_4131_838D_5739A67FF2C1_htm
macroscript FreeSpline category:"HowTo" tooltip:"FreeSpline" (
local old_pos
local new_spline
local second_knot_set
fn get_mouse_pos pen_pos old_pen_pos = (
if old_pos == undefined then old_pos = old_pen_pos
if distance pen_pos old_pos > 10 then
(
if second_knot_set then
addKnot new_spline 1 #smooth #curve pen_pos
else
(
setKnotPoint new_spline 1 2 pen_pos
second_knot_set = true
)
old_pos = pen_pos
updateShape new_spline
)-- end if
)-- end fn
fn draw_new_line old_pen_pos = (
pickPoint mouseMoveCallback:#(get_mouse_pos,old_pen_pos)
)
undo"Free Spline"on(
new_spline = splineShape ()
old_pen_pos = pickPoint ()
if old_pen_pos == #RightClick then
delete new_spline
else
(
select new_spline
new_spline.pos = old_pen_pos
addNewSpline new_spline
addKnot new_spline 1 #smooth #curve old_pen_pos
addKnot new_spline 1 #smooth #curve old_pen_pos
second_knot_set = false
draw_new_line old_pen_pos
q = querybox "Close Spline?" title:"Free Spline"
if q then
(
close new_spline 1
updateshape new_spline
)
select new_spline
)--end else
)--end undo
)--end script

View File

@@ -0,0 +1,64 @@
-- Taken from a 3-part tutorial from Autodesk's MAXScript reference
-- Source: http://help.autodesk.com/view/3DSMAX/2016/ENU/?guid=__files_GUID_6B5EDC11_A154_4AA7_A972_A11AC36949E9_htm
fn ColourToHex col = (
local theComponents = #(bit.intAsHex col.r, bit.intAsHex col.g, bit.intAsHex col.b)
local theValue = "#"
for i in theComponents do
theValue += (if i.count == 1 then "0" else "") + i
theValue
)
local st = timestamp()
local theFileName = (getDir #userscripts + "\\PolygonRendering3.svg")
local theSVGfile = createFile theFileName
format "<svg xmlns=\"http://www.w3.org/2000/svg\"\n" to:theSVGfile
format "\t\txmlns:xlink=\"http://www.w3.org/1999/xlink\">\n" to:theSVGfile
local theViewTM = viewport.getTM()
theViewTM.row4 = [0,0,0]
local theViewTM2 = viewport.getTM()
local theViewSize = getViewSize()
local theViewScale = getViewSize()
theViewScale.x /= 1024.0
theViewScale.y /= 1024.0
local theStrokeThickness = 3
gw.setTransform (matrix3 1)
for o in Geometry where not o.isHiddenInVpt and classof o != TargetObject do (
local theStrokeColour = white
local theFillColour = o.wirecolor
local theMesh = snapshotAsMesh o
for f = 1 to theMesh.numfaces do (
local theNormal = normalize (getFaceNormal theMesh f)
if (theNormal*theViewTM).z > 0 do
(
local theFace = getFace theMesh f
local v1 = gw.transPoint (getVert theMesh theFace.x)
local v2 = gw.transPoint (getVert theMesh theFace.y)
local v3 = gw.transPoint (getVert theMesh theFace.z)
v1.x /= theViewScale.x
v1.y /= theViewScale.y
v2.x /= theViewScale.x
v2.y /= theViewScale.y
v3.x /= theViewScale.x
v3.y /= theViewScale.y
format "\t<polygon points='%,% %,% %,%' \n" v1.x v1.y v2.x v2.y v3.x v3.y to:theSVGfile
format "\tstyle='stroke:%; fill:%; stroke-width:%'/>\n" (ColourToHex theStrokeColour) (ColourToHex theFillColour) theStrokeThickness to:theSVGfile
)--end if normal positive
)--end f loop
)--end o loop
format "</svg>\n" to:theSVGfile
close theSVGfile
local theSVGMap = VectorMap vectorFile:theFileName alphasource:0
local theBitmap = bitmap theViewSize.x theViewSize.y
renderMap theSVGMap into:theBitmap filter:true
display theBitmap
format "Render Time: % sec.\n" ((timestamp()-st)/1000.0)

View File

@@ -0,0 +1,22 @@
fn CalculateVolumeAndCentreOfMass obj =
(
local Volume= 0.0
local Centre= [0.0, 0.0, 0.0]
local theMesh = snapshotasmesh obj
local numFaces = theMesh.numfaces
for i = 1 to numFaces do
(
local Face= getFace theMesh i
local vert2 = getVert theMesh Face.z
local vert1 = getVert theMesh Face.y
local vert0 = getVert theMesh Face.x
local dV = Dot (Cross (vert1 - vert0) (vert2 - vert0)) vert0
Volume+= dV
Centre+= (vert0 + vert1 + vert2) * dV
)
delete theMesh
Volume /= 6
Centre /= 24
Centre /= Volume
#(Volume,Centre)
)

View File

@@ -0,0 +1 @@
Test[1 + 2, 3, TestID -> "One plus two"]

View File

@@ -0,0 +1 @@
Test["a" <> "b", "ab", TestID -> "Concat \"a\" and \"b\""]

View File

@@ -0,0 +1,5 @@
TestSuite[
{ "TestArithmetic.mt"
, "TestString.mt"
}
]

View File

@@ -0,0 +1,694 @@
= Name =
'''nginx_tcp_proxy_module''' - support TCP proxy with Nginx
= Installation =
Download the latest stable version of the release tarball of this module from [http://github.com/yaoweibin/nginx_tcp_proxy_module github]
Grab the nginx source code from [http://nginx.org/ nginx.org], for example, the version 1.2.1 (see nginx compatibility), and then build the source with this module:
<geshi lang="bash">
$ wget 'http://nginx.org/download/nginx-1.2.1.tar.gz'
$ tar -xzvf nginx-1.2.1.tar.gz
$ cd nginx-1.2.1/
$ patch -p1 < /path/to/nginx_tcp_proxy_module/tcp.patch
$ ./configure --add-module=/path/to/nginx_tcp_proxy_module
$ make
$ make install
</geshi>
= Synopsis =
<geshi lang="nginx">
http {
server {
listen 80;
location /status {
tcp_check_status;
}
}
}
</geshi>
<geshi lang="nginx">
#You can also include tcp_proxy.conf file individually
#include /path/to/tcp_proxy.conf;
tcp {
upstream cluster {
# simple round-robin
server 192.168.0.1:80;
server 192.168.0.2:80;
check interval=3000 rise=2 fall=5 timeout=1000;
#check interval=3000 rise=2 fall=5 timeout=1000 type=ssl_hello;
#check interval=3000 rise=2 fall=5 timeout=1000 type=http;
#check_http_send "GET / HTTP/1.0\r\n\r\n";
#check_http_expect_alive http_2xx http_3xx;
}
server {
listen 8888;
proxy_pass cluster;
}
}
</geshi>
= Description =
This module actually include many modules: ngx_tcp_module, ngx_tcp_core_module, ngx_tcp_upstream_module, ngx_tcp_proxy_module, ngx_tcp_websocket_module, ngx_tcp_ssl_module, ngx_tcp_upstream_ip_hash_module. All these modules work together to support TCP proxy with Nginx. I also added other features: ip_hash, upstream server health check, status monitor.
The motivation of writing these modules is Nginx's high performance and robustness. At first, I developed this module just for general TCP proxy. And now, this module is frequently used in websocket reverse proxying.
Note, You can't use the same listening port with HTTP modules.
= Directives =
== ngx_tcp_moodule ==
=== tcp ===
'''syntax:''' ''tcp {...}''
'''default:''' ''none''
'''context:''' ''main''
'''description:''' All the tcp related directives are contained in the tcp block.
'''ngx_tcp_core_moodule'''
=== server ===
'''syntax:''' ''server {...}''
'''default:''' ''none''
'''context:''' ''tcp''
'''description:''' All the specific server directives are contained in the server block.
=== listen ===
'''syntax:''' ''listen address:port [ bind | ssl | default]''
'''default:''' ''none''
'''context:''' ''server''
'''description:''' The same as [http://wiki.nginx.org/NginxMailCoreModule#listen listen]. The parameter of default means the default server if you have several server blocks with the same port.
=== access_log ===
'''syntax:''' ''access_log path [buffer=size] | off''
'''default:''' ''access_log logs/tcp_access.log''
'''context:''' ''tcp, server''
'''description:''' Set the access.log. Each record's format is like this:
<pre>
log_time worker_process_pid client_ip host_ip accept_time upstream_ip bytes_read bytes_write
2011/08/02 06:19:07 [5972] 127.0.0.1 0.0.0.0:1982 2011/08/02 06:18:19 172.19.0.129:80 80 236305
</pre>
* ''log_time'': The current time when writing this log. The log action is called when the proxy session is closed.
* ''worker_process_pid'': the pid of worker process
* ''client_ip'': the client ip
* ''host_ip'': the server ip and port
* ''accept_time'': the time when the server accepts client's connection
* ''upstream_ip'': the upstream server's ip
* ''bytes_read'': the bytes read from client
* ''bytes_write'': the bytes written to client
=== allow ===
'''syntax:''' ''allow [ address | CIDR | all ]''
'''default:''' ''none''
'''context:''' ''server''
'''description:''' Directive grants access for the network or addresses indicated.
=== deny ===
'''syntax:''' ''deny [ address | CIDR | all ]''
'''default:''' ''none''
'''context:''' ''server''
'''description:''' Directive grants access for the network or addresses indicated.
=== so_keepalive ===
'''syntax:''' ''so_keepalive on|off''
'''default:''' ''off''
'''context:''' ''main, server''
'''description:''' The same as [http://wiki.nginx.org/NginxMailCoreModule#so_keepalive so_keepalive].
=== tcp_nodelay ===
'''syntax:''' ''tcp_nodelay on|off''
'''default:''' ''on''
'''context:''' ''main, server''
'''description:''' The same as [http://wiki.nginx.org/NginxHttpCoreModule#tcp_nodelay tcp_nodelay].
=== timeout ===
'''syntax:''' ''timeout milliseconds''
'''default:''' ''60000''
'''context:''' ''main, server''
'''description:''' set the timeout value with clients.
=== server_name ===
'''syntax:''' ''server_name name''
'''default:''' ''The name of the host, obtained through gethostname()''
'''context:''' ''tcp, server''
'''description:''' The same as [http://wiki.nginx.org/NginxMailCoreModule#server_name server_name]. You can specify several server name in different server block with the same port. They can be used in websocket module.
=== resolver ===
'''syntax:''' ''resolver address''
'''default:''' ''none''
'''context:''' ''tcp, server''
'''description:''' DNS server
=== resolver_timeout ===
'''syntax:''' ''resolver_timeout time''
'''default:''' ''30s''
'''context:''' ''tcp, server''
'''description:''' Resolver timeout in seconds.
== ngx_tcp_upstream_module ==
=== upstream ===
'''syntax:''' ''upstream {...}''
'''default:''' ''none''
'''context:''' ''tcp''
'''description:''' All the upstream directives are contained in this block. The upstream server will be dispatched with round robin by default.
=== server ===
'''syntax:''' ''server name [parameters]''
'''default:''' ''none''
'''context:''' ''upstream''
'''description:''' Most of the parameters are the same as [http://wiki.nginx.org/NginxHttpUpstreamModule#server server]. Default port is 80.
=== check ===
'''syntax:''' ''check interval=milliseconds [fall=count] [rise=count] [timeout=milliseconds] [type=tcp|ssl_hello|smtp|mysql|pop3|imap]''
'''default:''' ''none, if parameters omitted, default parameters are interval=30000 fall=5 rise=2 timeout=1000''
'''context:''' ''upstream''
'''description:''' Add the health check for the upstream servers. At present, the check method is a simple tcp connect.
The parameters' meanings are:
* ''interval'': the check request's interval time.
* ''fall''(fall_count): After fall_count check failures, the server is marked down.
* ''rise''(rise_count): After rise_count check success, the server is marked up.
* ''timeout'': the check request's timeout.
* ''type'': the check protocol type:
# ''tcp'' is a simple tcp socket connect and peek one byte.
# ''ssl_hello'' sends a client ssl hello packet and receives the server ssl hello packet.
# ''http'' sends a http request packet, receives and parses the http response to diagnose if the upstream server is alive.
# ''smtp'' sends a smtp request packet, receives and parses the smtp response to diagnose if the upstream server is alive. The response begins with '2' should be an OK response.
# ''mysql'' connects to the mysql server, receives the greeting response to diagnose if the upstream server is alive.
# ''pop3'' receives and parses the pop3 response to diagnose if the upstream server is alive. The response begins with '+' should be an OK response.
# ''imap'' connects to the imap server, receives the greeting response to diagnose if the upstream server is alive.
=== check_http_send ===
'''syntax:''' ''check_http_send http_packet''
'''default:''' ''"GET / HTTP/1.0\r\n\r\n"''
'''context:''' ''upstream''
'''description:''' If you set the check type is http, then the check function will sends this http packet to check the upstream server.
=== check_http_expect_alive ===
'''syntax:''' ''check_http_expect_alive [ http_2xx | http_3xx | http_4xx | http_5xx ]''
'''default:''' ''http_2xx | http_3xx''
'''context:''' ''upstream''
'''description:''' These status codes indicate the upstream server's http response is OK, the backend is alive.
=== check_smtp_send ===
'''syntax:''' ''check_smtp_send smtp_packet''
'''default:''' ''"HELO smtp.localdomain\r\n"''
'''context:''' ''upstream''
'''description:''' If you set the check type is smtp, then the check function will sends this smtp packet to check the upstream server.
=== check_smtp_expect_alive ===
'''syntax:''' ''check_smtp_expect_alive [smtp_2xx | smtp_3xx | smtp_4xx | smtp_5xx]''
'''default:''' ''smtp_2xx''
'''context:''' ''upstream''
'''description:''' These status codes indicate the upstream server's smtp response is OK, the backend is alive.
=== check_shm_size ===
'''syntax:''' ''check_shm_size size''
'''default:''' ''(number_of_checked_upstream_blocks + 1) * pagesize''
'''context:''' ''tcp''
'''description:''' If you store hundreds of servers in one upstream block, the shared memory for health check may be not enough, you can enlarged it by this directive.
=== tcp_check_status ===
'''syntax:''' ''tcp_check_status''
'''default:''' ''none''
'''context:''' ''location''
'''description:''' Display the health checking servers' status by HTTP. This directive is set in the http block.
The table field meanings are:
* ''Index'': The server index in the check table
* ''Name'' : The upstream server name
* ''Status'': The marked status of the server.
* ''Busyness'': The number of connections which are connecting to the server.
* ''Rise counts'': Count the successful checking
* ''Fall counts'': Count the unsuccessful checking
* ''Access counts'': Count the times accessing to this server
* ''Check type'': The type of the check packet
'''ngx_tcp_upstream_busyness_module'''
=== busyness ===
'''syntax:''' ''busyness''
'''default:''' ''none''
'''context:''' ''upstream''
'''description:''' the upstream server will be dispatched by backend servers' busyness.
'''ngx_tcp_upstream_ip_hash_module'''
=== ip_hash ===
'''syntax:''' ''ip_hash''
'''default:''' ''none''
'''context:''' ''upstream''
'''description:''' the upstream server will be dispatched by ip_hash.
== ngx_tcp_proxy_module ==
=== proxy_pass ===
'''syntax:''' ''proxy_pass host:port''
'''default:''' ''none''
'''context:''' ''server''
'''description:''' proxy the request to the backend server. Default port is 80.
=== proxy_buffer ===
'''syntax:''' ''proxy_buffer size''
'''default:''' ''4k''
'''context:''' ''tcp, server''
'''description:''' set the size of proxy buffer.
=== proxy_connect_timeout ===
'''syntax:''' ''proxy_connect_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of connection to backends.
=== proxy_read_timeout ===
'''syntax:''' ''proxy_read_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of reading from backends.
=== proxy_send_timeout ===
'''syntax:''' ''proxy_send_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of sending to backends.
== ngx_tcp_websocket_module ==
=== websocket_pass ===
'''syntax:''' ''websocket_pass [path] host:port''
'''default:''' ''none''
'''context:''' ''server''
'''description:''' proxy the websocket request to the backend server. Default port is 80. You can specify several different paths in the same server block.
=== websocket_buffer ===
'''syntax:''' ''websocket_buffer size''
'''default:''' ''4k''
'''context:''' ''tcp, server''
'''description:''' set the size of proxy buffer.
=== websocket_connect_timeout ===
'''syntax:''' ''websocket_connect_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of connection to backends.
=== websocket_read_timeout ===
'''syntax:''' ''websocket_read_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of reading from backends. Your timeout will be the minimum of this and the *timeout* parameter, so if you want a long timeout for your websockets, make sure to set both paramaters.
=== websocket_send_timeout ===
'''syntax:''' ''websocket_send_timeout miliseconds''
'''default:''' ''60000''
'''context:''' ''tcp, server''
'''description:''' set the timeout value of sending to backends.
== ngx_tcp_ssl_module ==
The default config file includes this ngx_tcp_ssl_module. If you want to just compile nginx without ngx_tcp_ssl_module, copy the ngx_tcp_proxy_module/config_without_ssl to ngx_tcp_proxy_module/config, reconfigrure and compile nginx.
=== ssl ===
'''syntax:''' ''ssl [on|off] ''
'''default:''' ''ssl off''
'''context:''' ''tcp, server''
Enables SSL for a server.
=== ssl_certificate ===
'''syntax:''' ''ssl_certificate file''
'''default:''' ''ssl_certificate cert.pem''
'''context:''' ''tcp, server''
This directive specifies the file containing the certificate, in PEM format. This file can contain also other certificates and the server private key.
=== ssl_certificate_key ===
'''syntax:''' ''ssl_certificate_key file''
'''default:''' ''ssl_certificate_key cert.pem''
'''context:''' ''tcp, server''
This directive specifies the file containing the private key, in PEM format.
=== ssl_client_certificate ===
'''syntax:''' ''ssl_client_certificate file''
'''default:''' ''none''
'''context:''' ''tcp, server''
This directive specifies the file containing the CA (root) certificate, in PEM format, that is used for validating client certificates.
=== ssl_dhparam ===
'''syntax:''' ''ssl_dhparam file''
'''default:''' ''none''
'''context:''' ''tcp, server''
This directive specifies a file containing Diffie-Hellman key agreement protocol cryptographic parameters, in PEM format, utilized for exchanging session keys between server and client.
=== ssl_ciphers ===
'''syntax:''' ''ssl_ciphers openssl_cipherlist_spec''
'''default:''' ''ssl_ciphers HIGH:!aNULL:!MD5''
'''context:''' ''tcp, server''
This directive describes the list of cipher suites the server supports for establishing a secure connection. Cipher suites are specified in the [http://openssl.org/docs/apps/ciphers.html OpenSSL] cipherlist format, for example:
<geshi lang="nginx">
ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP;
</geshi>
The complete cipherlist supported by the currently installed version of OpenSSL in your platform can be obtained by issuing the command:
<pre>
openssl ciphers
</pre>
=== ssl_crl ===
'''syntax:''' ''ssl_crl file''
'''default:''' ''none''
'''context:''' ''tcp, server''
This directive specifies the filename of a Certificate Revocation List, in PEM format, which is used to check the revocation status of certificates.
=== ssl_prefer_server_ciphers ===
'''syntax:''' ''ssl_prefer_server_ciphers [on|off] ''
'''default:''' ''ssl_prefer_server_ciphers off''
'''context:''' ''tcp, server''
The server requires that the cipher suite list for protocols SSLv3 and TLSv1 are to be preferred over the client supported cipher suite list.
=== ssl_protocols ===
'''syntax:''' ''ssl_protocols [SSLv2] [SSLv3] [TLSv1] [TLSv1.1] [TLSv1.2]''
'''default:''' ''ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2''
'''context:''' ''tcp, server''
This directive enables the protocol versions specified.
=== ssl_verify_client ===
'''syntax:''' ''ssl_verify_client on|off|optional''
'''default:''' ''ssl_verify_client off''
'''context:''' ''tcp, server''
This directive enables the verification of the client identity. Parameter 'optional' checks the client identity using its certificate in case it was made available to the server.
=== ssl_verify_depth ===
'''syntax:''' ''ssl_verify_depth number''
'''default:''' ''ssl_verify_depth 1''
'''context:''' ''tcp, server''
This directive sets how deep the server should go in the client provided certificate chain in order to verify the client identity.
=== ssl_session_cache ===
'''syntax:''' ''ssl_session_cache off|none|builtin:size and/or shared:name:size''
'''default:''' ''ssl_session_cache off''
'''context:''' ''tcp, server''
The directive sets the types and sizes of caches to store the SSL sessions.
The cache types are:
* off -- Hard off: nginx says explicitly to a client that sessions can not reused.
* none -- Soft off: nginx says to a client that session can be resued, but nginx actually never reuses them. This is workaround for some mail clients as ssl_session_cache may be used in mail proxy as well as in HTTP server.
* builtin -- the OpenSSL builtin cache, is used inside one worker process only. The cache size is assigned in the number of the sessions. Note: there appears to be a memory fragmentation issue using this method, please take that into consideration when using this. See "References" below.
* shared -- the cache is shared between all worker processes. The size of the cache is assigned in bytes: 1 MB cache can contain roughly 4000 sessions. Each shared cache must be given an arbitrary name. A shared cache with a given name can be used in several virtual hosts.
It's possible to use both types of cache &mdash; builtin and shared &mdash; simultaneously, for example:
<geshi lang="nginx">
ssl_session_cache builtin:1000 shared:SSL:10m;
</geshi>
Bear in mind however, that using only shared cache, i.e., without builtin, should be more effective.
=== ssl_session_timeout ===
'''syntax:''' ''ssl_session_timeout time''
'''default:''' ''ssl_session_timeout 5m''
'''context:''' ''tcp, server''
This directive defines the maximum time during which the client can re-use the previously negotiated cryptographic parameters of the secure session that is stored in the SSL cache.
= Compatibility =
* My test bed is 0.7.65+
= Notes =
The http_response_parse.rl and smtp_response_parse.rl are [http://www.complang.org/ragel/ ragel] scripts , you can edit the script and compile it like this:
<geshi lang="bash">
$ ragel -G2 http_response_parse.rl
$ ragel -G2 smtp_response_parse.rl
</geshi>
= TODO =
* refact this module, make it more extendable for adding third-party modules
* manipulate header like http module's proxy_set_header
* built-in variable support
* custom log format
* syslog support
* FTP/IRC proxying
= Known Issues =
* This module can't use the same listening port with the HTTP module.
= Changelogs =
== v0.2.0 ==
* add ssl proxy module
* add websocket proxy module
* add upstream busyness module
* add tcp access log module
== v0.19 ==
* add many check methods
== v0.1 ==
* first release
= Authors =
Weibin Yao(姚伟斌) ''yaoweibin at gmail dot com''
= Copyright & License =
This README template copy from [http://github.com/agentzh agentzh].
I borrowed a lot of code from upstream and mail module from the nginx 0.7.* core. This part of code is copyrighted by Igor Sysoev. And the health check part is borrowed the design of Jack Lindamood's healthcheck module [http://github.com/cep21/healthcheck_nginx_upstreams healthcheck_nginx_upstreams];
This module is licensed under the BSD license.
Copyright (C) 2013 by Weibin Yao <yaoweibin@gmail.com>.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

View File

@@ -0,0 +1,99 @@
// Copyright 2014 Isis Innovation Limited and the authors of InfiniTAM
#include <metal_stdlib>
#include "../../DeviceAgnostic/ITMSceneReconstructionEngine.h"
#include "../../DeviceAgnostic/ITMVisualisationEngine.h"
#include "ITMVisualisationEngine_Metal.h"
using namespace metal;
kernel void genericRaycastVH_device(DEVICEPTR(Vector4f) *pointsRay [[ buffer(0) ]],
const CONSTPTR(ITMVoxel) *voxelData [[ buffer(1) ]],
const CONSTPTR(typename ITMVoxelIndex::IndexData) *voxelIndex [[ buffer(2) ]],
const CONSTPTR(Vector2f) *minmaxdata [[ buffer(3) ]],
const CONSTPTR(CreateICPMaps_Params) *params [[ buffer(4) ]],
uint2 threadIdx [[ thread_position_in_threadgroup ]],
uint2 blockIdx [[ threadgroup_position_in_grid ]],
uint2 blockDim [[ threads_per_threadgroup ]])
{
int x = threadIdx.x + blockIdx.x * blockDim.x, y = threadIdx.y + blockIdx.y * blockDim.y;
if (x >= params->imgSize.x || y >= params->imgSize.y) return;
int locId = x + y * params->imgSize.x;
int locId2 = (int)floor((float)x / minmaximg_subsample) + (int)floor((float)y / minmaximg_subsample) * params->imgSize.x;
castRay<ITMVoxel, ITMVoxelIndex>(pointsRay[locId], x, y, voxelData, voxelIndex, params->invM, params->invProjParams,
params->voxelSizes.y, params->lightSource.w, minmaxdata[locId2]);
}
kernel void genericRaycastVGMissingPoints_device(DEVICEPTR(Vector4f) *forwardProjection [[ buffer(0) ]],
const CONSTPTR(int) *fwdProjMissingPoints [[ buffer(1) ]],
const CONSTPTR(ITMVoxel) *voxelData [[ buffer(2) ]],
const CONSTPTR(typename ITMVoxelIndex::IndexData) *voxelIndex [[ buffer(3) ]],
const CONSTPTR(Vector2f) *minmaxdata [[ buffer(4) ]],
const CONSTPTR(CreateICPMaps_Params) *params [[ buffer(5) ]],
uint2 threadIdx [[ thread_position_in_threadgroup ]],
uint2 blockIdx [[ threadgroup_position_in_grid ]],
uint2 blockDim [[ threads_per_threadgroup ]])
{
int pointId = threadIdx.x + blockIdx.x * blockDim.x;
if (pointId >= params->imgSize.z) return;
int locId = fwdProjMissingPoints[pointId];
int y = locId / params->imgSize.x, x = locId - y * params->imgSize.x;
int locId2 = (int)floor((float)x / minmaximg_subsample) + (int)floor((float)y / minmaximg_subsample) * params->imgSize.x;
castRay<ITMVoxel, ITMVoxelIndex>(forwardProjection[locId], x, y, voxelData, voxelIndex, params->invM, params->invProjParams,
params->voxelSizes.y, params->lightSource.w, minmaxdata[locId2]);
}
kernel void renderICP_device(const CONSTPTR(Vector4f) *pointsRay [[ buffer(0) ]],
DEVICEPTR(Vector4f) *pointsMap [[ buffer(1) ]],
DEVICEPTR(Vector4f) *normalsMap [[ buffer(2) ]],
DEVICEPTR(Vector4u) *outRendering [[ buffer(3) ]],
const CONSTPTR(CreateICPMaps_Params) *params [[ buffer(4) ]],
uint2 threadIdx [[ thread_position_in_threadgroup ]],
uint2 blockIdx [[ threadgroup_position_in_grid ]],
uint2 blockDim [[ threads_per_threadgroup ]])
{
int x = threadIdx.x + blockIdx.x * blockDim.x, y = threadIdx.y + blockIdx.y * blockDim.y;
if (x >= params->imgSize.x || y >= params->imgSize.y) return;
processPixelICP<false>(outRendering, pointsMap, normalsMap, pointsRay, params->imgSize.xy, x, y, params->voxelSizes.x, TO_VECTOR3(params->lightSource));
}
kernel void renderForward_device(DEVICEPTR(Vector4u) *outRendering [[ buffer(0) ]],
const CONSTPTR(Vector4f) *pointsRay [[ buffer(1) ]],
const CONSTPTR(CreateICPMaps_Params) *params [[ buffer(2) ]],
uint2 threadIdx [[ thread_position_in_threadgroup ]],
uint2 blockIdx [[ threadgroup_position_in_grid ]],
uint2 blockDim [[ threads_per_threadgroup ]])
{
int x = threadIdx.x + blockIdx.x * blockDim.x, y = threadIdx.y + blockIdx.y * blockDim.y;
if (x >= params->imgSize.x || y >= params->imgSize.y) return;
processPixelForwardRender<false>(outRendering, pointsRay, params->imgSize.xy, x, y, params->voxelSizes.x, TO_VECTOR3(params->lightSource));
}
kernel void forwardProject_device(DEVICEPTR(Vector4f) *forwardProjection [[ buffer(0) ]],
const CONSTPTR(Vector4f) *pointsRay [[ buffer(1) ]],
const CONSTPTR(CreateICPMaps_Params) *params [[ buffer(2) ]],
uint2 threadIdx [[ thread_position_in_threadgroup ]],
uint2 blockIdx [[ threadgroup_position_in_grid ]],
uint2 blockDim [[ threads_per_threadgroup ]])
{
int x = (threadIdx.x + blockIdx.x * blockDim.x), y = (threadIdx.y + blockIdx.y * blockDim.y);
if (x >= params->imgSize.x || y >= params->imgSize.y) return;
int locId = x + y * params->imgSize.x;
Vector4f pixel = pointsRay[locId];
int locId_new = forwardProjectPixel(pixel * params->voxelSizes.x, params->M, params->projParams, params->imgSize.xy);
if (locId_new >= 0) forwardProjection[locId_new] = pixel;
}

View File

@@ -0,0 +1,16 @@
//
// Siesta.h
// Siesta
//
// Created by Paul on 2015/6/14.
// Copyright © 2015 Bust Out Solutions. MIT license.
//
#import <UIKit/UIKit.h>
//! Project version number for Siesta.
FOUNDATION_EXPORT double SiestaVersionNumber;
//! Project version string for Siesta.
FOUNDATION_EXPORT const unsigned char SiestaVersionString[];

31
samples/PHP/mail.phps Normal file
View File

@@ -0,0 +1,31 @@
<?php
/**
* This example shows sending a message using PHP's mail() function.
*/
require '../PHPMailerAutoload.php';
//Create a new PHPMailer instance
$mail = new PHPMailer;
//Set who the message is to be sent from
$mail->setFrom('from@example.com', 'First Last');
//Set an alternative reply-to address
$mail->addReplyTo('replyto@example.com', 'First Last');
//Set who the message is to be sent to
$mail->addAddress('whoto@example.com', 'John Doe');
//Set the subject line
$mail->Subject = 'PHPMailer mail() test';
//Read an HTML message body from an external file, convert referenced images to embedded,
//convert HTML into a basic plain-text alternative body
$mail->msgHTML(file_get_contents('contents.html'), dirname(__FILE__));
//Replace the plain text body with one created manually
$mail->AltBody = 'This is a plain-text message body';
//Attach an image file
$mail->addAttachment('images/phpmailer_mini.png');
//send the message, check for errors
if (!$mail->send()) {
echo "Mailer Error: " . $mail->ErrorInfo;
} else {
echo "Message sent!";
}

View File

@@ -0,0 +1,90 @@
create or replace package plsqlguide is
-- Author : Jared Petersen
-- Created : 9/22/2015 12:26:22 AM
-- Purpose : Basic PLSQL template/guide
/* Procedures */
procedure p_main;
end plsqlguide;
/
create or replace package body plsqlguide is
/* Main entry point (homepage) */
procedure p_main
is
begin
htp.prn('
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags -->
<title>PL/SQL Sample Application</title>
<!-- Bootstrap -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
<!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body>
<!-- Static navbar -->
<nav class="navbar navbar-default navbar-static-top">
<div class="container">
<div class="navbar-header">
<a class="navbar-brand" href="#">PL/SQL Sample Application</a>
</div>
</div>
</nav>
<div class="container">
<table class="table table-bordered">
<tr>
<th>#</th>
<th>Name</th>
<th>Description</th>
<th>Quantity</th>
<th>Price</th>
</tr>
');
-- Fill out the parts table
for row in (select * from parts) loop
htp.prn('
<tr>
<td>'||row.pid||'</td>
<td>'||row.name||'</td>
<td>'||row.description||'</td>
<td>'||row.quantity||'</td>
<td>'||row.price||'</td>
</tr>
');
end loop;
htp.prn('
</table>
</div> <!-- /container -->
<!-- jQuery (necessary for Bootstrap''s JavaScript plugins) -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<!-- Include all compiled plugins (below), or include individual files as needed -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/js/bootstrap.min.js"></script>
</body>
</html>
');
end p_main;
begin
-- Initialization
null;
end plsqlguide;
/

207
samples/POV-Ray SDL/balcony.pov Executable file
View File

@@ -0,0 +1,207 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Scene Description File
// File: balcony.pov
// Desc: Povray demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
//
// ***********************************************************************
//
// -------------------- 'balcony' demonstration scene --------------------
//
// written July-August 2001 by Christoph Hormann <chris_hormann@gmx.de>
//
// demonstrates use of various new or changed features:
//
// - isosurface (for the rail columns)
// - mesh2 object (table cloth)
// - uv-mapping (table cloth)
// - pattern image type (background heightfield)
// - slope pattern (background heightfield)
// - variable reflection (water & glass)
// - metallic reflection
// - conserve_energy
// - function pattern (water)
// - fading interior (water, drink)
// - 'circular' and 'orient' area_light
// - radiosity
// - photons (objects on the table)
//
// ***********************************************************************
//
// Command line options:
//
// -w240 -h320
// -w480 -h640 +a0.3
// -w600 -h800 +a0.3
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#version 3.6;
#include "functions.inc"
#include "colors.inc"
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#declare AreaLight=on;
#declare Radiosity=on;
#declare Photons=on;
#declare TestLight=off;
#declare show_Fog=true;
#declare show_Water=true;
#declare show_Terrain=true;
#declare show_Building=true;
#declare show_Table=true;
#declare show_TableCloth=true;
#declare show_Chair=true;
#declare show_Table_Stuff=true;
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
global_settings{
max_trace_level 15
assumed_gamma 1
#if (Radiosity=on)
radiosity{
pretrace_start 0.08
pretrace_end 0.01
count 130
nearest_count 5
error_bound 0.3
recursion_limit 1
low_error_factor 0.5
gray_threshold 0.0
minimum_reuse 0.015
brightness 1.0
adc_bailout 0.01/2
normal on
}
#end
#if (Photons=on)
photons {
spacing 0.002
}
#end
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
// This scene uses a non-standard camera set-up.
// (See CAMERA in the included documentation for details.)
// If you are new to POV-Ray, you might want to try a different demo scene.
camera {
location <0.5, 0.5, 1.2>
direction y
sky z
up z
right x*image_width/image_height // keep propotions with any aspect ratio
look_at <5, 4.3, 0.9>
angle 36
}
/*
camera { // table detail camera
location <1.5, 1.5, 1.0>
direction y
sky z
up z
right x*image_width/image_height // keep propotions with any aspect ratio
look_at <3.3,2.52,0.5>
angle 30
}
*/
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (TestLight=on)
light_source {
<2, 2, 2>
color rgb 0.7
}
#end
light_source {
<3.0, -2.5, 2.6>*10000
color rgb <3.43,2.87,1.95>
#if (AreaLight=on)
area_light 400*x 400*y 4,4
jitter
circular
orient
#end
photons {
reflection on
refraction on
}
}
#if (show_Fog)
fog{
fog_type 2
fog_alt 1.2
fog_offset 0
color rgbt <0.60, 0.68, 0.82, 0.0>
distance 700
up z
}
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "sky.inc"
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (show_Water)
#include "water.inc"
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (show_Building)
#include "building.inc"
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (show_Terrain)
#include "terrain.inc"
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (show_Table)
#include "table.inc"
#end
#if (show_TableCloth)
#include "table_cloth.inc"
#end
#if (show_Table_Stuff)
#include "table_stuff.inc"
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (show_Chair)
#include "chair.inc"
#end
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

117
samples/POV-Ray SDL/bglass.inc Executable file
View File

@@ -0,0 +1,117 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: bglass.inc
// Desc: drinking glass for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Mat_Glass=
material {
texture {
pigment { color rgbt 1 }
finish {
ambient 0.0
diffuse 0.1
specular 0.5
roughness 0.05
reflection {
0.0, 1.0
fresnel on
}
conserve_energy
}
}
interior {
ior 1.5
fade_distance 0.1
fade_power 1001
fade_color <0.4,0.4,0.4>
}
}
#declare Mat_Liquid=
material {
texture {
pigment { color rgbt 1 }
finish {
ambient 0.0
diffuse 0.1
specular 0.5
roughness 0.01
reflection {
0.0, 1.0
fresnel on
}
conserve_energy
}
}
interior {
ior 1.3
fade_distance 0.03
fade_power 1001
fade_color <0.8,0.3,0.4>
}
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "shapes.inc"
#local Content_Shape=
merge {
cylinder {
0*z, 5*z, 3.0
}
object { Round_Cylinder_Merge (2*z, -3*z, 3.0, 0.25) }
material { Mat_Liquid }
}
#declare Glass=
union {
merge {
difference {
cylinder {
0.01*z, 14*z, 3.2
}
cylinder {
0*z, 10*z, 3.0
translate 4.6*z
}
object { Round_Cylinder_Merge (2*z, -3*z, 3.0, 0.25) translate 4.6*z }
}
torus {
3.1, 0.1
rotate 90*x
translate 14*z
}
material { Mat_Glass }
}
object { Content_Shape scale 0.99 translate 4.6*z }
scale 1.1
scale 0.01
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

212
samples/POV-Ray SDL/building.inc Executable file
View File

@@ -0,0 +1,212 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: building.inc
// Desc: building for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Tex_Stone=
texture {
pigment {
agate
color_map {
[0.7 color rgb <0.6,0.6,0.6> ]
[1.0 color rgb 0.46 ]
}
warp { turbulence <0.7,0.4,0.4> }
scale <0.3,1.2,1.2>*0.25
rotate -60*y
rotate 70*z
}
finish {
ambient 0.0//0.1
diffuse 0.5
specular 0.15
}
normal {
granite 0.2
warp {turbulence 1}
scale 0.1
}
}
#declare Tex_Floor_A=
texture {
pigment {
color rgb <0.6,0.6,0.6>
}
finish {
ambient 0.0
diffuse 0.5
specular 0.15
}
normal {
granite 0.2
warp {turbulence 1}
scale 0.25
translate 2
}
}
#declare Tex_Floor_B=
texture {
pigment {
color rgb <0.18,0.18,0.22>
}
finish {
ambient 0.0
diffuse 0.5
specular 0.15
}
normal {
granite 0.2
warp {turbulence 1}
scale 0.25
}
}
#declare Tex_Floor=
texture {
checker
texture { Tex_Floor_A },
texture { Tex_Floor_B }
scale 0.4
rotate 45*z
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "shapes.inc"
#declare fn_Rad=
function {
sin(pow(abs(z*0.4),1.8))+0.4
}
#declare Small_Column_part1=
isosurface {
function { min(sqrt( x*x + y*y ) - fn_Rad(x, y, z), sqrt( x*x + y*y + pow(abs(z*2),1.4)) - 1.0) }
max_gradient 1.8
//eval
accuracy 0.001
contained_by { box { -4, 4 } }
translate 4*z
scale 6
texture { Tex_Stone }
}
#declare Small_Column=
union {
object { Small_Column_part1 translate 3*z }
object { Round_Cylinder_Union (0, 3*z, 10, 1) }
object { Round_Cylinder_Union (51*z, 54*z, 10, 1) }
scale 0.01
translate 0.1*z
texture { Tex_Stone }
}
#declare Large_Column=
union {
object { Round_Cylinder_Merge (0.7*z, 0.8*z, 0.22, 0.02) }
cylinder { 0.75*z, 3*z, 0.2 }
object { Round_Box_Union (<-0.23,-0.23,-0.1>, <0.23,0.23,0.15>, 0.02) }
object { Round_Box_Union (<-0.20,-0.20,0.00>, <0.20,0.20,0.70>, 0.02) }
object { Round_Box_Union (<-0.23,-0.23,0.58>, <0.23,0.23,0.70>, 0.02) }
object { Round_Box_Union (<-0.26,-0.26,0.64>, <0.26,0.26,0.74>, 0.02) }
torus { 0.2, 0.06 rotate 90*x translate 2.74*z }
object { Round_Box_Union (<-0.26,-0.26,2.80>, <0.26,0.26,2.88>, 0.01) }
texture { Tex_Stone }
}
#declare Balustrade=
union {
object { Round_Box_Union (<0.0,-0.15,0>, <5,0.15,0.1>, 0.02) }
object { Round_Box_Union (<0.0,-0.15,0.64>, <5,0.15,0.74>, 0.02) }
#declare Cnt=0;
#while (Cnt<10)
object { Small_Column translate(Cnt*0.5+0.6)*x }
#declare Cnt=Cnt+1;
#end
texture { Tex_Stone }
}
#declare Walls=
union {
box { <-0.5,-0.5,-1>, <-2,5.5,3.2> }
box { <-0.5,-0.5,-1>, <5.5,-2,3.2> }
texture { Tex_Stone }
}
#declare Ceiling_Segment=
union {
box { <-0.20,-0.20,2.94>, <0.20,0.20,2.98> }
box { <-0.14,-0.14,2.94>, <0.14,0.14,3.01> }
}
#declare Ceiling=
union {
box { <5.6,5.6,3.04>, <-2,-2,3.5> }
union {
object { Round_Box_Union (<0.0,-0.26,3.1>, <6,0.26,2.88>, 0.02) rotate 180*z }
object { Round_Box_Union (<0.0,-0.26,3.1>, <6,0.26,2.88>, 0.02) rotate -90*z }
translate <5,5,0>
}
difference {
box { <5.0,5.0,2.95>, <-2,-2,3.5> }
object { Ceiling_Segment translate <4.44,4.44,0> }
object { Ceiling_Segment translate <4.44,3.94,0> }
object { Ceiling_Segment translate <3.94,4.44,0> }
object { Ceiling_Segment translate <3.94,3.94,0> }
object { Ceiling_Segment translate <4.44,3.44,0> }
object { Ceiling_Segment translate <3.44,4.44,0> }
object { Ceiling_Segment translate <3.94,3.44,0> }
object { Ceiling_Segment translate <3.44,3.94,0> }
object { Ceiling_Segment translate <4.44,2.94,0> }
object { Ceiling_Segment translate <2.94,4.44,0> }
}
texture { Tex_Stone }
}
#declare Base=
union {
box { <5.4,5.4,0>, <0,0,-1> texture { Tex_Floor } }
box { <6,6,-1>, <0,0,-2> }
texture { Tex_Stone }
}
object { Balustrade rotate 180*z translate <5,5,0> }
object { Balustrade rotate -90*z translate <5,5,0> }
object { Large_Column translate <5,5,0> }
object { Base }
object { Walls }
object { Ceiling }
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

382
samples/POV-Ray SDL/chair.inc Executable file
View File

@@ -0,0 +1,382 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: chair.inc
// Desc: chair for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Tex_Table_Foot=
texture {
pigment {
color rgb 0.4
}
finish {
ambient 0.0
diffuse 0.3
specular 0.4
roughness 0.01
metallic
reflection {
0.8
metallic
}
}
}
#declare Tex_Table_Foot_Bottom=
texture {
pigment {
color rgb 0.2
}
finish {
ambient 0.0
diffuse 0.3
specular 0.4
roughness 0.02
}
}
#declare Tex_Dark_Wood=
texture {
pigment {
bozo
color_map {
[0.3 color rgb <0.0,0.0,0.16> ]
[0.5 color rgb <0.0,0.0,0.08> ]
[0.7 color rgb <0.0,0.0,0.0> ]
}
scale <4,1,1>*0.036
}
finish {
ambient 0.09
diffuse 0.3
specular 0.5
roughness 0.025
reflection {
0.15
metallic
}
}
normal {
granite 0.1
scale 0.03
accuracy 0.007
}
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "shapes.inc"
#local Chair_Tube_Rad=0.01;
#local Chair_Tube_Curve_Rad=0.045;
#local Chair_Leg_Angle=7;
#local Chair_Leg_AngleA=4;
#local Chair_Leg_Depth=0.13;
#local Chair_Plate_Curve_Rad=0.03;
#local Chair_Plate_Thickness=0.008;
#local Chair_Plate_Width=0.48;
#local Chair_Plate_UWidth=0.22;
#local Chair_Plate_Height=0.45;
#local Chair_Plate_UAngle=5;
#local Chair_Plate_Depth=0.26;
#local Chair_Leg=
union {
intersection {
torus { Chair_Tube_Curve_Rad, Chair_Tube_Rad }
plane { x, 0 }
plane { -x, 0 rotate (-90+Chair_Leg_Angle)*y }
}
cylinder {
<-Chair_Tube_Curve_Rad,0,0>,
<-Chair_Tube_Curve_Rad,0,-Chair_Plate_Height+0.01>, Chair_Tube_Rad
rotate Chair_Leg_Angle*y
}
cylinder {
<0,0,Chair_Tube_Curve_Rad>,
<Chair_Leg_Depth,0,Chair_Tube_Curve_Rad>, Chair_Tube_Rad
}
object { Round_Cylinder_Merge (
<-Chair_Tube_Curve_Rad,0,-Chair_Plate_Height-0.003>,
<-Chair_Tube_Curve_Rad,0,-Chair_Plate_Height+0.025>, Chair_Tube_Rad+0.001, 0.005)
rotate Chair_Leg_Angle*y
texture { Tex_Table_Foot_Bottom }
}
translate -Chair_Leg_Depth*x
translate Chair_Plate_Height*cos(radians(Chair_Leg_Angle))*z
}
#macro Chair_Back(Rotate)
union {
intersection {
torus { Chair_Tube_Curve_Rad, Chair_Tube_Rad }
plane { x, 0 }
plane { z, 0 }
translate <-Chair_Leg_Depth, 0.0,Chair_Tube_Curve_Rad*2>
}
cylinder {
<-0.08, 0.0,Chair_Tube_Curve_Rad>,
< 0.05, 0.0,Chair_Tube_Curve_Rad>, Chair_Tube_Rad
}
intersection {
torus { 4, Chair_Tube_Rad }
plane { z, 0.4 }
plane { -z, 0 }
translate <-4-Chair_Leg_Depth-Chair_Tube_Curve_Rad, 0.0,Chair_Tube_Curve_Rad*2>
}
translate -Chair_Tube_Curve_Rad*z
rotate 3*y
rotate Rotate*x
translate Chair_Tube_Curve_Rad*z
translate Chair_Plate_Height*cos(radians(Chair_Leg_Angle))*z
}
#end
#local Chair_Base=
union {
union {
object { Chair_Back(-0.25) translate Chair_Tube_Rad*2*y }
object { Chair_Leg }
object { Chair_Leg rotate 180*z }
rotate -Chair_Leg_AngleA*x
translate -0.23*y
}
union {
object { Chair_Back( 0.25) translate -Chair_Tube_Rad*2*y }
object { Chair_Leg }
object { Chair_Leg rotate 180*z }
rotate Chair_Leg_AngleA*x
translate 0.23*y
}
texture { Tex_Table_Foot }
}
#local Chair_Plate=
union {
intersection {
merge {
torus { Chair_Plate_Curve_Rad, Chair_Plate_Thickness translate (Chair_Plate_Width/2)*y }
torus { Chair_Plate_Curve_Rad, Chair_Plate_Thickness translate -(Chair_Plate_Width/2)*y }
difference {
cylinder {
-(Chair_Plate_Width/2)*y, (Chair_Plate_Width/2)*y,
Chair_Plate_Curve_Rad+Chair_Plate_Thickness
}
cylinder {
-(Chair_Plate_Width/1.8)*y, (Chair_Plate_Width/1.8)*y,
Chair_Plate_Curve_Rad-Chair_Plate_Thickness
}
}
}
plane { -z, 0 rotate -20*y}
plane { -x, 0 }
}
merge {
cylinder {
<0.0, -Chair_Plate_Width/2, Chair_Plate_Curve_Rad>
<0.0, Chair_Plate_Width/2, Chair_Plate_Curve_Rad>,
Chair_Plate_Thickness
}
sphere { <0.0, -Chair_Plate_Width/2, Chair_Plate_Curve_Rad>, Chair_Plate_Thickness }
sphere { <0.0, Chair_Plate_Width/2, Chair_Plate_Curve_Rad>, Chair_Plate_Thickness }
rotate 70*y
}
box {
< 0.00, -Chair_Plate_Width/2, Chair_Plate_Curve_Rad-Chair_Plate_Thickness>,
<-Chair_Plate_Depth, Chair_Plate_Width/2, Chair_Plate_Curve_Rad+Chair_Plate_Thickness>
}
cylinder {
< 0.00, -Chair_Plate_Width/2, Chair_Plate_Curve_Rad>
<-Chair_Plate_Depth, -Chair_Plate_Width/2, Chair_Plate_Curve_Rad>,
Chair_Plate_Thickness
}
cylinder {
< 0.00, Chair_Plate_Width/2, Chair_Plate_Curve_Rad>
<-Chair_Plate_Depth, Chair_Plate_Width/2, Chair_Plate_Curve_Rad>,
Chair_Plate_Thickness
}
box {
<-Chair_Plate_Depth, -Chair_Plate_Width/2+Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad-Chair_Plate_Thickness>,
<-Chair_Plate_Depth-Chair_Plate_Curve_Rad, Chair_Plate_Width/2-Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad+Chair_Plate_Thickness>
}
cylinder {
<-Chair_Plate_Depth, Chair_Plate_Width/2-Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad-Chair_Plate_Thickness>
<-Chair_Plate_Depth, Chair_Plate_Width/2-Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad+Chair_Plate_Thickness>,
Chair_Plate_Curve_Rad
}
cylinder {
<-Chair_Plate_Depth, -Chair_Plate_Width/2+Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad-Chair_Plate_Thickness>
<-Chair_Plate_Depth, -Chair_Plate_Width/2+Chair_Plate_Curve_Rad,
Chair_Plate_Curve_Rad+Chair_Plate_Thickness>,
Chair_Plate_Curve_Rad
}
torus {
Chair_Plate_Curve_Rad, Chair_Plate_Thickness
rotate 90*x
translate <-Chair_Plate_Depth,
-Chair_Plate_Width/2+Chair_Plate_Curve_Rad, Chair_Plate_Curve_Rad>
}
torus {
Chair_Plate_Curve_Rad, Chair_Plate_Thickness
rotate 90*x
translate <-Chair_Plate_Depth,
Chair_Plate_Width/2-Chair_Plate_Curve_Rad, Chair_Plate_Curve_Rad>
}
translate (Chair_Plate_Height+0.03)*z
translate 0.18*x
}
#local Chair_Back_Plate=
union {
intersection {
union {
intersection {
difference {
cylinder { <0.0, -0.30, 0.0>, <0.0, 0.30, 0.0>, 4+2*Chair_Plate_Thickness }
cylinder { <0.0, -0.40, 0.0>, <0.0, 0.40, 0.0>, 4 }
}
plane { y, Chair_Plate_UWidth rotate Chair_Plate_UAngle*x }
plane { -y, Chair_Plate_UWidth rotate -Chair_Plate_UAngle*x }
}
torus {
4+Chair_Plate_Thickness, Chair_Plate_Thickness
scale <1, 1, 1/cos(radians(Chair_Plate_UAngle))>
rotate Chair_Plate_UAngle*x
translate Chair_Plate_UWidth*y
}
torus {
4+Chair_Plate_Thickness, Chair_Plate_Thickness
scale <1, 1, 1/cos(radians(Chair_Plate_UAngle))>
rotate -Chair_Plate_UAngle*x
translate -Chair_Plate_UWidth*y
}
}
plane { z, 0 rotate -8*y }
plane { -z, 0 rotate -0.2*y }
}
intersection {
union {
cylinder {
<4+Chair_Plate_Thickness, 0.3, 0.0>,
<4+Chair_Plate_Thickness, -0.3, 0.0>,
Chair_Plate_Thickness
rotate -0.2*y
}
cylinder {
<4+Chair_Plate_Thickness, 0.3, 0.0>,
<4+Chair_Plate_Thickness, -0.3, 0.0>,
Chair_Plate_Thickness
rotate -8*y
}
}
plane { y, Chair_Plate_UWidth rotate Chair_Plate_UAngle*x }
plane { -y, Chair_Plate_UWidth rotate -Chair_Plate_UAngle*x }
}
sphere {
<4+Chair_Plate_Thickness, Chair_Plate_UWidth, 0.0>,
Chair_Plate_Thickness
rotate -0.2*y
}
sphere {
<4+Chair_Plate_Thickness, -Chair_Plate_UWidth, 0.0>,
Chair_Plate_Thickness
rotate -0.2*y
}
sphere {
<4+Chair_Plate_Thickness,
Chair_Plate_UWidth-4*sin(radians(Chair_Plate_UAngle))*sin(radians(8)), 0.0>,
Chair_Plate_Thickness
rotate -8*y
}
sphere {
<4+Chair_Plate_Thickness,
-Chair_Plate_UWidth+4*sin(radians(Chair_Plate_UAngle))*sin(radians(8)), 0.0>,
Chair_Plate_Thickness
rotate -8*y
}
translate <-4-Chair_Leg_Depth-Chair_Tube_Curve_Rad+Chair_Tube_Rad,
0.0, Chair_Tube_Curve_Rad*2>
translate -Chair_Tube_Curve_Rad*z
rotate 3*y
translate Chair_Tube_Curve_Rad*z
translate Chair_Plate_Height*cos(radians(Chair_Leg_Angle))*z
}
union {
object { Chair_Back_Plate texture { Tex_Dark_Wood rotate 90*y } }
object { Chair_Plate texture { Tex_Dark_Wood } }
object { Chair_Base }
scale 0.92
rotate -60*z
translate <2.68,3.35,0>
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

12217
samples/POV-Ray SDL/cloth.inc Executable file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,188 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence of Vision Ray Tracer Scene Description File
// File: gamma_showcase.pov
// Vers: 3.7
// Desc: Gamma Handling Test Scene - An arrangement of spheres on a marble plane
// Date: 2010-12-21
// Auth: Christoph Lipka
//
// +w640 +h480 +a0.3 +am1 +fN -d File_Gamma=sRGB Output_File_Name=gamma_showcase.png
// +w640 +h480 +a0.3 +am1 +fN -d File_Gamma=1.0 Output_File_Name=gamma_showcase_linear.png
// +w320 +h240 +a0.3 +am1 +fN -d File_Gamma=sRGB Output_File_Name=gamma_showcase_ref0.png Declare=Stripes=off
// +w320 +h240 +a0.3 +am1 +fN -d File_Gamma=sRGB Output_File_Name=gamma_showcase_ref1.png Declare=Stripes=off Declare=Gamma=1.2
// +w320 +h240 +a0.3 +am1 +fN -d File_Gamma=sRGB Output_File_Name=gamma_showcase_ref2.png Declare=Stripes=off Declare=Gamma=0.8
// +w640 +h480 +a0.3 +am1 -f +d
#version 3.7;
#include "colors.inc"
#include "stones.inc"
#ifndef (Stripes)
#declare Stripes = on;
#end
#ifndef (Gamma)
#declare Gamma = 1.0;
#end
global_settings {
max_trace_level 5
assumed_gamma 1.0
radiosity {
pretrace_start 0.08
pretrace_end 0.01
count 35
nearest_count 5
error_bound 1.8
recursion_limit 2
low_error_factor .5
gray_threshold 0.0
minimum_reuse 0.015
brightness 1
adc_bailout 0.01/2
}
}
#default {
texture {
pigment {rgb 1}
finish {
ambient 0.0
diffuse 0.6
specular 0.6 roughness 0.001
reflection { 0.0 1.0 fresnel on }
conserve_energy
}
}
}
// ----------------------------------------
#local TestRed = rgb <0.5,0.1,0.1>;
#local TestGreen = rgb <0.1,0.5,0.1>;
#local TestBlue = rgb <0.1,0.1,0.5>;
#local CameraFocus = <0,0.5,0>;
#local CameraDist = 8;
#local CameraDepth = 1.8;
#local CameraTilt = 20;
camera {
location <0,0,0>
direction z*CameraDepth
right x*image_width/image_height
up y
translate <0,0,-CameraDist>
rotate x*CameraTilt
translate CameraFocus
}
#macro LightSource(Pos,Color)
light_source {
Pos
color Color
spotlight
point_at <0,0,0>
radius 175/vlength(Pos)
falloff 200/vlength(Pos)
area_light x*vlength(Pos)/10, y*vlength(Pos)/10, 9,9 adaptive 1 jitter circular orient
}
#end
LightSource(<-500,500,-500>,TestRed + <0.2,0.2,0.2>)
LightSource(< 0,500,-500>,TestGreen + <0.2,0.2,0.2>)
LightSource(< 500,500,-500>,TestBlue + <0.2,0.2,0.2>)
// ----------------------------------------
#macro DarkStripeBW(TargetBrightness)
#if (TargetBrightness < 0.5)
(0.0)
#else
(TargetBrightness*2 - 1.0)
#end
#end
#macro BrightStripeBW(TargetBrightness)
#if (TargetBrightness < 0.5)
(TargetBrightness*2)
#else
(1.0)
#end
#end
#macro DarkStripeRGB(TargetColor)
<DarkStripeBW(TargetColor.red),DarkStripeBW(TargetColor.green),DarkStripeBW(TargetColor.blue)>
#end
#macro BrightStripeRGB(TargetColor)
<BrightStripeBW(TargetColor.red),BrightStripeBW(TargetColor.green),BrightStripeBW(TargetColor.blue)>
#end
#macro StripedPigment(TargetColor)
#if (Stripes)
function { abs(mod(abs(image_height*CameraDepth*y/z+0.5),2.0)-1.0) }
color_map {
[0.5 color rgb DarkStripeRGB(TargetColor) ]
[0.5 color rgb BrightStripeRGB(TargetColor) ]
}
translate <0,0,-CameraDist>
rotate x*CameraTilt
translate CameraFocus
#else
color TargetColor
#end
#end
plane {
y, 0
texture { T_Stone11 }
interior { ior 1.5 }
}
#macro GammaAdjust(C,G)
#local C2 = color rgbft <pow(C.red,G),pow(C.green,G),pow(C.blue,G),pow(C.filter,G),pow(C.transmit,G)>;
(C2)
#end
#macro TestSphere(Pos,Radius,TargetColor,Split)
sphere {
Pos + y*Radius, Radius
texture { pigment { color GammaAdjust(TargetColor,Gamma) } }
interior { ior 1.5 }
}
#if (Split)
sphere {
Pos + y*Radius + x*0.001, Radius
texture { pigment { StripedPigment(TargetColor) } }
interior { ior 1.5 }
}
#end
#end
TestSphere(<-2,0,1>, 1, TestRed, true)
TestSphere(< 0,0,1>, 1, TestGreen, true)
TestSphere(< 2,0,1>, 1, TestBlue, true)
#local Steps = 6;
#for(I,0,1,1/Steps)
#if (I < 0.5)
#local Color2 = TestRed;
#else
#local Color2 = TestBlue;
#end
#local P = abs(I-0.5)*2;
TestSphere(<I*4-2,0,-0.5>, 2/Steps, (1-P)*TestGreen + P*Color2, true)
#end
#local Steps = 8;
#for(I,0,1,1/Steps)
TestSphere(<I*4-2,0,-1.5>, 2/Steps, rgb I, true)
TestSphere(<I*4-2,0,-2.0>, 2/Steps, GammaAdjust(rgb I, 2.2*Gamma), false)
#end

91
samples/POV-Ray SDL/sky.inc Executable file
View File

@@ -0,0 +1,91 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: sky.inc
// Desc: sky for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#local P_Clouds=
pigment {
gradient z
pigment_map {
[ 0.0 color rgbt 1]
[ 0.1
bozo
color_map {
[0.0 color rgbt < 0.85, 0.88, 0.94, 0.0>]
[0.15 color rgbt < 0.91, 0.96, 0.99, 0.0>]
[0.35 color rgbt < 0.91, 0.96, 0.99, 1.0>]
}
turbulence 0.75
lambda 2.4
omega 0.6
octaves 8
scale <0.4,0.4,0.15>
]
[ 0.4
bozo
color_map {
[0.0 color rgbt < 0.85, 0.88, 0.94, 0.0>]
[0.15 color rgbt < 0.91, 0.96, 0.99, 0.0>]
[0.35 color rgbt < 0.91, 0.96, 0.99, 1.0>]
}
turbulence 0.75
lambda 2.4
omega 0.6
octaves 8
scale <0.4,0.4,0.15>
]
[ 0.65 color rgbt 1]
}
rotate 10*z
}
#local Tex_Sky =
texture {
pigment {
function { abs(z) }
color_map {
[0.0 color rgb < 0.640, 0.685, 0.800 >]
[0.3 color rgb < 0.400, 0.550, 0.900 >]
}
turbulence 0.05
}
finish {
diffuse 0
ambient 1
}
}
texture {
pigment { P_Clouds }
finish {
diffuse 0
ambient 1
}
}
sphere {
<0, 0, 0>, 1
texture { Tex_Sky }
scale<1000000, 1000000, 300000>
no_shadow
hollow on
photons{ collect off }
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

171
samples/POV-Ray SDL/table.inc Executable file
View File

@@ -0,0 +1,171 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: table.inc
// Desc: table for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Tex_Table_Foot=
texture {
pigment {
color rgb 0.4
}
finish {
ambient 0.0
diffuse 0.3
specular 0.4
roughness 0.01
metallic
reflection {
0.8
metallic
}
}
}
#declare Tex_Table_Foot_Bottom=
texture {
pigment {
color rgb 0.2
}
finish {
ambient 0.0
diffuse 0.3
specular 0.4
roughness 0.02
}
}
#declare Tex_Dark_Wood=
texture {
pigment {
bozo
color_map {
[0.3 color rgb <0.0,0.0,0.16> ]
[0.5 color rgb <0.0,0.0,0.08> ]
[0.7 color rgb <0.0,0.0,0.0> ]
}
scale <4,1,1>*0.036
}
finish {
ambient 0.09
diffuse 0.3
specular 0.5
roughness 0.025
reflection {
0.15
metallic
}
}
normal {
granite 0.1
scale 0.03
accuracy 0.007
}
scale 0.5
rotate 90*y
}
#declare Tex_Dark_Wood2 =
texture {
pigment {
wood
color_map {
[ 0.0000 color rgb<0.6431, 0.3176, 0.0824> ]
[ 0.1000 color rgb<0.6196, 0.2824, 0.0588> ]
[ 0.2000 color rgb<0.7137, 0.3725, 0.1529> ]
[ 0.3000 color rgb<0.7529, 0.4157, 0.1922> ]
[ 0.4000 color rgb<0.8157, 0.4941, 0.2588> ]
[ 0.5000 color rgb<0.7686, 0.4745, 0.2196> ]
[ 0.6000 color rgb<0.8471, 0.5647, 0.2980> ]
[ 0.7000 color rgb<0.8627, 0.5843, 0.3137> ]
[ 0.8000 color rgb<0.8902, 0.6314, 0.3529> ]
[ 0.9000 color rgb<0.8627, 0.6118, 0.3294> ]
[ 1.0000 color rgb<0.8392, 0.5922, 0.3098> ]
}
turbulence <0.075, 0.075, 0.65>
scale <0.04, 0.04, 0.6>
scale 0.27
rotate 91*y
translate -0.1*z
}
finish {
ambient 0.0
diffuse 0.4
specular 0.3
roughness 0.025
reflection {
0.17
metallic
}
}
normal {
granite 0.015
scale <0.02, 0.02, 0.06>
rotate 91*y
accuracy 0.007
}
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "shapes.inc"
#declare Table_Height=0.66;
#declare Table=
union {
torus { 0.49, 0.01 sturm rotate 90*x translate z*(Table_Height-0.01) }
cylinder { z*(Table_Height-0.05), z*(Table_Height-0.01), 0.5 }
cylinder { z*(Table_Height-0.01), z*Table_Height, 0.49 }
union {
cylinder { z*0.01, z*0.63, 0.03 translate 0.37*x }
cylinder { z*0.01, z*0.63, 0.03 translate 0.37*x rotate 120*z }
cylinder { z*0.01, z*0.63, 0.03 translate 0.37*x rotate 240*z }
texture { Tex_Table_Foot }
rotate -70*z
}
union {
object { Round_Cylinder_Merge (0, z*0.03, 0.031, 0.005) translate 0.37*x }
object { Round_Cylinder_Merge (0, z*0.03, 0.031, 0.005) translate 0.37*x rotate 120*z }
object { Round_Cylinder_Merge (0, z*0.03, 0.031, 0.005) translate 0.37*x rotate 240*z }
texture { Tex_Table_Foot_Bottom }
rotate -70*z
}
texture { Tex_Dark_Wood2 }
#if (show_TableCloth)
scale <0.97, 0.97, 0.99>
#else
scale <0.97, 0.97, 1.00>
#end
}
object { Table translate <3.3,2.52,0> }
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

View File

@@ -0,0 +1,91 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: table_cloth.inc
// Desc: table cloth for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare ClCol01=color rgb <0.8, 0.7, 0.4>;
#declare ClCol02=color rgb <0.07, 0.12, 0.4>;
#declare CPig1=
pigment {
gradient x
triangle_wave
color_map {
[0.04 ClCol01 ]
[0.04 ClCol02 ]
[0.06 ClCol02 ]
[0.06 ClCol01 ]
[0.09 ClCol01 ]
[0.09 ClCol02 ]
[0.13 ClCol02 ]
[0.13 ClCol01 ]
[0.16 ClCol01 ]
[0.16 ClCol02 ]
[0.18 ClCol02 ]
[0.18 ClCol01 ]
}
}
#declare CPig2=
pigment {
gradient y
triangle_wave
pigment_map {
[0.04 CPig1 ]
[0.04 ClCol02 ]
[0.06 ClCol02 ]
[0.06 CPig1 ]
[0.09 CPig1 ]
[0.09 ClCol02 ]
[0.13 ClCol02 ]
[0.13 CPig1 ]
[0.16 CPig1 ]
[0.16 ClCol02 ]
[0.18 ClCol02 ]
[0.18 CPig1 ]
}
}
/*
#include "clothutil.inc"
ReadClothFile("cloth.cth")
DrawSmoothTriangles2(Points, 90, 90, on, true, "cloth.inc")
*/
#declare Table_Cloth=
mesh2{
#include "cloth.inc"
texture {
uv_mapping
pigment {
CPig2
}
finish {
ambient 0.0
diffuse 0.6
}
normal {
quilted 0.16
scale 0.008
}
}
rotate -30*z
}
object { Table_Cloth translate <3.3,2.52,0> }
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

View File

@@ -0,0 +1,136 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: table_stuff.inc
// Desc: stuff on the table for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Mat_Glass=
material {
texture {
pigment { color rgbt 1 }
finish {
ambient 0.0
diffuse 0.1
specular 0.5
roughness 0.01
reflection {
0.15, 1.0
fresnel on
}
conserve_energy
}
}
interior {
ior 1.5
fade_distance 0.1
fade_power 1001
fade_color <0.4,0.4,0.8>
}
}
#declare Tex_Box_Metal=
texture {
pigment {
color rgb <0.5,0.45,0.4>
}
finish {
ambient 0.0
diffuse 0.05
specular 0.5
roughness 0.01
metallic
reflection {
0.8
metallic
}
}
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#include "shapes.inc"
#include "functions.inc"
#declare Table_Height=0.66;
#declare Box_Iso=
isosurface {
function { -f_superellipsoid(x,y,z, 0.2, 0.2) }
contained_by {box { -1.2, 1.2 }}
max_gradient 1.1
translate 1.001*z
}
#declare Box=
union {
intersection {
object { Box_Iso }
object { Round_Box_Merge (<-1.1,-1.1,1.6>, <1.1,1.1,-0.1>, 0.4) }
}
intersection {
object { Box_Iso }
object { Round_Box_Merge (<-1.1,-1.1,1.6>, <1.1,1.1,2.2>, 0.4) }
scale 1.01
rotate 0.2
}
torus {
0.6, 0.13
rotate 90*z
translate 2*z
}
scale <1,1,0.6>
}
#include "bglass.inc"
union {
object {
Glass
photons{
target 1.0
refraction on
reflection on
}
translate <-0.16,-0.1,0>
}
object {
Box
texture {
Tex_Box_Metal
}
photons{
target 1.0
reflection on
}
scale 0.06
translate <-0.1,0.2,0>
}
translate <3.3,2.52,Table_Height>
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

118
samples/POV-Ray SDL/terrain.inc Executable file
View File

@@ -0,0 +1,118 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence of Vision Ray Tracer Include File
// File: terrain.inc
// Desc: terrain for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#declare Tex_Vegetation=
texture {
pigment {
bozo
color_map {
[0.3 color rgb <0.20,0.35,0.1>*0.9 ]
[0.8 color rgb <0.12,0.35,0.1>*0.7 ]
}
scale 4
}
finish {
ambient 0.0
diffuse 0.5
brilliance 0.8
specular 0.1
}
normal {
granite 0.4
}
}
#declare Tex_Stone=
texture {
pigment {
color rgb <0.6,0.6,0.6>
}
finish {
ambient 0.0//0.1
diffuse 0.45
specular 0.15
}
}
#declare Tex_Terrain=
texture {
slope -z
texture_map {
[0.34 Tex_Vegetation ]
[0.34 Tex_Stone ]
}
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#declare Terrain=
object {
height_field {
function 300,300 {
pigment {
function { 1-(min(pow(x*x + z*z,1.3), 1) -0.0001) }
color_map {
[0.0 color rgb 0.0]
[1.0 color rgb 1.0]
}
scale 0.35
translate <0.5,0,0.5>
warp { turbulence 0.3 }
scale 3
warp { turbulence 0.4 lambda 2.2 octaves 8 }
scale 1/3
rotate -90*x
translate -0.5*y
scale <1, -1, 1>
translate 0.5*y
}
}
water_level 0.02
rotate 90*x
rotate -10*z
scale <4, 4, 1>
scale 30
}
}
union {
object {
Terrain
translate <130, 368, -10>
}
object {
Terrain
rotate -180*z
scale 0.3
translate <90, 97, -6>
}
texture { Tex_Terrain }
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

74
samples/POV-Ray SDL/water.inc Executable file
View File

@@ -0,0 +1,74 @@
// This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
// To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
// letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
// Persistence Of Vision Ray Tracer Include File
// File: water.inc
// Desc: water for 'balcony.pov' demonstration scene
// Date: July/August 2001
// Auth: Christoph Hormann
// Updated: 09Aug2008 (jh) for v3.7 distribution
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
#if (version < 3.7)
#version 3.5;
#end
#include "functions.inc"
#declare RMF=function{ f_ridged_mf(x, y, z, 0.07, 2.2, 7, 0.6, 0.9, 1)}
#declare M_Watx4 =
material {
texture {
pigment {
color rgbt <0.2, 0.22, 0.21, 0.94>
}
finish {
diffuse 0.0
ambient -0.2
reflection {
0.0, 0.95
fresnel on
}
conserve_energy
specular 0.4
roughness 0.007
}
normal{
function { RMF(x, y, z) } 0.8
scale 0.3
}
}
interior {
ior 1.31
fade_distance 5
fade_power 1001.0
fade_color <0.02, 0.20, 0.06>
}
}
plane {
z, -1
material {
M_Watx4
}
hollow on
}
plane {
z, -12.0
texture {
pigment { color rgb 0 }
finish { ambient 0.0 diffuse 0.0 }
}
hollow on
}
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

10
samples/Perl/Sample.pod Normal file
View File

@@ -0,0 +1,10 @@
use strict;
use warnings;
package DZT::Sample;
sub return_arrayref_of_values_passed {
my $invocant = shift;
return \@_;
}
1;

View File

@@ -12,7 +12,6 @@ unless EVAL 'EVAL("1", :lang<perl5>)' {
die unless
EVAL(q/
package My::Hash;
use strict;
sub new {
my ($class, $ref) = @_;

24
samples/Pickle/data.pkl Normal file
View File

@@ -0,0 +1,24 @@
(dp0
S'a'
p1
(lp2
I1
aF2.0
aI3
ac__builtin__
complex
p3
(F4.0
F6.0
tp4
Rp5
asS'c'
p6
NsS'b'
p7
(S'string'
p8
VUnicode string
p9
tp10
s.

File diff suppressed because one or more lines are too long

36
samples/Pickle/random.pkl Normal file
View File

@@ -0,0 +1,36 @@
cnumpy.core.multiarray
_reconstruct
p0
(cnumpy
ndarray
p1
(I0
tp2
S'b'
p3
tp4
Rp5
(I1
(I100
tp6
cnumpy
dtype
p7
(S'f8'
p8
I0
I1
tp9
Rp10
(I3
S'<'
p11
NNNI-1
I-1
I0
tp12
bI00
S'\x1cc~\xc3\xa7r\xed?\xe5${\xec\xd6\xcd\xed?\x809-\x02%\xa9\xa2?F\x0f\x1d\xe8\xef\xa3\xdb?\xfe\xd1\x0c\xb7\x83\x13\xef?\xe0<o\xa1\xa9^\xdf?CE\x96\x88/o\xe2?<\xd8\xa1\x96\xa2T\xce?\x152\x8e\xe5\xa8\x7f\xe8?\xe4\xb7\x9a\xe0$\x0f\xdc?\x90\xe4\xe2\xd4=\xce\xc3?Ix\xe3P\xc4C\xe1?\x16\xd17\xc1Y\xfc\xed?5\xd7\xae@4\xfa\xe8?\x0f\x87\x8d>\xfcO\xe5?Y\x97\xcb"\xa7%\xe7?\x9b\x8d\x16\xda\x97\xe1\xeb?T\x14\xbd\xfe|\xf4\xd0?\x18\xdfH\xc56A\xba?\x90\xc5\xfb\xc63:\xe5?\xbf%\xad\xe5.\x86\xe9?\xc6\x0c\xa9\x8c\xd7\xd5\xe9?\xf8\xafc:\x84g\xd7?\xf8\x98\x879\x9a\x16\xee?\xba\xdf\x88\x8az\x06\xe2?~g-\xeb\xc8\xed\xee?\x08A\xcc\x8c\xe7>\xef?\xceD\xc4ar\n\xdc?\x92w\xbb\xa34\xb1\xd9?\x88\xb9\xc0{u\xa3\xdc?d\x1a\xad\xe8\xf3\x14\xdd?\x9c\x95\x13\x96o?\xe5?\x9cT[\xb8r\xa9\xe5?0\xf1\x01+(\x0f\xdf?W\xbdjqD&\xed?c\xcf1-W\xe6\xe1?\xce\xbc\xe1{zW\xd9?"d\xcf\xd7\x13\x93\xde?\xf2P\xf6\xc3\xd6\x87\xd5?\xc2\x0e\x92q\x89\xda\xd5?\xc0:B\x1bb\x00\x9e?Y\xafHmr\x80\xe3?\x1co\xa7\xba\xa5/\xe4?\xa2\xbc \x9c\xddB\xd0?\xd2L\x935\x17\'\xee?|\x8cM\xeb\x97=\xe8?\x0f0xN*V\xea?\x81p\xe3,!\xf2\xee?\xf5w\xed\x10\x9eu\xe0?\xc5\x16\\LR\xb5\xe1?\xbeh\x04\xa4g\xe5\xd6?\xea\xc0\xb9\xf0\xb2\xd8\xd9?\xac\x9c\xeep\x1a\xa9\xd8?@W9hp\x16\xb1?\xc4\xedS\xd6V\xa1\xed?\x93,!\xdc\xa1\x8b\xe9?\x80)\xb1\xa6[T\xc9?\xac\xbc\x8a\xd21\xdd\xc5?\x80\x9c.g\xf1\xf2\xc6?\tLu\xc3\xf7U\xe9?n\'\x9f?\xbe\xf9\xe9?\xa3\xe7K\x1c\xb3\xa9\xea?X\x98\x1a\xcb\xa0\xcd\xd3? \xb6O\x9c\x1bQ\xc2?"\x89[\xad1\x8e\xea?\xdd\x8f\xa0P\xc7\x0e\xe2?c\xa4j\xa3\r\xac\xef?\xba\xb6\x0f\x8emo\xef?\xe0\xed\xa0\xc5R9\xab?U\xf1\xcd\xcf\xbf\xcb\xea?\x89*#\x06\xb0|\xe8?d\xa3\xad\xcd\xe0]\xcc?\xb5\xe78\xa7w\x13\xe3?\xce\x99\x98\xefS%\xd7?\xb1\xf8\xd8\x8eI\x13\xef?\x91`]\x93\xd4 \xec?\xc0\rPz\xee\xbd\xe7?7\x92\xd4\x0fP\x8f\xe1?L\x0f\xaf\xa9\xc3\x19\xdd?\\}\x15X\x870\xc7? ~ t\xcat\xb1?@?\xec\x97u\x05\xe9?F\x8d:\xac4D\xdb?qY\xe1Qk|\xe2? \xaf\xeaj\xa5\x04\xab?J[\x1al;\x00\xd5?\x00^{n\xc2\xf1S?\xb0\x82dN\xda\xb5\xc7?\xe0 \x07\xe1?R\x92?\xc4\r\x08+\x99J\xe1?I|&U\x19\xc4\xe1?|*\xf9\xebq\x7f\xed?\xbc*\x93\x89k\xab\xe9?oiL\x90;\xe0\xef?\x96\xcd\x9b\xff\x18g\xdc?pt\xb4\xa5\x9c\xa2\xbc?Nu]w*\xb7\xd2?\x88k\xac\xd0\xfd\xbf\xd5?Q\x02$b\xfeH\xea?5\xf6\t\xb6K\x1a\xee?'
p13
tp14
b.

10
samples/Pickle/save.pkl Normal file
View File

@@ -0,0 +1,10 @@
(dp0
S'lion'
p1
S'yellow'
p2
sS'kitty'
p3
S'red'
p4
s.

30
samples/Pony/circle.pony Normal file
View File

@@ -0,0 +1,30 @@
use "collections"
class Circle
var _radius: F32
new create(radius': F32) =>
_radius = radius'
fun ref get_radius(): F32 =>
_radius
fun ref get_area(): F32 =>
F32.pi() * _radius.pow(2)
fun ref get_circumference(): F32 =>
2 * _radius * F32.pi()
actor Main
new create(env: Env) =>
for i in Range[F32](1.0, 101.0) do
let c = Circle(i)
var str =
"Radius: " + c.get_radius().string() + "\n" +
"Circumference: " + c.get_circumference().string() + "\n" +
"Area: " + c.get_area().string() + "\n"
env.out.print(str)
end

32
samples/Pony/counter.pony Normal file
View File

@@ -0,0 +1,32 @@
use "collections"
actor Counter
var _count: U32
new create() =>
_count = 0
be increment() =>
_count = _count + 1
be get_and_reset(main: Main) =>
main.display(_count)
_count = 0
actor Main
var _env: Env
new create(env: Env) =>
_env = env
var count: U32 = try env.args(1).u32() else 10 end
var counter = Counter
for i in Range[U32](0, count) do
counter.increment()
end
counter.get_and_reset(this)
be display(result: U32) =>
_env.out.print(result.string())

261
samples/Pony/gups-opt.pony Normal file
View File

@@ -0,0 +1,261 @@
use "options"
use "time"
use "collections"
class Config
var logtable: U64 = 20
var iterate: U64 = 10000
var logchunk: U64 = 10
var logactors: U64 = 2
fun ref apply(env: Env): Bool =>
var options = Options(env)
options
.add("logtable", "l", I64Argument)
.add("iterate", "i", I64Argument)
.add("chunk", "c", I64Argument)
.add("actors", "a", I64Argument)
for option in options do
match option
| ("table", var arg: I64) => logtable = arg.u64()
| ("iterate", var arg: I64) => iterate = arg.u64()
| ("chunk", var arg: I64) => logchunk = arg.u64()
| ("actors", var arg: I64) => logactors = arg.u64()
| let err: ParseError =>
err.report(env.out)
env.out.print(
"""
gups_opt [OPTIONS]
--table N log2 of the total table size. Defaults to 20.
--iterate N number of iterations. Defaults to 10000.
--chunk N log2 of the chunk size. Defaults to 10.
--actors N log2 of the actor count. Defaults to 2.
"""
)
return false
end
end
env.out.print(
"logtable: " + logtable.string() +
"\niterate: " + iterate.string() +
"\nlogchunk: " + logchunk.string() +
"\nlogactors: " + logactors.string()
)
true
actor Main
let _env: Env
let _config: Config = Config
var _updates: U64 = 0
var _confirm: U64 = 0
let _start: U64
var _actors: Array[Updater] val
new create(env: Env) =>
_env = env
if _config(env) then
let actor_count = 1 << _config.logactors
let loglocal = _config.logtable - _config.logactors
let chunk_size = 1 << _config.logchunk
let chunk_iterate = chunk_size * _config.iterate
_updates = chunk_iterate * actor_count
_confirm = actor_count
var updaters = recover Array[Updater](actor_count) end
for i in Range[U64](0, actor_count) do
updaters.push(Updater(this, actor_count, i, loglocal, chunk_size,
chunk_iterate * i))
end
_actors = consume updaters
_start = Time.nanos()
for a in _actors.values() do
a.start(_actors, _config.iterate)
end
else
_start = 0
_actors = recover Array[Updater] end
end
be done() =>
if (_confirm = _confirm - 1) == 1 then
for a in _actors.values() do
a.done()
end
end
be confirm() =>
_confirm = _confirm + 1
if _confirm == _actors.size() then
let elapsed = (Time.nanos() - _start).f64()
let gups = _updates.f64() / elapsed
_env.out.print(
"Time: " + (elapsed / 1e9).string() +
"\nGUPS: " + gups.string()
)
end
actor Updater
let _main: Main
let _index: U64
let _updaters: U64
let _chunk: U64
let _mask: U64
let _loglocal: U64
let _output: Array[Array[U64] iso]
let _reuse: List[Array[U64] iso] = List[Array[U64] iso]
var _others: (Array[Updater] val | None) = None
var _table: Array[U64]
var _rand: U64
new create(main:Main, updaters: U64, index: U64, loglocal: U64, chunk: U64,
seed: U64)
=>
_main = main
_index = index
_updaters = updaters
_chunk = chunk
_mask = updaters - 1
_loglocal = loglocal
_rand = PolyRand.seed(seed)
_output = _output.create(updaters)
let size = 1 << loglocal
_table = Array[U64].undefined(size)
var offset = index * size
try
for i in Range[U64](0, size) do
_table(i) = i + offset
end
end
be start(others: Array[Updater] val, iterate: U64) =>
_others = others
iteration(iterate)
be apply(iterate: U64) =>
iteration(iterate)
fun ref iteration(iterate: U64) =>
let chk = _chunk
for i in Range(0, _updaters) do
_output.push(
try
_reuse.pop()
else
recover Array[U64](chk) end
end
)
end
for i in Range(0, _chunk) do
var datum = _rand = PolyRand(_rand)
var updater = (datum >> _loglocal) and _mask
try
if updater == _index then
_table(i) = _table(i) xor datum
else
_output(updater).push(datum)
end
end
end
try
let to = _others as Array[Updater] val
repeat
let data = _output.pop()
if data.size() > 0 then
to(_output.size()).receive(consume data)
else
_reuse.push(consume data)
end
until _output.size() == 0 end
end
if iterate > 1 then
apply(iterate - 1)
else
_main.done()
end
be receive(data: Array[U64] iso) =>
try
for i in Range(0, data.size()) do
let datum = data(i)
var j = (datum >> _loglocal) and _mask
_table(j) = _table(j) xor datum
end
data.clear()
_reuse.push(consume data)
end
be done() =>
_main.confirm()
primitive PolyRand
fun apply(prev: U64): U64 =>
(prev << 1) xor if prev.i64() < 0 then _poly() else 0 end
fun seed(from: U64): U64 =>
var n = from % _period()
if n == 0 then
return 1
end
var m2 = Array[U64].undefined(64)
var temp = U64(1)
try
for i in Range(0, 64) do
m2(i) = temp
temp = this(temp)
temp = this(temp)
end
end
var i: U64 = 64 - n.clz()
var r = U64(2)
try
while i > 0 do
temp = 0
for j in Range(0, 64) do
if ((r >> j) and 1) != 0 then
temp = temp xor m2(j)
end
end
r = temp
i = i - 1
if ((n >> i) and 1) != 0 then
r = this(r)
end
end
end
r
fun _poly(): U64 => 7
fun _period(): U64 => 1317624576693539401

View File

@@ -0,0 +1,3 @@
actor Main
new create(env: Env) =>
env.out.print("Hello, world.")

View File

@@ -0,0 +1,188 @@
use "files"
use "options"
use "collections"
actor Worker
new mandelbrot(main: Main, x: U64, y: U64, width: U64, iterations: U64,
limit: F32, real: Array[F32] val, imaginary: Array[F32] val)
=>
var view: Array[U8] iso =
recover
Array[U8]((y - x) * (width >> 3))
end
let group_r = Array[F32].undefined(8)
let group_i = Array[F32].undefined(8)
var row = x
try
while row < y do
let prefetch_i = imaginary(row)
var col: U64 = 0
while col < width do
var j: U64 = 0
while j < 8 do
group_r.update(j, real(col + j))
group_i.update(j, prefetch_i)
j = j + 1
end
var bitmap: U8 = 0xFF
var n = iterations
repeat
var mask: U8 = 0x80
var k: U64 = 0
while k < 8 do
let r = group_r(k)
let i = group_i(k)
group_r.update(k, ((r * r) - (i * i)) + real(col + k))
group_i.update(k, (2.0 * r * i) + prefetch_i)
if ((r * r) + (i * i)) > limit then
bitmap = bitmap and not mask
end
mask = mask >> 1
k = k + 1
end
until (bitmap == 0) or ((n = n - 1) == 1) end
view.push(bitmap)
col = col + 8
end
row = row + 1
end
main.draw(x * (width >> 3), consume view)
end
actor Main
var iterations: U64 = 50
var limit: F32 = 4.0
var chunks: U64 = 16
var width: U64 = 16000
var actors: U64 = 0
var header: U64 = 0
var real: Array[F32] val = recover Array[F32] end
var imaginary: Array[F32] val = recover Array[F32] end
var outfile: (File | None) = None
new create(env: Env) =>
try
arguments(env)
let length = width
let recip_width = 2.0 / width.f32()
var r = recover Array[F32](length) end
var i = recover Array[F32](length) end
for j in Range(0, width) do
r.push((recip_width * j.f32()) - 1.5)
i.push((recip_width * j.f32()) - 1.0)
end
real = consume r
imaginary = consume i
spawn_actors()
create_outfile()
end
be draw(offset: U64, pixels: Array[U8] val) =>
match outfile
| var out: File =>
out.seek_start(header + offset)
out.write(pixels)
if (actors = actors - 1) == 1 then
out.dispose()
end
end
fun ref create_outfile() =>
match outfile
| var f: File =>
f.print("P4\n " + width.string() + " " + width.string() + "\n")
header = f.size()
f.set_length((width * (width >> 3)) + header)
end
fun ref spawn_actors() =>
actors = ((width + (chunks - 1)) / chunks)
var rest = width % chunks
if rest == 0 then rest = chunks end
var x: U64 = 0
var y: U64 = 0
for i in Range(0, actors - 1) do
x = i * chunks
y = x + chunks
Worker.mandelbrot(this, x, y, width, iterations, limit, real, imaginary)
end
Worker.mandelbrot(this, y, y + rest, width, iterations, limit, real,
imaginary)
fun ref arguments(env: Env) ? =>
let options = Options(env)
options
.add("iterations", "i", I64Argument)
.add("limit", "l", F64Argument)
.add("chunks", "c", I64Argument)
.add("width", "w", I64Argument)
.add("output", "o", StringArgument)
for option in options do
match option
| ("iterations", var arg: I64) => iterations = arg.u64()
| ("limit", var arg: F64) => limit = arg.f32()
| ("chunks", var arg: I64) => chunks = arg.u64()
| ("width", var arg: I64) => width = arg.u64()
| ("output", var arg: String) =>
outfile = try File(FilePath(env.root, arg)) end
| let err: ParseError => err.report(env.out) ; usage(env) ; error
end
end
fun tag usage(env: Env) =>
env.out.print(
"""
mandelbrot [OPTIONS]
The binary output can be converted to a BMP with the following command
(ImageMagick Tools required):
convert <output> JPEG:<output>.jpg
Available options:
--iterations, -i Maximum amount of iterations to be done for each pixel.
Defaults to 50.
--limit, -l Square of the limit that pixels need to exceed in order
to escape from the Mandelbrot set.
Defaults to 4.0.
--chunks, -c Maximum line count of chunks the image should be
divided into for divide & conquer processing.
Defaults to 16.
--width, -w Lateral length of the resulting mandelbrot image.
Defaults to 16000.
--output, -o File to write the output to.
"""
)

130
samples/Pony/mixed.pony Normal file
View File

@@ -0,0 +1,130 @@
use "collections"
actor Worker
var _env: Env
new create(env: Env) =>
_env = env
var a: U64 = 86028157
var b: U64 = 329545133
var result = factorize(a*b)
var correct =
try
(result.size() == 2) and
(result(0) == 86028157) and
(result(1) == 329545133)
else
false
end
fun ref factorize(bigint: U64) : Array[U64] =>
var factors = Array[U64](2)
if bigint <= 3 then
factors.push(bigint)
else
var d: U64 = 2
var i: U64 = 0
var n = bigint
while d < n do
if (n % d) == 0 then
i = i + 1
factors.push(d)
n = n / d
else
d = if d == 2 then 3 else (d + 2) end
end
end
factors.push(d)
end
factors
actor Ring
var _env: Env
var _size: U32
var _pass: U32
var _repetitions: U32
var _next: Ring
new create(env: Env, size: U32, pass: U32, repetitions: U32) =>
_env = env
_size = size
_pass = pass
_repetitions = repetitions
_next = spawn_ring(_env, _size, _pass)
run()
new neighbor(env: Env, next: Ring) =>
_env = env
_next = next
_size = 0
_pass = 0
_repetitions = 0
be apply(i: U32) =>
if i > 0 then
_next(i - 1)
else
run()
end
fun ref run() =>
if _repetitions > 0 then
_repetitions = _repetitions - 1
_next(_pass * _size)
Worker(_env)
end
fun tag spawn_ring(env: Env, size: U32, pass': U32) : Ring =>
var next: Ring = this
for i in Range[U32](0, size) do
next = Ring.neighbor(env, next)
end
next
actor Main
var _size: U32 = 50
var _count: U32 = 20
var _pass: U32 = 10000
var _repetitions: U32 = 5
var _env: Env
new create(env: Env) =>
_env = env
try
arguments()
start_benchmark()
else
usage()
end
fun ref arguments() ? =>
_count = _env.args(1).u32()
_size = _env.args(2).u32()
_pass = _env.args(3).u32()
_repetitions = _env.args(4).u32()
fun ref start_benchmark() =>
for i in Range[U32](0, _count) do
Ring(_env, _size, _pass, _repetitions)
end
fun ref usage() =>
_env.out.print(
"""
mixed OPTIONS
N number of actors in each ring"
N number of rings"
N number of messages to pass around each ring"
N number of times to repeat"
"""
)

280
samples/Prolog/queues.yap Normal file
View File

@@ -0,0 +1,280 @@
% This file has been included as an YAP library by Vitor Santos Costa, 1999
% File : QUEUES.PL
% Author : R.A.O'Keefe
% Updated: Friday November 18th, 1983, 8:09:31 pm
% Purpose: define queue operations
% Needs : lib(lists) for append/3.
/** @defgroup Queues Queues
@ingroup library
@{
The following queue manipulation routines are available once
included with the `use_module(library(queues))` command. Queues are
implemented with difference lists.
*/
/**
@pred make_queue(+ _Queue_)
Creates a new empty queue. It should only be used to create a new queue.
*/
/** @pred empty_queue(+ _Queue_)
Tests whether the queue is empty.
*/
/** @pred head_queue(+ _Queue_, ? _Head_)
Unifies Head with the first element of the queue.
*/
/** @pred join_queue(+ _Element_, + _OldQueue_, - _NewQueue_)
Adds the new element at the end of the queue.
*/
/** @pred jump_queue(+ _Element_, + _OldQueue_, - _NewQueue_)
Adds the new element at the front of the list.
*/
/** @pred length_queue(+ _Queue_, - _Length_)
Counts the number of elements currently in the queue.
*/
/** @pred list_join_queue(+ _List_, + _OldQueue_, - _NewQueue_)
Ads the new elements at the end of the queue.
*/
/** @pred list_jump_queue(+ _List_, + _OldQueue_, + _NewQueue_)
Adds all the elements of _List_ at the front of the queue.
*/
/** @pred list_to_queue(+ _List_, - _Queue_)
Creates a new queue with the same elements as _List._
*/
/** @pred queue_to_list(+ _Queue_, - _List_)
Creates a new list with the same elements as _Queue_.
*/
/** @pred serve_queue(+ _OldQueue_, + _Head_, - _NewQueue_)
Removes the first element of the queue for service.
*/
:- module(queues, [
make_queue/1, % create empty queue
join_queue/3, % add element to end of queue
list_join_queue/3, % add many elements to end of queue
jump_queue/3, % add element to front of queue
list_jump_queue/3, % add many elements to front of queue
head_queue/2, % look at first element of queue
serve_queue/3, % remove first element of queue
length_queue/2, % count elements of queue
empty_queue/1, % test whether queue is empty
list_to_queue/2, % convert list to queue
queue_to_list/2 % convert queue to list
]).
:- use_module(library(lists), [append/3]).
/*
:- mode
make_queue(-),
join_queue(+, +, -),
list_join_queue(+, +, -),
jump_queue(+, +, -),
list_jump_queue(+, +, -),
head_queue(+, ?),
serve_queue(+, ?, -),
length_queue(+, ?),
length_queue(+, +, +, -),
empty_queue(+),
list_to_queue(+, -),
queue_to_list(+, -),
queue_to_list(+, +, -).
*/
/* In this package, a queue is represented as a term Front-Back, where
Front is a list and Back is a tail of that list, and is normally a
variable. join_queue will only work when the Back is a variable,
the other routines will accept any tail. The elements of the queue
are the list difference, that is, all the elements starting at Front
and stopping at Back. Examples:
[a,b,c,d,e|Z]-Z has elements a,b,c,d,e
[a,b,c,d,e]-[d,e] has elements a,b,c
Z-Z has no elements
[1,2,3]-[1,2,3] has no elements
*/
% make_queue(Queue)
% creates a new empty queue. It will also match empty queues, but
% because Prolog doesn't do the occurs check, it will also match
% other queues, creating circular lists. So this should ONLY be
% used to make new queues.
make_queue(X-X).
% join_queue(Element, OldQueue, NewQueue)
% adds the new element at the end of the queue. The old queue is
% side-effected, so you *can't* do
% join_queue(1, OldQ, NewQ1),
% join_queue(2, OldQ, NewQ2).
% There isn't any easy way of doing that, sensible though it might
% be. You *can* do
% join_queue(1, OldQ, MidQ),
% join_queue(2, MidQ, NewQ).
% See list_join_queue.
join_queue(Element, Front-[Element|Back], Front-Back).
% list_join_queue(List, OldQueue, NewQueue)
% adds the new elements at the end of the queue. The elements are
% added in the same order that they appear in the list, e.g.
% list_join_queue([y,z], [a,b,c|M]-M, [a,b,c,y,z|N]-N).
list_join_queue(List, Front-OldBack, Front-NewBack) :-
append(List, OldBack, NewBack).
% jump_queue(Element, OldQueue, NewQueue)
% adds the new element at the front of the list. Unlike join_queue,
% jump_queue(1, OldQ, NewQ1),
% jump_queue(2, OldQ, NewQ2)
% *does* work, though if you add things at the end of NewQ1 they
% will also show up in NewQ2. Note that
% jump_queue(1, OldQ, MidQ),
% jump_queue(2, MidQ, NewQ)
% makes NewQ start 2, 1, ...
jump_queue(Element, Front-Back, [Element|Front]-Back).
% list_jump_queue(List, OldQueue, NewQueue)
% adds all the elements of List at the front of the queue. There are
% two ways we might do this. We could add all the elements one at a
% time, so that they would appear at the beginning of the queue in the
% opposite order to the order they had in the list, or we could add
% them in one lump, so that they have the same order in the queue as
% in the list. As you can easily add the elements one at a time if
% that is what you want, I have chosen the latter.
list_jump_queue(List, OldFront-Back, NewFront-Back) :-
append(List, OldFront, NewFront).
% reverse(List, OldFront, NewFront). % for the other definition
% head_queue(Queue, Head)
% unifies Head with the first element of the queue. The tricky part
% is that we might be at the end of a queue: Back-Back, with Back a
% variable, and in that case this predicate should not succeed, as we
% don't know what that element is or whether it exists yet.
head_queue(Front-Back, Head) :-
Front \== Back, % the queue is not empty
Front = [Head|_].
% serve_queue(OldQueue, Head, NewQueue)
% removes the first element of the queue for service.
serve_queue(OldFront-Back, Head, NewFront-Back) :-
OldFront \== Back,
OldFront = [Head|NewFront].
% empty_queue(Queue)
% tests whether the queue is empty. If the back of a queue were
% guaranteed to be a variable, we could have
% empty_queue(Front-Back) :- var(Front).
% but I don't see why you shouldn't be able to treat difference
% lists as queues if you want to.
empty_queue(Front-Back) :-
Front == Back.
% length_queue(Queue, Length)
% counts the number of elements currently in the queue. Note that
% we have to be careful in checking for the end of the list, we
% can't test for [] the way length(List) does.
length_queue(Front-Back, Length) :-
length_queue(Front, Back, 0, N),
Length = N.
length_queue(Front, Back, N, N) :-
Front == Back, !.
length_queue([_|Front], Back, K, N) :-
L is K+1,
length_queue(Front, Back, L, N).
% list_to_queue(List, Queue)
% creates a new queue with the same elements as List.
list_to_queue(List, Front-Back) :-
append(List, Back, Front).
% queue_to_list(Queue, List)
% creates a new list with the same elements as Queue.
queue_to_list(Front-Back, List) :-
queue_to_list(Front, Back, List).
queue_to_list(Front, Back, Ans) :-
Front == Back, !, Ans = [].
queue_to_list([Head|Front], Back, [Head|Tail]) :-
queue_to_list(Front, Back, Tail).

View File

@@ -0,0 +1,124 @@
# Copyright 2015 The Bazel Authors. 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.
"""Build definitions for JavaScript binaries compiled with the Closure Compiler.
A single file is produced with the _compiled.js suffix.
By default, the name of the entry point is assumed to be the same as that of the
build target. This behaviour may be overridden with the "main" attribute.
The optimization level may be set with the "compilation_level" attribute.
Supported values are: unobfuscated, simple, and advanced.
Example:
closure_js_binary(
name = "hello",
compilation_level = "simple",
language_in = "ecmascript6",
language_out = "ecmascript3",
externs = ["//third_party/javascript/google_cast/cast.js"],
deps = [
"@closure_library//:closure_library",
":hello_lib",
],
)
This rule will produce hello_combined.js.
"""
_COMPILATION_LEVELS = {
"whitespace_only": [
"--compilation_level=WHITESPACE_ONLY",
"--formatting=PRETTY_PRINT"
],
"simple": ["--compilation_level=SIMPLE"],
"advanced": ["--compilation_level=ADVANCED"]
}
_SUPPORTED_LANGUAGES = {
"es3": ["ES3"],
"ecmascript3": ["ECMASCRIPT3"],
"es5": ["ES5"],
"ecmascript5": ["ECMASCRIPT5"],
"es5_strict": ["ES5_STRICT"],
"ecmascript5_strict": ["ECMASCRIPT5_STRICT"],
"es6": ["ES6"],
"ecmascript6": ["ECMASCRIPT6"],
"es6_strict": ["ES6_STRICT"],
"ecmascript6_strict": ["ECMASCRIPT6_STRICT"],
"es6_typed": ["ES6_TYPED"],
"ecmascript6_typed": ["ECMASCRIPT6_TYPED"],
}
def _impl(ctx):
externs = set(order="compile")
srcs = set(order="compile")
for dep in ctx.attr.deps:
externs += dep.transitive_js_externs
srcs += dep.transitive_js_srcs
args = [
"--entry_point=goog:%s" % ctx.attr.main,
"--js_output_file=%s" % ctx.outputs.out.path,
"--dependency_mode=LOOSE",
"--warning_level=VERBOSE",
] + (["--js=%s" % src.path for src in srcs] +
["--externs=%s" % extern.path for extern in externs])
# Set the compilation level.
if ctx.attr.compilation_level in _COMPILATION_LEVELS:
args += _COMPILATION_LEVELS[ctx.attr.compilation_level]
else:
fail("Invalid compilation_level '%s', expected one of %s" %
(ctx.attr.compilation_level, _COMPILATION_LEVELS.keys()))
# Set the language in.
if ctx.attr.language_in in _SUPPORTED_LANGUAGES:
args += "--language_in=" + _SUPPORTED_LANGUAGES[ctx.attr.language_in]
else:
fail("Invalid language_in '%s', expected one of %s" %
(ctx.attr.language_in, _SUPPORTED_LANGUAGES.keys()))
# Set the language out.
if ctx.attr.language_out in _SUPPORTED_LANGUAGES:
args += "--language_out=" + _SUPPORTED_LANGUAGES[ctx.attr.language_out]
else:
fail("Invalid language_out '%s', expected one of %s" %
(ctx.attr.language_out, _SUPPORTED_LANGUAGES.keys()))
ctx.action(
inputs=list(srcs) + list(externs),
outputs=[ctx.outputs.out],
arguments=args,
executable=ctx.executable._closure_compiler)
return struct(files=set([ctx.outputs.out]))
closure_js_binary = rule(
implementation=_impl,
attrs={
"deps": attr.label_list(
allow_files=False,
providers=["transitive_js_externs", "transitive_js_srcs"]),
"main": attr.string(default="%{name}"),
"compilation_level": attr.string(default="advanced"),
"language_in": attr.string(default="ecmascript6"),
"language_out": attr.string(default="ecmascript3"),
"_closure_compiler": attr.label(
default=Label("//external:closure_compiler_"),
executable=True),
},
outputs={"out": "%{name}_combined.js"})

1427
samples/Ren'Py/example.rpy Normal file

File diff suppressed because it is too large Load Diff

267
samples/Ruby/racc.rb Normal file
View File

@@ -0,0 +1,267 @@
#
# DO NOT MODIFY!!!!
# This file is automatically generated by Racc 1.4.7
# from Racc grammer file "".
#
require 'racc/parser.rb'
module RJSON
class Parser < Racc::Parser
require 'rjson/handler'
attr_reader :handler
def initialize tokenizer, handler = Handler.new
@tokenizer = tokenizer
@handler = handler
super()
end
def next_token
@tokenizer.next_token
end
def parse
do_parse
handler
end
##### State transition tables begin ###
racc_action_table = [
9, 33, 9, 11, 13, 16, 19, 22, 9, 7,
23, 1, 9, 11, 13, 16, 19, 29, 30, 7,
21, 1, 9, 11, 13, 16, 19, 31, nil, 7,
21, 1, 23, 7, nil, 1 ]
racc_action_check = [
6, 27, 33, 33, 33, 33, 33, 3, 31, 33,
6, 33, 29, 29, 29, 29, 29, 12, 22, 29,
12, 29, 2, 2, 2, 2, 2, 25, nil, 2,
2, 2, 25, 0, nil, 0 ]
racc_action_pointer = [
24, nil, 20, 7, nil, nil, -2, nil, nil, nil,
nil, nil, 10, nil, nil, nil, nil, nil, nil, nil,
nil, nil, 18, nil, nil, 20, nil, -7, nil, 10,
nil, 6, nil, 0, nil, nil, nil ]
racc_action_default = [
-27, -12, -21, -27, -1, -2, -27, -10, -15, -26,
-8, -22, -27, -23, -17, -16, -24, -20, -18, -25,
-19, -11, -27, -13, -3, -27, -6, -27, -9, -21,
37, -27, -4, -21, -14, -5, -7 ]
racc_goto_table = [
8, 26, 24, 27, 10, 3, 25, 5, 4, 12,
nil, nil, nil, nil, 28, nil, nil, nil, nil, nil,
nil, 32, nil, nil, nil, nil, 35, 34, 27, nil,
nil, 36 ]
racc_goto_check = [
9, 7, 5, 8, 11, 1, 6, 3, 2, 12,
nil, nil, nil, nil, 11, nil, nil, nil, nil, nil,
nil, 5, nil, nil, nil, nil, 7, 9, 8, nil,
nil, 9 ]
racc_goto_pointer = [
nil, 5, 8, 7, nil, -4, 0, -5, -3, -2,
nil, 2, 7, nil, nil ]
racc_goto_default = [
nil, nil, 14, 18, 6, nil, nil, nil, 20, nil,
2, nil, nil, 15, 17 ]
racc_reduce_table = [
0, 0, :racc_error,
1, 14, :_reduce_none,
1, 14, :_reduce_none,
2, 15, :_reduce_none,
3, 15, :_reduce_none,
3, 19, :_reduce_none,
1, 19, :_reduce_none,
3, 20, :_reduce_none,
2, 16, :_reduce_none,
3, 16, :_reduce_none,
1, 23, :_reduce_10,
1, 24, :_reduce_11,
1, 17, :_reduce_12,
1, 18, :_reduce_13,
3, 25, :_reduce_none,
1, 25, :_reduce_none,
1, 22, :_reduce_none,
1, 22, :_reduce_none,
1, 22, :_reduce_none,
1, 26, :_reduce_none,
1, 26, :_reduce_20,
0, 27, :_reduce_none,
1, 27, :_reduce_22,
1, 27, :_reduce_23,
1, 27, :_reduce_24,
1, 27, :_reduce_25,
1, 21, :_reduce_26 ]
racc_reduce_n = 27
racc_shift_n = 37
racc_token_table = {
false => 0,
:error => 1,
:STRING => 2,
:NUMBER => 3,
:TRUE => 4,
:FALSE => 5,
:NULL => 6,
"," => 7,
":" => 8,
"[" => 9,
"]" => 10,
"{" => 11,
"}" => 12 }
racc_nt_base = 13
racc_use_result_var = true
Racc_arg = [
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table = [
"$end",
"error",
"STRING",
"NUMBER",
"TRUE",
"FALSE",
"NULL",
"\",\"",
"\":\"",
"\"[\"",
"\"]\"",
"\"{\"",
"\"}\"",
"$start",
"document",
"object",
"array",
"start_object",
"end_object",
"pairs",
"pair",
"string",
"value",
"start_array",
"end_array",
"values",
"scalar",
"literal" ]
Racc_debug_parser = false
##### State transition tables end #####
# reduce 0 omitted
# reduce 1 omitted
# reduce 2 omitted
# reduce 3 omitted
# reduce 4 omitted
# reduce 5 omitted
# reduce 6 omitted
# reduce 7 omitted
# reduce 8 omitted
# reduce 9 omitted
def _reduce_10(val, _values, result)
@handler.start_array
result
end
def _reduce_11(val, _values, result)
@handler.end_array
result
end
def _reduce_12(val, _values, result)
@handler.start_object
result
end
def _reduce_13(val, _values, result)
@handler.end_object
result
end
# reduce 14 omitted
# reduce 15 omitted
# reduce 16 omitted
# reduce 17 omitted
# reduce 18 omitted
# reduce 19 omitted
def _reduce_20(val, _values, result)
@handler.scalar val[0]
result
end
# reduce 21 omitted
def _reduce_22(val, _values, result)
n = val[0]; result = n.count('.') > 0 ? n.to_f : n.to_i
result
end
def _reduce_23(val, _values, result)
result = true
result
end
def _reduce_24(val, _values, result)
result = false
result
end
def _reduce_25(val, _values, result)
result = nil
result
end
def _reduce_26(val, _values, result)
@handler.scalar val[0].gsub(/^"|"$/, '')
result
end
def _reduce_none(val, _values, result)
val[0]
end
end # class Parser
end # module RJSON

View File

@@ -0,0 +1,14 @@
data {
int<lower=0> N;
vector[N] incumbency_88;
vector[N] vote_86;
vector[N] vote_88;
}
parameters {
vector[3] beta;
real<lower=0> sigma;
}
model {
vote_88 ~ normal(beta[1] + beta[2] * vote_86
+ beta[3] * incumbency_88,sigma);
}

31
samples/Stan/dogs.stan Normal file
View File

@@ -0,0 +1,31 @@
data {
int<lower=0> n_dogs;
int<lower=0> n_trials;
int<lower=0,upper=1> y[n_dogs,n_trials];
}
parameters {
vector[3] beta;
}
transformed parameters {
matrix[n_dogs,n_trials] n_avoid;
matrix[n_dogs,n_trials] n_shock;
matrix[n_dogs,n_trials] p;
for (j in 1:n_dogs) {
n_avoid[j,1] <- 0;
n_shock[j,1] <- 0;
for (t in 2:n_trials) {
n_avoid[j,t] <- n_avoid[j,t-1] + 1 - y[j,t-1];
n_shock[j,t] <- n_shock[j,t-1] + y[j,t-1];
}
for (t in 1:n_trials)
p[j,t] <- beta[1] + beta[2] * n_avoid[j,t] + beta[3] * n_shock[j,t];
}
}
model {
beta ~ normal(0, 100);
for (i in 1:n_dogs) {
for (j in 1:n_trials)
y[i,j] ~ bernoulli_logit(p[i,j]);
}
}

26
samples/Stan/schools.stan Normal file
View File

@@ -0,0 +1,26 @@
data {
int<lower=0> N;
vector[N] y;
vector[N] sigma_y;
}
parameters {
vector[N] eta;
real mu_theta;
real<lower=0,upper=100> sigma_eta;
real xi;
}
transformed parameters {
real<lower=0> sigma_theta;
vector[N] theta;
theta <- mu_theta + xi * eta;
sigma_theta <- fabs(xi) / sigma_eta;
}
model {
mu_theta ~ normal(0, 100);
sigma_eta ~ inv_gamma(1, 1); //prior distribution can be changed to uniform
eta ~ normal(0, sigma_eta);
xi ~ normal(0, 5);
y ~ normal(theta,sigma_y);
}

View File

@@ -0,0 +1,27 @@
//@jsx: preserve
//@module: amd
//@filename: react.d.ts
declare module JSX {
interface Element { }
interface IntrinsicElements {
}
interface ElementAttributesProperty {
props;
}
}
interface Props {
foo: string;
}
//@filename: file.tsx
export class MyComponent {
render() {
}
props: { foo: string; }
}
<MyComponent foo="bar" />; // ok
<MyComponent foo={0} />; // should be an error

154
samples/Uno/PlayerPads.uno Normal file
View File

@@ -0,0 +1,154 @@
using Uno;
using Uno.Collections;
using Uno.Graphics;
using Uno.Scenes;
using Uno.Designer;
using Uno.Content;
using Uno.Content.Models;
using Uno.UI;
namespace PONG2D
{
public class PlayerPads : Node
{
Image _player1Image;
Image _player2Image;
[Inline]
public Image Player1
{
get { return _player1Image; }
set
{
if (_player1Image != value)
{
_player1Image = value;
}
}
}
[Inline]
public Image Player2
{
get { return _player2Image; }
set
{
if (_player2Image != value)
{
_player2Image = value;
}
}
}
[Hide]
public float2 Player1Pos
{
get { return (Player1.ActualPosition); }
set
{
if (Player1 != null)
Player1.Position = value;
}
}
[Hide]
public float2 Player2Pos
{
get { return (Player2.ActualPosition); }
set
{
if (Player2 != null)
Player2.Position = value;
}
}
public Rect Player1Rect
{
get { return new Rect(Player1Pos, float2(Player1.Width, Player2.Height)); }
set
{
Player1Pos = value.Position;
if (Player1 != null)
{
Player1.Width = value.Size.X;
Player1.Height = value.Size.Y;
}
}
}
public Rect Player2Rect
{
get { return new Rect(Player2Pos, float2(Player2.Width, Player2.Height)); }
set
{
Player2Pos = value.Position;
if (Player2 != null)
{
Player2.Width = value.Size.X;
Player2.Height = value.Size.Y;
}
}
}
public Ball Ball
{
get;
set;
}
public float PadVelocity { get; set; }
public PlayerPads()
{
}
void UpdatePositions()
{
}
protected override void OnUpdate()
{
base.OnUpdate();
if (Input.IsKeyDown(Uno.Platform.Key.W))
{
Player1Pos = float2(0, Player1Pos.Y - PadVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.S))
{
Player1Pos = float2(0, Player1Pos.Y + PadVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.Up))
{
Player2Pos = float2(0, Player2Pos.Y - PadVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.Down))
{
Player2Pos = float2(0, Player2Pos.Y + PadVelocity);
}
if (Ball != null)
{
if (Ball.BallRectangle.Intersects(Player1Rect) ||
Ball.BallRectangle.Intersects(Player2Rect))
{
Ball.BallVelocity = float2(Ball.BallVelocity.X * -1f, Ball.BallVelocity.Y);
}
}
}
}
}

139
samples/Uno/Pong.uno Normal file
View File

@@ -0,0 +1,139 @@
using Uno;
using Uno.Collections;
using Uno.Graphics;
using Uno.Scenes;
using Uno.Content;
using Uno.Content.Models;
namespace PONG2D
{
public class Pong : Node
{
float2 _player1Pos;
float2 _player2Pos;
float2 ballPosition;
float2 ballVelocity;
float2 rectangleSize;
Rect player1Rect;
Rect player2Rect;
Rect ballRect;
float2 resolution = Context.VirtualResolution;
Random random = new Random(1);
float2 Player1Pos
{
get { return _player1Pos; }
set
{
_player1Pos = Math.Clamp(value, float2(0, 0), resolution - rectangleSize);
}
}
float2 Player2Pos
{
get { return _player2Pos; }
set
{
_player2Pos = Math.Clamp(value, float2(0, 0), resolution - rectangleSize);
}
}
public Pong()
{
Uno.Scenes.Input.AddGlobalListener(this);
}
protected override void OnInitialize()
{
base.OnInitialize();
UpdateValues();
}
void UpdateValues()
{
rectangleSize = float2(resolution.X / 80f, resolution.Y / 5f);
_player1Pos = float2(0f);
_player2Pos = float2(Context.VirtualResolution.X - rectangleSize.X, 0f);
player1Rect = new Rect(_player1Pos, rectangleSize);
player2Rect = new Rect(_player2Pos, rectangleSize);
ballPosition = float2(resolution.X * 0.5f - 10f, resolution.Y * 0.5f - 10f);
ballRect = new Rect(ballPosition, float2(20f));
SpwanBall();
}
void SpwanBall()
{
ballRect.Position = float2(resolution.X * 0.5f - 10f, resolution.Y * 0.5f - 10f);
ballVelocity = float2(5f, 10f) * 0.5f;
}
void OnWindowResize(object sender, EventArgs args)
{
//UpdateValues();
}
protected override void OnUpdate()
{
base.OnUpdate();
var padVelocity = resolution.Y * (float)Application.Current.FrameInterval * 4f;
if (Input.IsKeyDown(Uno.Platform.Key.Up))
{
Player1Pos = float2(Player1Pos.X, Player1Pos.Y - padVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.Down))
{
Player1Pos = float2(Player1Pos.X, Player1Pos.Y + padVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.W))
{
Player2Pos = float2(Player2Pos.X, Player2Pos.Y - padVelocity);
}
if (Input.IsKeyDown(Uno.Platform.Key.S))
{
Player2Pos = float2(Player2Pos.X, Player2Pos.Y + padVelocity);
}
player1Rect.Position = Player1Pos;
player2Rect.Position = Player2Pos;
if (ballRect.Position.X > resolution.X || ballRect.Position.X < 0)
{
SpwanBall();
}
if (ballRect.Position.Y > resolution.Y ||
ballRect.Position.Y < 0)
{
ballVelocity.Y *= -1f;
}
if (ballRect.Intersects(player1Rect) ||
ballRect.Intersects(player2Rect))
{
ballVelocity.X *= -1f;
}
ballRect.Position += ballVelocity;
}
protected override void OnDraw()
{
Uno.Drawing.RoundedRectangle.Draw(player1Rect.Position, player1Rect.Size, float4(1f), 0);
Uno.Drawing.RoundedRectangle.Draw(player2Rect.Position, player2Rect.Size, float4(1f), 0);
Uno.Drawing.RoundedRectangle.Draw(ballRect.Position, ballRect.Size, float4(1f), 0f);
}
}
}

136
samples/Uno/TowerBlock.uno Normal file
View File

@@ -0,0 +1,136 @@
using Uno;
using Uno.Collections;
using Uno.Graphics;
using Uno.Scenes;
using Uno.Content;
using Uno.Content.Models;
using Uno.Physics.Box2D;
using TowerBuilder.Box2DMath;
namespace TowerBuilder
{
public class TowerBlock : TestBed
{
Body floorBody, deleteBody, mouseBody;
private List<Body> bodies = new List<Body>();
private List<Body> bodiesToDelete = new List<Body>();
private ContactListener contactListener;
protected override void OnInitializeTestBed()
{
World.Gravity = float2(0, -25.0f);
World.ContactListener = contactListener = new ContactListener(this);
bodies.Clear();
bodiesToDelete.Clear();
CreateFloor();
CreateDeleteBody();
CreateBox2();
}
void CreateFloor()
{
var bodyDef = new BodyDef();
bodyDef.position = float2(0, -40.0f);
floorBody = World.CreateBody(bodyDef);
var shape = new PolygonShape();
shape.SetAsBox(30.0f, 10.0f);
var fixtureDef = new FixtureDef();
fixtureDef.shape = shape;
fixtureDef.density = 1.0f;
floorBody.CreateFixture(fixtureDef);
}
void CreateDeleteBody()
{
var bodyDef = new BodyDef();
bodyDef.position = float2(0, -44.0f);
deleteBody = World.CreateBody(bodyDef);
var shape = new PolygonShape();
shape.SetAsBox(200.0f, 10.0f);
var fixtureDef = new FixtureDef();
fixtureDef.shape = shape;
fixtureDef.density = 1.0f;
deleteBody.CreateFixture(fixtureDef);
}
Random random = new Random((int) (Uno.Diagnostics.Clock.GetSeconds() * 1000000));
void CreateBox2()
{
var bodyDef = new BodyDef();
bodyDef.type = BodyType.Dynamic;
bodyDef.position = float2(random.NextFloat(-25f, 25f), 50.0f);
bodyDef.angularVelocity = random.NextFloat() * 40 - 20;
bodyDef.userData = float3(0, 0, 0);
var body = World.CreateBody(bodyDef);
var shape = new PolygonShape();
shape.SetAsBox(0.75f, 0.75f);
var fixtureDef = new FixtureDef();
fixtureDef.shape = shape;
fixtureDef.density = 5.0f;
//fixtureDef.friction = 0.75f;
body.CreateFixture(fixtureDef);
bodies.Add(body);
}
private int c = 0;
protected override void OnFixedUpdate()
{
base.OnFixedUpdate();
debug_log bodies.Count;
if(c++ % 8 == 0 && bodies.Count < 20) CreateBox2();
foreach(var body in bodiesToDelete)
{
World.DestroyBody(body);
bodies.Remove(body);
}
bodiesToDelete.Clear();
}
public class ContactListener : IContactListener
{
private TowerBlock b;
public ContactListener(TowerBlock b)
{
this.b = b;
}
public void BeginContact(Contact contact)
{
if(contact.GetFixtureA().GetBody() == b.deleteBody)
{
b.bodiesToDelete.Add(contact.GetFixtureB().GetBody());
}
else if(contact.GetFixtureB().GetBody() == b.deleteBody)
{
b.bodiesToDelete.Add(contact.GetFixtureA().GetBody());
}
}
public void EndContact(Contact contact) {}
public void PreSolve(Contact contact, ref Manifold manifold) {}
public void PostSolve(Contact contact, ref ContactImpulse impulse) {}
}
}
}

79
samples/UrWeb/iso8601.ur Normal file
View File

@@ -0,0 +1,79 @@
open Parse.String
val digit = satisfy isdigit
val decimal_of_len n =
ds <- count n digit;
return (List.foldl (fn d acc => 10*acc + ((ord d)-(ord #"0"))) 0 ds)
val date =
y <- decimal_of_len 4;
char' #"-";
m <- decimal_of_len 2;
char' #"-";
d <- decimal_of_len 2;
if m > 0 && m <= 12 then
return {Year=y, Month=(Datetime.intToMonth (m-1)), Day=d}
else
fail
(* We parse fractions of a second, but ignore them since Datetime
doesn't permit representing them. *)
val time =
h <- decimal_of_len 2;
char' #":";
m <- decimal_of_len 2;
s <- maybe (char' #":";
s <- decimal_of_len 2;
maybe' (char' #"."; skipWhile isdigit);
return s);
return {Hour=h, Minute=m, Second=Option.get 0 s}
val timezone_offset =
let val zulu = char' #"Z"; return 0
val digits = decimal_of_len 2
val sign = or (char' #"+"; return 1)
(char' #"-"; return (-1))
in
zulu `or` (s <- sign;
h <- digits;
m <- (maybe' (char' #":"); or digits (return 0));
return (s*(h*60+m)))
end
val datetime_with_tz =
d <- date; char' #"T"; t <- time;
tz <- timezone_offset;
return (d ++ t ++ {TZOffsetMinutes=tz})
val datetime =
d <- datetime_with_tz;
return (d -- #TZOffsetMinutes)
fun process v =
case parse (d <- datetime_with_tz; eof; return d) v of
Some r =>
let
val {Year=year,Month=month,Day=day,
Hour=hour,Minute=minute,Second=second} =
Datetime.addMinutes (r.TZOffsetMinutes) (r -- #TZOffsetMinutes)
fun pad x =
if x < 10 then "0" `strcat` show x else show x
in
<xml>{[pad hour]}:{[pad minute]}:{[pad second]} {[month]} {[day]}, {[year]}</xml>
end
| None => <xml>none</xml>
fun main () : transaction page =
input <- source "2012-01-01T01:10:42Z";
return <xml>
<body>
<label>
Enter an
<a href="https://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>
datetime here:
<ctextbox source={input} />
</label>
<ul><dyn signal={v <- signal input; return (process v)} /></ul>
</body>
</xml>

85
samples/UrWeb/parse.urs Normal file
View File

@@ -0,0 +1,85 @@
functor Make(Stream : sig type t end) : sig
con t :: Type -> Type
val mreturn : a ::: Type -> a -> t a
val mbind : a ::: Type -> b ::: Type ->
(t a) -> (a -> t b) -> (t b)
val monad_parse : monad t
val parse : a ::: Type -> t a -> Stream.t -> option a
(** Combinators *)
val fail : a ::: Type -> t a
val or : a ::: Type -> t a -> t a -> t a
val maybe : a ::: Type -> t a -> t (option a)
val maybe' : a ::: Type -> t a -> t unit
val many : a ::: Type -> t a -> t (list a)
val count : a ::: Type -> int -> t a -> t (list a)
val skipMany : a ::: Type -> t a -> t unit
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
end
structure String : sig
con t :: Type -> Type
val monad_parse : monad t
val parse : a ::: Type -> t a -> string -> option a
(** Combinators *)
val fail : a ::: Type -> t a
val or : a ::: Type -> t a -> t a -> t a
val maybe : a ::: Type -> t a -> t (option a)
val maybe' : a ::: Type -> t a -> t unit
val many : a ::: Type -> t a -> t (list a)
val count : a ::: Type -> int -> t a -> t (list a)
val skipMany : a ::: Type -> t a -> t unit
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
val eof : t unit
(* We provide alternative versions of some of these predicates
* that return t unit as a monadic syntactical convenience. *)
val string : string -> t string
val string' : string -> t unit
val stringCI : string -> t string
val stringCI' : string -> t unit
val char : char -> t char
val char' : char -> t unit
val take : int -> t (string*int)
val drop : int -> t unit
val satisfy : (char -> bool) -> t char
val skip : (char -> bool) -> t unit
val skipWhile : (char -> bool) -> t unit
val takeWhile : (char -> bool) -> t (string*int)
val takeWhile' : (char -> bool) -> t string (* conses *)
(* Well, "till" is the correct form; but "til" is in common enough
* usage that I'll prefer it for terseness. *)
val takeTil : (char -> bool) -> t (string*int)
val takeTil' : (char -> bool) -> t string (* conses *)
val takeRest : t string
(** Convenience functions *)
val skipSpace : t unit
val endOfLine : t unit
val unsigned_int_of_radix : int -> t int
(*
* val signed_int_of_radix : int -> t int
* val double : t float
*)
end
structure Blob : sig
con t :: Type -> Type
val monad_parse : monad t
val parse : a ::: Type -> t a -> blob -> option a
(** Combinators *)
val fail : a ::: Type -> t a
val or : a ::: Type -> t a -> t a -> t a
val maybe : a ::: Type -> t a -> t (option a)
val maybe' : a ::: Type -> t a -> t unit
val many : a ::: Type -> t a -> t (list a)
val count : a ::: Type -> int -> t a -> t (list a)
val skipMany : a ::: Type -> t a -> t unit
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
end

72
samples/X10/ArraySum.x10 Normal file
View File

@@ -0,0 +1,72 @@
/*
* This file is part of the X10 project (http://x10-lang.org).
*
* This file is licensed to You under the Eclipse Public License (EPL);
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* (C) Copyright IBM Corporation 2006-2014.
*/
import x10.io.Console;
/**
* A simple illustration of loop parallelization within a single place.
*/
public class ArraySum {
var sum:Long;
val data:Rail[Long];
public def this(n:Long) {
// Create a Rail with n elements (0..(n-1)), all initialized to 1.
data = new Rail[Long](n, 1);
sum = 0;
}
def sum(a:Rail[Long], start:Long, last:Long) {
var mySum: Long = 0;
for (i in start..(last-1)) {
mySum += a(i);
}
return mySum;
}
def sum(numThreads:Long) {
val mySize = data.size/numThreads;
finish for (p in 0..(numThreads-1)) async {
val mySum = sum(data, p*mySize, (p+1)*mySize);
// Multiple activities will simultaneously update
// this location -- so use an atomic operation.
atomic sum += mySum;
}
}
public static def main(args:Rail[String]) {
var size:Long = 5*1000*1000;
if (args.size >=1)
size = Long.parse(args(0));
Console.OUT.println("Initializing.");
val a = new ArraySum(size);
val P = [1,2,4];
//warmup loop
Console.OUT.println("Warming up.");
for (numThreads in P)
a.sum(numThreads);
for (numThreads in P) {
Console.OUT.println("Starting with " + numThreads + " threads.");
a.sum=0;
var time: long = - System.nanoTime();
a.sum(numThreads);
time += System.nanoTime();
Console.OUT.println("For p=" + numThreads
+ " result: " + a.sum
+ ((size==a.sum)? " ok" : " bad")
+ " (time=" + (time/(1000*1000)) + " ms)");
}
}
}

View File

@@ -0,0 +1,50 @@
/*
* This file is part of the X10 project (http://x10-lang.org).
*
* This file is licensed to You under the Eclipse Public License (EPL);
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* (C) Copyright IBM Corporation 2006-2014.
*/
import x10.xrx.Runtime;
/**
* Demonstrate how to instantiate the X10 runtime as an executor service
* submit jobs to the runtime, wait jobs to complete and cancel all jobs
*
* Compile with: x10c -O -EXECUTOR_MODE=true Cancellation.x10
* Run with: X10_CANCELLABLE=true X10_NPLACES=4 x10 -DX10RT_IMPL=JavaSockets Cancellation
*/
class Cancellation {
static def job(id:Long, iterations:Long) = ()=>{
at (Place.places().next(here)) async {
for (i in 1..iterations) {
finish for (p in Place.places()) {
at (p) async Console.OUT.println(here+" says hello (job " + id + ", iteration " + i + ")");
}
Console.ERR.println();
System.sleep(200);
}
}
};
public static def main(args:Rail[String]):void {
val w1 = Runtime.submit(job(1, 5));
w1.await(); Console.ERR.println("Job 1 completed\n");
val w2 = Runtime.submit(job(2, 1000));
System.threadSleep(1000);
val c1 = Runtime.cancelAll();
try { w2.await(); } catch (e:Exception) { Console.ERR.println("Job 2 aborted with exception " + e +"\n"); }
c1.await(); // waiting for cancellation to be processed
System.threadSleep(1000);
Runtime.submit(job(3, 1000));
Runtime.submit(job(4, 1000));
System.threadSleep(1000);
val c2 = Runtime.cancelAll();
c2.await();
Console.ERR.println("Goodbye\n");
}
}

Some files were not shown because too many files have changed in this diff Show More