Compare commits

...

489 Commits

Author SHA1 Message Date
Arfon Smith
f100dc91c2 Merge pull request #1588 from github/cache-bustin
Bust that cache
2014-10-16 14:21:33 -05:00
Arfon Smith
fd9d63d605 Removing beta label 2014-10-16 14:05:36 -05:00
Arfon Smith
5c21c35875 Merge branch 'master' into cache-bustin 2014-10-16 12:59:41 -05:00
Arfon Smith
370d55fd74 Merge pull request #1595 from github/text-html-ruby
Use TextMate 1 scope for HTML+ERB files
2014-10-15 17:05:08 -05:00
Arfon Smith
8dd2ddcbf7 CI 2014-10-14 20:18:32 -05:00
Arfon Smith
037857623d Merge branch 'master' into cache-bustin
Conflicts:
	lib/linguist/version.rb
2014-10-14 19:45:09 -05:00
Arfon Smith
d7b19d577b Bumping version 2014-10-14 19:44:35 -05:00
Adam Roben
c70048a3e2 Use TextMate 1 scope for HTML+ERB files
The TextMate 2 scope requires support for injection grammars, which some parsers don't support.
2014-10-14 14:19:05 -04:00
Arfon Smith
6d51117a91 Merge pull request #1593 from github/more-tmscopes
Add more TextMate scopes
2014-10-14 10:06:47 -05:00
Arfon Smith
848a1cc1e5 Minor bump 2014-10-14 10:06:38 -05:00
Adam Roben
9092dfdc7f Add a TextMate scope for Literate CoffeeScript 2014-10-14 10:50:39 -04:00
Adam Roben
d7fe0cc5c7 Add TextMate scopes for HTML variants 2014-10-14 10:41:19 -04:00
Adam Roben
15ec37d4bc Add a TextMate scope for Objective-C++ 2014-10-14 10:41:19 -04:00
Adam Roben
43cc701ac3 Add a TextMate scope for JSON 2014-10-14 10:41:19 -04:00
Adam Roben
7cb8357f73 Add a TextMate scope for YAML 2014-10-14 10:41:19 -04:00
Adam Roben
4b46bcf649 Add TextMate scopes for Sass/SCSS files 2014-10-14 10:41:19 -04:00
Arfon Smith
a954a6465e Update README.md 2014-10-14 09:29:45 -05:00
Arfon Smith
afb6041104 Merge pull request #1592 from github/vmg/tmscopes
Vmg/tmscopes
2014-10-14 09:07:02 -05:00
Arfon Smith
4b28fdbc4d Removing beta label 2014-10-14 08:45:49 -05:00
Arfon Smith
b8a5e8505a Merge branch 'vmg/tmscopes' into cache-bustin
Conflicts:
	lib/linguist/version.rb
2014-10-13 20:21:31 -05:00
Arfon Smith
3087d640a3 3.2.2b1 2014-10-13 19:33:03 -05:00
Arfon Smith
e87b89ab5b Removing todo 2014-10-13 18:52:27 -05:00
Arfon Smith
7aabc6a5ad A different approach 2014-10-13 17:01:53 -05:00
Arfon Smith
5cc053694a Remove pry 2014-10-13 16:38:51 -05:00
Arfon Smith
653314448c Bust that cache 2014-10-13 16:37:46 -05:00
Arfon Smith
4f14db10ea Merge pull request #933 from pchaigno/pro
Support of the .pro file extension for Prolog.
2014-10-13 14:57:19 -05:00
Arfon Smith
98e348ba5f Minor docs update fixes #1581 2014-10-13 14:48:50 -05:00
Arfon Smith
a69b20c1a4 Minor docs update #fixes 1581 2014-10-13 14:48:04 -05:00
Vicent Marti
9275e5240f Bump version 2014-10-13 17:50:57 +02:00
Vicent Marti
7dcc3b3edf Add tm_scope to the BlobHelper 2014-10-13 17:19:38 +02:00
Vicent Marti
6e872c11b6 Pass tm_scope overrides 2014-10-13 17:19:38 +02:00
Vicent Marti
e5b6001759 Add support for TextMate scopes 2014-10-13 17:19:38 +02:00
Arfon Smith
769f1b8658 Merge pull request #1587 from github/linguist-3.2.1
Linguist v3.2.1
2014-10-13 09:47:52 -05:00
Arfon Smith
5814b61356 Linguist v3.2.1 2014-10-13 09:47:02 -05:00
Arfon Smith
8a6d7f67ed Merge pull request #1517 from github/1515-local
3.2.0b3 gem / cc @vmg
2014-10-13 09:40:14 -05:00
Arfon Smith
bcb016a938 Removing beta label 2014-10-13 09:30:09 -05:00
Arfon Smith
065c6c02a8 Merge branch '1515-local' of github.com:github/linguist into 1515-local 2014-10-13 09:10:21 -05:00
Arfon Smith
f7386fcd72 Rugged bump 2014-10-13 09:10:08 -05:00
Arfon Smith
df703ef997 Rugged bump 2014-10-13 09:09:33 -05:00
Arfon Smith
9f6c421d91 Merge pull request #1586 from github/revert-1515-vmg/attributes
Revert "Load Git Attributes for Linguist-specific overrides"
2014-10-13 09:03:36 -05:00
Arfon Smith
91370ae955 Revert "Load Git Attributes for Linguist-specific overrides" 2014-10-13 08:58:53 -05:00
Arfon Smith
ffc0be191e Removing beta label 2014-10-13 08:42:46 -05:00
Vicent Marti
6e9f6da2a2 Merge pull request #1515 from github/vmg/attributes
Load Git Attributes for Linguist-specific overrides
2014-10-13 15:13:22 +02:00
Arfon Smith
c8cb7b7cab Git attr 2014-10-10 15:34:03 -05:00
Arfon Smith
7baa130d8d Merge branch 'master' into 1515-local 2014-10-10 15:32:28 -05:00
Arfon Smith
332d97b57f Removing generated override for now. 2014-10-10 15:32:08 -05:00
Ted Nyman
9c0dbdd48e Merge pull request #1575 from Jaxan/clean-samples
Adds samples for the clean programming language
2014-10-10 12:52:30 -07:00
Joshua Moerman
bec0052065 Adds samples for the clean programming language 2014-10-05 12:55:00 +02:00
Arfon Smith
5010f32421 Merge pull request #1570 from lucaswerkmeister/patch-1
Update Ceylon sample file
2014-10-02 17:06:30 -07:00
Lucas Werkmeister
ded4672ccc Update Ceylon sample file
See ceylon/ceylon-spec#585 for the new annotation syntax and ceylon/ceylon-spec#574 for the new string interpolation syntax.
2014-10-02 12:10:11 +02:00
Arfon Smith
03bb48cf28 Version bump 2014-09-30 08:42:08 -05:00
Arfon Smith
e71eefe8fc Merge branch 'master' into 1515-local 2014-09-30 08:38:26 -05:00
Arfon Smith
c203781e1b Merge pull request #1557 from larsbrinkhoff/frt
Only Forth uses .frt
2014-09-30 08:22:34 -05:00
Lars Brinkhoff
7a2be16d77 Add .frt samples for Forth. 2014-09-30 07:03:58 +02:00
Arfon Smith
77126e9e17 Removing fixture file 2014-09-29 16:28:23 -05:00
Arfon Smith
d1d5c61df5 Updating ref for gitattribute testing 2014-09-29 16:27:20 -05:00
Arfon Smith
09323c8bbc Version bump 2014-09-29 15:28:00 -05:00
Arfon Smith
ac9f82544a Merge pull request #1555 from github/vendored-ignored-gitattributes
Vendored ignored gitattributes
2014-09-29 15:24:30 -05:00
Arfon Smith
2e4e602787 Housekeeping 2014-09-29 15:20:11 -05:00
Arfon Smith
9d0ba5801b Reverting b0db064d09 now we have a better way to test these attributes 2014-09-29 15:11:44 -05:00
Arfon Smith
0cd7d85ec4 Using .gitattributes from test branch 2014-09-29 15:10:01 -05:00
Arfon Smith
b0f674e511 Merge pull request #1563 from github/bkeepers/vendored-ignored-gitattributes
A few tweaks to ignored methods
2014-09-29 14:26:27 -05:00
Brandon Keepers
2b411aad90 Extract #read_index for tests 2014-09-29 15:04:48 -04:00
Brandon Keepers
1c6483a499 Simplify boolean attribute handling 2014-09-29 14:13:44 -04:00
Brandon Keepers
6edf4498ce Move overridden_language to just #language 2014-09-29 14:12:36 -04:00
Brandon Keepers
b160a39678 Remove linguist_* prefix from vendored? and generated? 2014-09-29 13:48:40 -04:00
Lars Brinkhoff
86b4de89bd Only Forth uses .frt. 2014-09-27 06:10:19 +02:00
Brandon Keepers
a35d9a8d29 Merge pull request #1561 from pchaigno/graph-ml
Support for Graph Modeling Language
2014-09-26 14:34:39 -07:00
Paul Chaignon
8012876d5e Support for Graph Modeling Language 2014-09-26 10:43:35 -04:00
Arfon Smith
2e3e8c5b89 Removing pry 2014-09-25 13:55:14 -05:00
Arfon Smith
5284608942 Stubbing git attributes (for now) 2014-09-25 13:48:03 -05:00
Arfon Smith
ea2c7d8b27 Testing 2014-09-25 13:11:43 -05:00
Arfon Smith
b0db064d09 Updating .gitattributes for real usage 2014-09-25 12:57:21 -05:00
Arfon Smith
3ff1e38f6c Adding support for overriding configurations in vendor.yml and generated? 2014-09-25 12:50:42 -05:00
Arfon Smith
b533b682d5 Test files for .gitattributes 2014-09-25 12:13:55 -05:00
Paul Chaignon
f59cf24a82 Merge branch 'master' into pro 2014-09-25 10:23:21 -04:00
Arfon Smith
f87436d499 Adding linguist_vendored? and linguist_generated? to include overrides from .gitattributes 2014-09-24 19:57:30 -05:00
Arfon Smith
178d4756ef Changing up .gitattributes keys for testing 2014-09-24 19:25:05 -05:00
Arfon Smith
5152bd7124 Merge pull request #1547 from bwestlin/master
Added files generated by Typesafe Activator to vendor.yml
2014-09-24 17:04:16 -05:00
Arfon Smith
b5015b6cc7 Merge pull request #1554 from github/1267-local
1267 local
2014-09-24 16:50:55 -05:00
Arfon Smith
097900a327 Merge pull request #1553 from github/1372-local
1372 local
2014-09-24 16:45:39 -05:00
Arfon Smith
1d2a6c38c7 Merge branch 'master' into 1267-local
Conflicts:
	lib/linguist/samples.json
2014-09-24 16:43:42 -05:00
Arfon Smith
cc87ceb0d5 Merge branch 'master' into 1372-local
Conflicts:
	lib/linguist/samples.json
2014-09-24 16:38:07 -05:00
Arfon Smith
a38f77683b Merge pull request #1552 from github/benchmarking
Benchmarking
2014-09-24 16:13:53 -05:00
Arfon Smith
d8da05cde2 Merge pull request #1522 from github/cl-heuristics
Heuristics on for .cl
2014-09-24 10:58:40 -05:00
Arfon Smith
554b5bfe7f Merge pull request #1549 from kr/godep
Treat Go dependency tree as generated and vendored code
2014-09-24 10:56:41 -05:00
Keith Rarick
86aa4c3f3d Add Go dependencies to generated.rb and test_blob.rb 2014-09-22 01:12:46 -07:00
Keith Rarick
19b8721225 Add Go dependencies to vendor.yml and test_blob.rb 2014-09-22 00:58:56 -07:00
Arfon Smith
0cb1ebc41e Merge pull request #1546 from vivekgalatage/master
Adding JavaScript syntax support for JavaScriptBuild (.jsb) files
2014-09-21 21:44:03 -05:00
Björn Westlin
c7c4883f49 Added files generated by Typesafe Activator to vendor.yml 2014-09-21 22:08:12 +02:00
Vivek Galatage
d8b4d4639c Sample JSBuild file showing the usage javascript as scripting language. 2014-09-22 00:15:35 +05:30
Vivek Galatage
ebe45e6f37 Adding JavaScript syntax support for JavaScriptBuild (.jsb) files
jsb is a meta build system [1] which can generate actual build files for GNU make, ninja, visual studio etc.

These files are pure javascript files. Just to differentiate them from rest of the javascript files, these are marked as .jsb file.

[1] https://github.com/vivekgalatage/jsb
2014-09-21 10:27:54 +05:30
Arfon Smith
cb016f8439 Merge pull request #1545 from larsbrinkhoff/groff
Add Groff sample.
2014-09-20 13:58:18 -05:00
Lars Brinkhoff
92212d2652 Add Groff sample. 2014-09-19 13:51:19 +02:00
Arfon Smith
950882be78 Merge pull request #1537 from github/drop-samples.json
Ignore samples.json
2014-09-18 14:30:15 -05:00
Arfon Smith
036855072e Merge branch 'master' into drop-samples.json
Conflicts:
	.travis.yml
2014-09-18 14:29:54 -05:00
Arfon Smith
29bbf50900 Merge pull request #1542 from github/travis-updates
Cleaning up travis.yml
2014-09-18 14:26:23 -05:00
Arfon Smith
ca59303dba Preferred syntax 2014-09-18 14:25:36 -05:00
Arfon Smith
e21f35039b Is this still needed? 2014-09-18 14:11:08 -05:00
Arfon Smith
f2b377fae8 Removing unnecessary Travis build step 2014-09-18 14:07:14 -05:00
Arfon Smith
24a36bf4bb Removing docs about generating samples 2014-09-18 14:06:11 -05:00
Arfon Smith
3284450dc4 Make sure samples.json is present before running tests 2014-09-18 13:56:41 -05:00
Arfon Smith
ea9d326819 Merge branch 'master' into drop-samples.json 2014-09-18 13:50:53 -05:00
Arfon Smith
4cc679c1e5 Merge branch 'master' into 1515-local 2014-09-17 09:54:45 -05:00
Arfon Smith
c49ce55714 Bumping Rugged 2014-09-17 09:54:41 -05:00
The rugged tests are fragile
9d4b5416a5 Bump Rugged 2014-09-17 15:48:14 +02:00
Arfon Smith
82285df54b Merge pull request #1536 from pchaigno/apex-lexer
Use Java lexer for Apex
2014-09-16 16:46:50 -05:00
Brandon Keepers
e67c1789b8 Generate samples.json before building gem 2014-09-16 10:26:35 -04:00
Brandon Keepers
015af19eaf Move Samples::DATA constant to Samples.cache method 2014-09-16 10:25:30 -04:00
Brandon Keepers
156985ed52 Remove samples.json from version control 2014-09-16 10:24:05 -04:00
Paul Chaignon
71d1bd75c0 Use Java lexer for Apex 2014-09-15 16:10:36 -04:00
Arfon Smith
8e7c9c4bc4 Merge pull request #1524 from ankitr/patch-1
Changes C# to proposed color in #1332
2014-09-15 14:07:46 -05:00
Arfon Smith
7b7236fe30 Merge pull request #1534 from github/1530-local
1530 local
2014-09-15 14:00:49 -05:00
Arfon Smith
55d997f43a Merge branch 'master' into 1530-local
Conflicts:
	lib/linguist/samples.json
2014-09-15 13:48:22 -05:00
Arfon Smith
1829b38339 Merge pull request #1529 from fingolfin/godot
Add support for the GDScript language
2014-09-15 13:44:23 -05:00
Arfon Smith
e4c28e12cf Merge pull request #1533 from github/travis-samples
Generate samples before build
2014-09-15 13:22:43 -05:00
Arfon Smith
066cf45f4a Merge pull request #1525 from fingolfin/typos
Fix typos
2014-09-15 13:21:26 -05:00
Arfon Smith
ac32b09a6b Generate samples before build 2014-09-15 13:17:38 -05:00
Arfon Smith
92296f4b4b Merge pull request #1520 from pmoura/master
Use the Logtalk lexer for syntax coloring of Prolog files
2014-09-15 09:10:46 -05:00
Max Horn
3b4d2499eb Update samples.json 2014-09-15 15:02:25 +02:00
Max Horn
f38e15790e Update samples.json 2014-09-15 15:01:46 +02:00
Max Horn
b67c2bc2b2 Add support for G-code language
This is a special language controlling 3D printers (by RepRap, Makerbot,
Ultimaker etc.). It is not a general purpose programming language, but
still contains commands for e.g. looping. On the other hand, most of the
time it will be generated by another program, not hand-written. Hence I
classified it as "data".

Specification:
* http://reprap.org/wiki/G-code

Some repositories with examples:
* https://github.com/reprappro/Mendel
* https://github.com/BLLIP/bllip-parser
* https://github.com/MakerGear/M2
2014-09-15 14:59:40 +02:00
Max Horn
393c9b759e Add support for the GDScript language
References:
* https://github.com/okamstudio/godot/wiki/gdscript
* http://www.godotengine.org/

Some projects using it:
* https://github.com/okamstudio/godot
* https://github.com/Qwertie-/Godot-games

My motivation for adding it: To disambiguate these .gd
files from GAP .gd files.
2014-09-15 14:31:58 +02:00
Max Horn
54a7cf6785 Fix typos 2014-09-15 13:24:39 +02:00
Ankit Ranjan
1cf7a6389c Changes C# to proposed color in #1332 2014-09-13 12:00:30 -07:00
Arfon Smith
c204d7c297 Merge pull request #1403 from github/benchmarking
Benchmarking
2014-09-13 13:41:09 -05:00
Arfon Smith
5932f5f273 Allow for result to be generated when there are un-committed changes. 2014-09-13 11:06:15 -05:00
Arfon Smith
98977c87db Heuristics on for .cl 2014-09-12 16:34:51 -05:00
Paulo Moura
ff457af2d4 Use the Logtalk lexer for syntax coloring of Prolog files 2014-09-12 20:49:54 +01:00
Arfon Smith
0e86ab9044 Version beta bump and some notes 2014-09-11 15:05:36 -05:00
Vicent Marti
3d39e842ec Load Git Attributes for Linguist-specific overrides 2014-09-11 13:51:07 +02:00
The rugged tests are fragile
16c1aa2845 Fetch the attributes test branch in Travis 2014-09-11 13:51:07 +02:00
The rugged tests are fragile
d0cf883558 Use rugged 0.21.1b0 2014-09-11 13:51:06 +02:00
Arfon Smith
64e4830aad Merge branch 'benchmarking' of github.com:github/linguist into benchmarking 2014-09-10 17:07:01 -05:00
Arfon Smith
0c47f2af75 Merge branch 'master' into benchmarking
Conflicts:
	lib/linguist/heuristics.rb
	lib/linguist/languages.yml
2014-09-10 17:06:48 -05:00
Arfon Smith
14c5d8c95a Merge pull request #1516 from github/benchmarking-2
Tweaks to benchmarking stuff
2014-09-10 17:00:55 -05:00
Brandon Keepers
6850499056 Remove git dependency 2014-09-10 15:49:59 -05:00
Brandon Keepers
9288f784a1 remove hash extension 2014-09-10 15:49:54 -05:00
Brandon Keepers
dab75f6f97 Rework benchmarking script to avoid git operations
$ git checkout master
    $ bundle exec rake benchmark:generate CORPUS=~/Downloads/samples-9
    wrote benchmark/results/samples-9-8cdb8ed4.json

    $ git checkout branch-name
    $ bx rake benchmark:generate CORPUS=~/Downloads/samples-9

    wrote benchmark/results/samples-9-8d8020dd.json

    $ bx rake benchmark:compare
REFERENCE=benchmark/results/samples-9-8cdb8ed4.json
CANDIDATE=benchmark/results/samples-9-8d8020dd.json
    LanguageA changed from 95.9% to 0.0%
    LanguageB changed from 4.0% to 99.9%
2014-09-10 15:47:44 -05:00
Arfon Smith
4a017d9033 Merge pull request #1509 from github/cut-release-v3.1.5
3.1.5
2014-09-05 13:58:58 -05:00
Arfon Smith
6f896d988f 3.1.5 2014-09-05 13:24:39 -05:00
Arfon Smith
35a9d241fc Samples 2014-09-05 13:23:10 -05:00
Arfon Smith
9ba0a7db64 Merge pull request #1506 from pchaigno/cgi-scripts
Add .cgi as an extension for Python and Bash
2014-09-05 13:21:33 -05:00
Arfon Smith
9968503872 Merge pull request #1508 from github/prolog-script
Scripty Prolog
2014-09-05 13:17:48 -05:00
Arfon Smith
34218c5f58 Scripty Prolog 2014-09-05 13:00:19 -05:00
Arfon Smith
ebd41f1f20 Merge pull request #1507 from github/cut-release-v3.1.4
3.1.4
2014-09-05 11:25:36 -05:00
Arfon Smith
62b1816297 3.1.4 2014-09-05 10:40:37 -05:00
Paul Chaignon
2dfb864e4e Add .cgi as an extension for Python and Bash 2014-09-04 20:32:45 -04:00
Arfon Smith
2d1e1d4747 Merge pull request #1503 from github/prolog-pl-samples
Prolog pl samples
2014-09-04 16:10:39 -05:00
Arfon Smith
f785aa0ae2 Merge branch 'master' into prolog-pl-samples
Conflicts:
	lib/linguist/languages.yml
	lib/linguist/samples.json
2014-09-04 15:51:30 -05:00
Arfon Smith
cc476e212e Another sample file
Conflicts:
	lib/linguist/samples.json
2014-09-04 15:48:38 -05:00
Arfon Smith
bca9716fc6 Another sample file 2014-09-04 13:53:36 -05:00
Arfon Smith
fae6dbfebd Taking Heuristics for a spin. 2014-09-04 13:49:30 -05:00
Arfon Smith
a7a0800b46 Merge pull request #1502 from github/1444-local
1444 local
2014-09-04 12:09:22 -05:00
Arfon Smith
305293d3e5 For the pendants 2014-09-04 11:57:10 -05:00
Arfon Smith
17d4eb7a5e Samples 2014-09-04 11:51:41 -05:00
Arfon Smith
f97e103b6d Merge branch 'master' into 1444-local 2014-09-04 11:51:06 -05:00
Brandon Keepers
dafca264b2 Merge pull request #1376 from t-b/add-igor-pro
Add highlighting for Igor Pro procedures
2014-09-03 11:12:46 -04:00
Brandon Keepers
be970e9e3d Merge pull request #1499 from pchaigno/emacs-lisp-lexer
Change lexer for Emacs Lisp from Scheme to Common Lisp
2014-09-03 10:27:16 -04:00
Paul Chaignon
e76837fa20 Change lexer for Emacs Lisp from Scheme to Common Lisp 2014-09-02 10:33:53 -04:00
Arfon Smith
e1b3403dc8 Merge pull request #1484 from github/cut-release-v3.1.2
Bumping version number
2014-08-28 15:45:52 -05:00
Arfon Smith
79da17c5c8 Bumping version number 2014-08-28 11:17:50 -05:00
Arfon Smith
e9623d542d Samples 2014-08-28 09:48:53 -05:00
Arfon Smith
bc999f4067 Merge pull request #1475 from StoneCypher/AddOpalToRecognizedLanguages
Add Opal to list of recognized languages
2014-08-28 09:48:20 -05:00
Arfon Smith
474e536ae8 Samples 2014-08-28 09:41:19 -05:00
Arfon Smith
79647c5bb4 Merge pull request #1477 from DeathByTape/master
Added PigLatin language identification.
2014-08-28 09:40:47 -05:00
Dennis J. McWherter Jr
5409c39e35 Reverted samples.json. 2014-08-23 15:39:31 -05:00
Dennis J. McWherter Jr
5d4a24dd4f Added PigLatin language identification.
Updated languages.yml to associate *.pig files with PigLatin.
Added pig script example to samples/.
Updated the samples.json with to account for new sample.
2014-08-22 20:51:36 -05:00
John Haugeland
c97abe7ef5 Add Opal to list of recognized languages 2014-08-21 13:35:41 -07:00
Arfon Smith
edaea7bede Samples update 2014-08-21 15:32:16 -05:00
Arfon Smith
909bce8ed9 Merge pull request #1474 from StoneCypher/AddAplToRecognizedLanguages
Add APL to recognized languages
2014-08-21 15:28:48 -05:00
Arfon Smith
4090c492e8 Merge pull request #1308 from pchaigno/new-lexers
Add lexers from Pygments
2014-08-21 14:30:38 -05:00
John Haugeland
a24afb0e12 Add APL to recognized languages 2014-08-20 20:42:50 -07:00
Thomas Braun
bc01f8b25f Add highlighting for Igor Pro procedures
Available in pygments since 5ceb7533e214.

Signed-off-by: Thomas Braun <thomas.braun@byte-physics.de>
2014-08-19 17:16:02 +02:00
Arfon Smith
077c4141d6 Merge pull request #1470 from jrha/pan_language
Use Pygments Pan lexer
2014-08-19 10:13:24 -05:00
James Adams
e5f20314e9 Use Pygments Pan lexer
The upstream pygments patches seem to have landed at GitHub as Pan code blocks
are being correctly highlighted, we should extend this to files in repositories as well.
2014-08-19 13:17:26 +01:00
Arfon Smith
8a61bcb6b5 Merge pull request #1394 from grindhold/master
EmberScript support
2014-08-18 13:55:44 -05:00
Arfon Smith
61b301b380 Merge pull request #1465 from edmundito/master
Added AGS (Adventure Game Studio) Script
2014-08-17 21:04:58 -05:00
Edmundo Ruiz
be86f28be1 Raked samples file with AGS Script. 2014-08-16 12:22:22 -07:00
Edmundo Ruiz
a443380869 Added Adventure Game Studio (AGS) Script language definition and samples. 2014-08-16 11:51:15 -07:00
Arfon Smith
3d1d431cda Merge pull request #1412 from pchaigno/thirdparty
Improve vendor regex for third party folders
2014-08-15 14:25:43 -05:00
Arfon Smith
9559ece8af Merge pull request #1418 from peol/patch-1
Regex matching filename 'composer.lock' fixed
2014-08-15 14:23:07 -05:00
Arfon Smith
8f56a1096d Merge pull request #1461 from joeyspin/patch-2
Add LabVIEW to languages.yml
2014-08-15 14:12:21 -05:00
Zach Holman
0ec85f902a Merge pull request #1405 from seancoyne/coldfusion-lexer-update
distinguish between ColdFusion HTML and ColdFusion CFCs
2014-08-14 17:06:22 -05:00
joeyspin
a47dde2166 Update languages.yml
Put LabVIEW order after LFE and after LLVM to meet test.pedantic
2014-08-14 16:39:04 -05:00
Sean Coyne
abdd6bfbd2 Merge branch 'master' into coldfusion-lexer-update
* master: (29 commits)
  Samples
  Samples
  example for bbx,cbx,lbx file (extracted from http://github.com/plk/biblatex)
  Samples
  Samples update
  Adding samples for new extensions
  Adding test to check that languages.yml includes all extensions represented in samples folder
  Add LookML
  Add Foundation js to vendor.yml, and test_blob.rb
  Remove file extensions with multiple segments
  Lexer for Handlebars
  Add knockout.js library as vendor file
  Support for Cycript language with .cy file extension
  extension for biblatex
  Adding Font Awesome to vendored files.
  3.1.1
  Add minimal support for recognizing OpenSCAD files.
  Added .hqf sample.
  Properly added sample.
  Added SQF support
  ...

Conflicts:
	lib/linguist/samples.json
2014-08-14 17:36:53 -04:00
joeyspin
d64104f472 Update languages.yml 2014-08-14 14:42:58 -05:00
joeyspin
1cd5ae2d57 Add LabVIEW to languages.yml
Adding XML LabVIEW project per discussion at #1386 and #1387
2014-08-14 14:21:18 -05:00
Arfon Smith
e27bf1627d Merge pull request #1445 from cflee/add-foundation-js
Add Foundation js to vendor.yml, and test_blob.rb
2014-08-14 13:16:41 -05:00
Arfon Smith
0689d64efd Merge pull request #1460 from github/1413-local
1413 local
2014-08-14 13:11:39 -05:00
Arfon Smith
3ba47aec38 Merge branch 'master' into 1413-local
Conflicts:
	lib/linguist/vendor.yml
2014-08-14 13:02:45 -05:00
Arfon Smith
b90253981b Merge pull request #1459 from github/1417-local
1417 local
2014-08-14 12:55:43 -05:00
Arfon Smith
513f678b6c Merge branch 'master' into 1417-local
Conflicts:
	lib/linguist/samples.json
2014-08-14 12:57:24 -05:00
Arfon Smith
478b9cf189 Samples 2014-08-14 12:16:35 -05:00
Arfon Smith
6675baff13 Merge pull request #1415 from KoffeinFlummi/master
Added SQF Support
2014-08-14 12:13:50 -05:00
Arfon Smith
a6efeebd21 Merge pull request #1421 from stevex86/master
Adding Font Awesome to vendored files.
2014-08-14 12:10:10 -05:00
Arfon Smith
6e2bb25b6e Samples 2014-08-14 09:31:47 -05:00
Arfon Smith
a54edf71d1 Merge pull request #1426 from maieul/master
extension for biblatex
2014-08-14 09:29:06 -05:00
maieul
8ff7eaf893 example for bbx,cbx,lbx file (extracted from http://github.com/plk/biblatex) 2014-08-14 12:13:41 +02:00
Paul Chaignon
a8d3872002 Add 3rdparty as third party folder 2014-08-14 08:45:17 +02:00
Paul Chaignon
dea03b7a46 Improve vendor regex for third party folders 2014-08-14 08:43:39 +02:00
Arfon Smith
f5723dcccf Samples 2014-08-13 15:48:12 -07:00
Arfon Smith
d772d1f162 Merge pull request #1408 from wilg/master
LookML
2014-08-13 15:43:01 -07:00
Arfon Smith
46cfd16ae7 Merge pull request #1458 from github/1348-local
1348 local
2014-08-13 15:39:55 -07:00
Arfon Smith
315243350b Merge branch 'master' into 1348-local
Conflicts:
	lib/linguist/samples.json
2014-08-13 15:32:51 -07:00
Arfon Smith
886d8a7293 Merge pull request #1457 from github/1364-local
1364 local
2014-08-13 15:29:30 -07:00
Arfon Smith
54318f4001 Merge branch 'master' into 1348-local
Conflicts:
	lib/linguist/samples.json
2014-08-13 15:26:49 -07:00
Arfon Smith
b3aee8abab Samples update 2014-08-13 15:16:48 -07:00
Arfon Smith
1bdbadc1b3 Adding samples for new extensions 2014-08-13 15:06:17 -07:00
Arfon Smith
e0997b311b Merge branch 'master' into 1364-local
Conflicts:
	lib/linguist/languages.yml
2014-08-13 14:59:31 -07:00
Arfon Smith
3c2ca312b9 Merge pull request #1375 from arthurvr/master
Update vendor.yml: added animate.css
2014-08-13 14:53:17 -07:00
Arfon Smith
315df1339a Merge pull request #1451 from github/extensions
Adding test to check that languages.yml includes all extensions represented in samples folder
2014-08-13 14:51:12 -07:00
Thomas Van Doren
e03b3e5ec4 Merge branch 'master' of github.com:github/linguist into chapel-lang
Conflicts:
	lib/linguist/samples.json
2014-08-12 11:10:55 -05:00
Arfon Smith
43923976c2 Adding test to check that languages.yml includes all extensions represented in samples folder 2014-08-11 14:16:25 -07:00
Wil Gieseler
6b8ee2f3f7 Add LookML 2014-08-08 21:08:36 -07:00
Arfon Smith
8cdb8ed48d Heuristics on and a bad commit for C++ 2014-08-06 19:31:52 +01:00
Arfon Smith
417bf7e1c9 Reworking Rake tasks 2014-08-06 19:21:20 +01:00
Chiang Fong Lee
b8e570bb3d Add Foundation js to vendor.yml, and test_blob.rb
Excludes files like:
- foundation.js
- foundation.min.js
- foundation.abide.js
2014-08-06 20:07:08 +08:00
Builder's Brewery
69ff3c79b4 removed find_by_alias('lsl') test 2014-08-06 13:04:31 +02:00
Builder's Brewery
eff4da20f8 removed LSLalias from 'lib/linguist/languages.yml' 2014-08-06 13:03:10 +02:00
Builder's Brewery
473688b109 Added tests for LSL to 'test/test_language.rb' 2014-08-06 12:47:56 +02:00
Builder's Brewery
7bfb6ed5d7 Added LSL sample to 'samples/LSL/LSL.lsl' 2014-08-06 12:42:32 +02:00
Builder's Brewery
276080aeec Added LSL language to 'lib/linguist/languages.yml' 2014-08-06 12:39:17 +02:00
Brandon Keepers
41c880afc7 Merge pull request #1432 from pchaigno/cycript
Support for Cycript language
2014-08-05 13:37:09 -04:00
Brandon Keepers
3d242c3a3a Merge pull request #1433 from pchaigno/knockout.js
Add knockout.js library as vendor file
2014-08-05 13:19:02 -04:00
Brandon Keepers
9325b07d68 Merge pull request #1438 from pchaigno/file-extensions
Remove file extensions with multiple segments
2014-08-05 13:01:00 -04:00
Brandon Keepers
ddeeb5d416 Merge pull request #1437 from pchaigno/handlebars-lexer
Lexer for Handlebars
2014-08-05 12:58:42 -04:00
Paul Chaignon
c8bc0a5c79 Remove file extensions with multiple segments 2014-08-04 11:23:31 +02:00
Paul Chaignon
f58522d5a9 Lexer for Handlebars 2014-08-03 22:53:23 +02:00
Paul Chaignon
27a621531b Add knockout.js library as vendor file 2014-08-01 16:07:52 +02:00
Paul Chaignon
0235433b7e Support for Cycript language with .cy file extension 2014-08-01 15:56:44 +02:00
maieul
6b5d1fe25b extension for biblatex 2014-07-31 16:03:01 +02:00
Arfon Smith
f811ab1b28 Merge pull request #1419 from github/cut-release-v3.1.1
3.1.1
2014-07-29 08:36:04 +01:00
Steve King, Jr
fc73f51855 Adding Font Awesome to vendored files. 2014-07-28 10:37:18 -07:00
Arfon Smith
dd181421a7 3.1.1 2014-07-28 17:32:40 +01:00
Andrée Hansson
f6e2189739 Regex matching filename 'composer.lock' fixed
The previous regex had an unescaped period, which matches any character between 'composer' and 'lock' in the filename.
2014-07-28 13:24:10 +02:00
G. Wade Johnson
d61f31d3ed Add minimal support for recognizing OpenSCAD files.
As 3D printing becomes more popular, more OpenSCAD projects will appear
on github. This change allows linguist to recognize those projects.
Hopefully, this will make finding projects easier.
2014-07-27 21:17:36 -05:00
KoffeinFlummi
4e83a6ad23 Added .hqf sample. 2014-07-28 00:38:07 +02:00
KoffeinFlummi
7fc39dc8d1 Properly added sample. 2014-07-27 21:26:34 +02:00
KoffeinFlummi
f10154a782 Added SQF support 2014-07-27 20:11:00 +02:00
Ryan Batchelder
8761dc4e17 Missed escaping a slash
Added EoL match
Thanks for pchaigno
2014-07-27 10:02:54 -07:00
Ryan Batchelder
5a044b1c07 Ignore Bourbon SCSS mixin library to avoid high CSS percentages 2014-07-26 14:05:13 -07:00
Sean Coyne
0100b76412 distinguish between ColdFusion HTML and ColdFusion CFCs
allows for using both ColdFusion Lexers provided by pigments and allows
for proper syntax highlighting of cfscript based CFCs

Signed-off-by: Sean Coyne <sean@n42designs.com>
2014-07-24 20:48:50 -04:00
Arfon Smith
149f8967ad Fixing up bin/linguist 2014-07-23 11:41:50 -05:00
Arfon Smith
c8754292f4 Merge pull request #1401 from github/fixing-executable
Fixing up bin/linguist
2014-07-23 11:40:22 -05:00
Arfon Smith
e376fe921b Skipping Text and Binary dirs 2014-07-23 11:30:25 -05:00
Arfon Smith
61faea0298 Fixing up bin/linguist 2014-07-23 11:20:31 -05:00
Arfon Smith
8d8020ddb5 Merge branch 'master' into benchmarking
Conflicts:
	lib/linguist/version.rb
2014-07-23 11:01:16 -05:00
Arfon Smith
7d13b9eb99 Formatting 2014-07-23 10:59:10 -05:00
Arfon Smith
6ed0a05b44 Reporting errors in classifications 2014-07-23 10:49:29 -05:00
Arfon Smith
c4c479578a Heuristics off 2014-07-23 10:37:50 -05:00
Arfon Smith
441caa91dd Samples 2014-07-23 10:34:03 -05:00
Arfon Smith
20154eb049 Rework diff slightly 2014-07-23 10:30:54 -05:00
Arfon Smith
84ea710d42 Moving linguist detection into rake task and ignoring diff for now. 2014-07-23 10:30:53 -05:00
Arfon Smith
8d524d618e Toy example 2014-07-23 10:30:53 -05:00
Arfon Smith
9fa34ab1fe Fixing BlobHelper loading issue 2014-07-23 10:30:53 -05:00
Arfon Smith
47db1cf1ac Explictly load FileBlob 2014-07-23 10:30:53 -05:00
Arfon Smith
f2f9b70659 Fixing broken test 2014-07-23 10:30:53 -05:00
Josh Abernathy
61c93ab08c pbproj's are cool too. 2014-07-23 10:30:53 -05:00
Josh Abernathy
d72f3fae33 Actually let's keep those. 2014-07-23 10:30:53 -05:00
Josh Abernathy
3f14d15722 Most Xcode files have a human-readable diff now! 2014-07-23 10:30:53 -05:00
Arfon Smith
963c0b46a0 Modifying Mirah search terms 2014-07-23 10:30:53 -05:00
Arfon Smith
66b4977a67 Linguist v3.0.4 2014-07-23 10:30:53 -05:00
Arfon Smith
126c2147e9 Checking all files for binary? 2014-07-23 10:30:43 -05:00
Paul Chaignon
f7c42a4e6a Rename file for the test on non-existing extension 2014-07-23 10:30:43 -05:00
Paul Chaignon
b1ea1fd96f Remove stylistic yet useless parentheses 2014-07-23 10:30:38 -05:00
Paul Chaignon
a5475bf839 Sample files to test the new FileBlob.extension method 2014-07-23 10:30:01 -05:00
Paul Chaignon
be9e187cc6 Remove .rb test 2014-07-23 10:29:31 -05:00
Paul Chaignon
d5098c6f66 Custom File.extname method which returns the filename if it is an extension 2014-07-23 10:29:22 -05:00
Arfon Smith
41fc785330 Kicking the tyres 2014-07-23 10:26:23 -05:00
Arfon Smith
4d83bf34f3 Ditching IO 2014-07-23 10:26:23 -05:00
Arfon Smith
3a797e2583 Formatting 2014-07-23 10:26:23 -05:00
Arfon Smith
7802030a53 Counting changes 2014-07-23 10:26:22 -05:00
Arfon Smith
e8e1e0ca23 Abort unless files exist 2014-07-23 10:26:22 -05:00
Arfon Smith
973431be40 Breaking comparsion step out into separate task 2014-07-23 10:26:22 -05:00
Arfon Smith
24fb5a8e29 3.0.3 release 2014-07-23 10:26:22 -05:00
Arfon Smith
37d161c290 Removing second binary? check 2014-07-23 10:26:22 -05:00
Arfon Smith
ddefa5f9e6 Ask Charlock earlier 2014-07-23 10:26:22 -05:00
Arfon Smith
955dd3d4d5 Adding test for Normalize.css 2014-07-23 10:26:22 -05:00
Arthur Verschaeve
d125205564 Update vendor.yml: normalize.css
Added popular CSS reset Normalize.css (http://necolas.github.io/normalize.css/)
2014-07-23 10:26:22 -05:00
Arfon Smith
7fa1b52497 Benchmark dir 2014-07-23 10:26:22 -05:00
Arfon Smith
a90d21899a Shellwords 2014-07-23 10:26:22 -05:00
Arfon Smith
569058f481 test on all 2014-07-23 10:26:22 -05:00
Arfon Smith
4ecda08f1f Prettier print 2014-07-23 10:26:21 -05:00
Arfon Smith
3b23059c09 Prettier print 2014-07-23 10:26:21 -05:00
Arfon Smith
a474ffc101 Deep diffing 2014-07-23 10:26:21 -05:00
Arfon Smith
f7672b837a Building language indexes 2014-07-23 10:26:21 -05:00
Arfon Smith
5235871fd8 Pry for development. 2014-07-23 10:26:21 -05:00
Arfon Smith
cac9873e20 Ignoring benchmark files 2014-07-23 10:26:21 -05:00
Arfon Smith
9094923de9 Debug statements 2014-07-23 10:26:21 -05:00
Arfon Smith
6454c96e6a Abort 2014-07-23 10:26:21 -05:00
Arfon Smith
7fbb9edc0f Gem deps 2014-07-23 10:26:21 -05:00
Arfon Smith
0a717f5c81 Gem 2014-07-23 10:26:21 -05:00
Arfon Smith
dab9777621 Branches 2014-07-23 10:26:20 -05:00
Arfon Smith
c8d1e9def1 Testing Pods 2014-07-23 10:26:20 -05:00
Josh Oldenburg
272dd45a43 Ignore everything in the Pods directory. 2014-07-23 10:26:20 -05:00
Josh Oldenburg
5abec96df7 Only ignore Pods/ for CocoaPods. 2014-07-23 10:26:20 -05:00
Josh Oldenburg
e860f961a9 Ignore files related to Cocoapods.
These include Podfile, Podfile.lock, and Pods/.
2014-07-23 10:26:20 -05:00
Arfon Smith
b9ecf61dcb Merge pull request #1399 from github/cut-3.1.0-release
Cut 3.1.0 release
2014-07-22 17:14:29 -05:00
Arfon Smith
437f81c4a0 3.1.0 2014-07-22 13:59:58 -05:00
Arfon Smith
26dad7dada 3.1.0beta 2014-07-22 12:51:24 -05:00
Arfon Smith
b1e5d6f8f8 Merge pull request #1398 from github/fixing-load-paths
Fixing BlobHelper loading issue
2014-07-22 12:46:27 -05:00
Arfon Smith
8c7b54d6e3 Fixing BlobHelper loading issue 2014-07-22 12:26:21 -05:00
grindhold
fea0d8963c added coffeescript lexer for emberscript 2014-07-20 08:59:09 +02:00
grindhold
7aca52c68c added emberscript and provided sample 2014-07-20 08:33:18 +02:00
Arfon Smith
529d3faaf8 Explictly load FileBlob 2014-07-18 20:40:14 -05:00
Arfon Smith
9f0f4657a2 Fixing broken test 2014-07-15 16:13:46 -07:00
Arfon Smith
90ff1b5896 Merge branch 'master' into cut-release-v3.0.4 2014-07-15 12:34:06 -07:00
Arfon Smith
feb82e34d6 Merge pull request #1385 from joshaber/master
XCodes
2014-07-15 12:33:38 -07:00
Josh Abernathy
4d7a34c177 pbproj's are cool too. 2014-07-15 12:27:35 -07:00
Josh Abernathy
5c3385ecd8 Actually let's keep those. 2014-07-15 12:08:23 -07:00
Josh Abernathy
a1af3a509c Most Xcode files have a human-readable diff now! 2014-07-15 12:06:55 -07:00
Arfon Smith
2913a87cc4 Linguist v3.0.4 2014-07-15 11:54:59 -07:00
Arfon Smith
69cc86c572 Merge pull request #1383 from github/mirah-search
Modifying Mirah search terms
2014-07-15 11:29:13 -07:00
Arfon Smith
60144c907e Modifying Mirah search terms 2014-07-15 11:01:41 -07:00
Arthur Verschaeve
1828cf6fc7 Update vendor.yml: added animate.css 2014-07-11 20:07:42 +02:00
Thomas Van Doren
ad4d273241 Merge remote-tracking branch 'github/master' into chapel-lang
Conflicts:
	lib/linguist/samples.json
2014-07-10 14:57:26 -07:00
Arfon Smith
0d03a94cde Merge pull request #1371 from github/1285-local
1285 local
2014-07-10 14:15:56 -05:00
Paul Chaignon
c4b876472f Rename Groovy sample file with a .gradle extension 2014-07-09 23:23:21 +02:00
Arfon Smith
6af5adaac1 blob.mode 2014-07-09 12:56:50 -05:00
Arfon Smith
17a28f2e91 Merge branch 'master' into 1285-local
Conflicts:
	lib/linguist/language.rb
	lib/linguist/samples.json
2014-07-09 12:46:18 -05:00
Arfon Smith
baaa7a5c13 Merge pull request #1370 from github/moar-binary
Checking all files for binary?
2014-07-09 12:21:34 -05:00
Arfon Smith
cfeb2a833c Checking all files for binary? 2014-07-09 12:11:25 -05:00
William Woodruff
e6fd58b3aa fixed extension order, hopefully correctly this time 2014-07-08 12:53:55 -04:00
William Woodruff
2ef905ef1e fixed extension order, hopefully correctly this time 2014-07-08 12:43:31 -04:00
William Woodruff
db80aa84dc fixed extension order 2014-07-08 12:31:40 -04:00
William Woodruff
f404cc16a1 added two more common file endings for perl programs 2014-07-08 00:41:34 -04:00
Arfon Smith
8b4acf7023 Merge pull request #1361 from github/release-3.0.3
3.0.3 release
2014-07-07 17:01:54 -05:00
Arfon Smith
7393c2ef91 3.0.3 release 2014-07-07 15:47:04 -05:00
Arfon Smith
4948ec2999 Merge pull request #1354 from github/binary-language-mkII
Ask Charlock earlier
2014-07-07 15:43:52 -05:00
Arfon Smith
408a325732 Merge pull request #1360 from github/1358-local
1358 local
2014-07-07 15:39:09 -05:00
Arfon Smith
5ca211b9f7 Adding test for Normalize.css 2014-07-07 15:34:10 -05:00
Arfon Smith
bc7596a8b5 Removing second binary? check 2014-07-07 15:24:22 -05:00
Arthur Verschaeve
6762ca8aa7 Update vendor.yml: normalize.css
Added popular CSS reset Normalize.css (http://necolas.github.io/normalize.css/)
2014-07-07 08:53:42 +02:00
Thomas Van Doren
bb7d6ab429 Merge remote-tracking branch 'github/master' into chapel-lang
Conflicts:
	lib/linguist/samples.json
2014-07-05 11:52:58 -07:00
Arfon Smith
986611ac36 Ask Charlock earlier 2014-07-04 21:12:46 -05:00
Arfon Smith
94b4ad1de6 Merge pull request #1353 from github/1217-local
1217 local
2014-07-04 18:49:34 -05:00
Arfon Smith
3e2f18bf3f Testing Pods 2014-07-04 18:45:43 -05:00
Arfon Smith
48c06cc299 Merge pull request #1352 from github/assembly-inc-revert
Reverting https://github.com/github/linguist/pull/1268
2014-07-04 18:35:13 -05:00
Arfon Smith
f10821ac49 Samples 2014-07-04 14:38:05 -05:00
Arfon Smith
cd5298dee6 Reverting https://github.com/github/linguist/pull/1268 2014-07-04 14:23:59 -05:00
Vicent Marti
a8c955609a Merge pull request #1346 from github/vmg/binary-fix
Properly detect binary blobs
2014-07-04 15:18:54 +02:00
Thomas Van Doren
c5acce0604 Include Chapel in some of the language tests. 2014-07-03 15:31:52 -07:00
Thomas Van Doren
a6ccce7b76 Add Chapel parallel programming language.
Includes several example programs from source distribution.
2014-07-03 15:31:08 -07:00
Josh Oldenburg
aa72012d41 Ignore everything in the Pods directory. 2014-07-03 16:18:58 -04:00
Vicent Marti
458831b885 3.0.2 2014-07-03 18:29:54 +02:00
Vicent Marti
f5e4789ccb Properly handle detection of binary files 2014-07-03 18:29:19 +02:00
Arfon Smith
1b712d2800 Merge pull request #1339 from dvorak/master
Add Puppetfile to ruby filenames
2014-07-03 10:47:39 -05:00
Arfon Smith
e274196441 Merge pull request #1341 from github/1320-local
1320 local
2014-07-02 13:37:20 -05:00
Arfon Smith
c4c3c27cfe Merge branch 'master' into 1320-local
Conflicts:
	lib/linguist/samples.json
2014-07-02 13:27:34 -05:00
Clayton O'Neill
a2dd9d2c8c Add Puppetfile to ruby filenames 2014-07-02 10:46:26 -04:00
Josh Oldenburg
06e095e5fc Only ignore Pods/ for CocoaPods. 2014-07-01 21:38:51 -04:00
Arfon Smith
b26d5bc1b1 Merge pull request #1337 from github/1323-local
1323 local
2014-07-01 19:25:27 -05:00
Arfon Smith
607792e1b2 Merge branch 'master' into 1323-local
Conflicts:
	lib/linguist/samples.json
2014-07-01 16:32:52 -05:00
Arfon Smith
fb38135a61 Merge pull request #1325 from pchaigno/interpreter-php
Interpreter for PHP
2014-07-01 16:27:39 -05:00
Arfon Smith
a5d5b6e6c7 Merge pull request #1333 from spderosso/alloy-lexer
use Alloy lexer
2014-07-01 15:57:55 -05:00
Arfon Smith
2fd2cdf68a Samples 2014-07-01 15:57:20 -05:00
Arfon Smith
11049ca3ca Merge pull request #1331 from GWRon/master
Fixed support for "BlitzMax"
2014-07-01 15:56:43 -05:00
Arfon Smith
c29bea19ef Update README.md 2014-07-01 12:08:42 -05:00
Arfon Smith
8c8434ed64 Merge pull request #1335 from github/1318-local
1318 local
2014-07-01 11:48:24 -05:00
Arfon Smith
9281bd043a Version 2014-07-01 11:19:05 -05:00
Arfon Smith
6771f7c272 Merge branch 'master' into 1318-local 2014-07-01 11:12:44 -05:00
Santiago Perez De Rosso
76b896a66d use Alloy lexer 2014-07-01 11:18:42 -04:00
Ronny Otto
a12520763c Fixed support for "BlitzMax"
- language was already defined but missed "type: programming", so detection of "BlitzMax"-files did not work. Fixed that.
- added "BlitzMax"-example to samples (and recreated samples.json)
2014-07-01 09:56:11 +02:00
Paul Chaignon
819bb7caab Interpreter for PHP 2014-06-28 12:35:26 +02:00
Aloke Desai
152205a146 fixed whitespace 2014-06-27 21:12:41 -07:00
Aloke Desai
85dbcb5444 added grace support 2014-06-27 19:58:53 -07:00
Vicent Marti
df09a746a0 b3 2014-06-27 16:57:58 +02:00
Lucas Bajolet
5199fcf0a2 Updated samples.json.
Signed-off-by: Lucas Bajolet <r4pass@hotmail.com>
2014-06-27 10:53:17 -04:00
Lucas Bajolet
dd557ed00a Added examples for Nit to samples.
Signed-off-by: Lucas Bajolet <r4pass@hotmail.com>
2014-06-27 10:49:29 -04:00
Lucas Bajolet
addf4e2485 Added Nit to supported languages.
Signed-off-by: Lucas Bajolet <r4pass@hotmail.com>
2014-06-27 10:49:08 -04:00
Vicent Marti
d9be472ccb Skip submodules when diffing 2014-06-27 16:41:23 +02:00
Vicent Marti
32828a9af5 b2 2014-06-27 13:51:56 +02:00
Vicent Marti
d206131df0 Hardcode OIDs for test 2014-06-27 13:51:37 +02:00
Vicent Marti
65eaf98d0b docs 2014-06-26 21:26:26 +02:00
Vicent Marti
12429b90fe Bring back missing test 2014-06-26 21:24:30 +02:00
Vicent Marti
621042e639 Remove whitespace 2014-06-26 18:42:43 +02:00
Arfon Smith
526244be11 Samples 2014-06-26 17:38:39 +01:00
Arfon Smith
bc53d0b55e Merge pull request #1311 from maximusvladimir/master
Added 3 character glsl extensions.
2014-06-26 17:37:42 +01:00
Vicent Marti
907d3c5a36 b1 2014-06-26 18:17:51 +02:00
Max K.
898f1e215e Added sample files for glsl. 2014-06-26 09:25:40 -05:00
Vicent Marti
324ac83489 Use the new Rugged release 2014-06-26 14:12:00 +02:00
Vicent Marti
00a873dcc7 Bump 3.0.0b0 2014-06-26 13:03:41 +02:00
Vicent Marti
bc34345a56 Fix the linguist binary 2014-06-26 13:03:30 +02:00
Vicent Marti
659d27cae5 DOCS 2014-06-26 12:54:08 +02:00
Vicent Marti
29072d6eae Fix travis build 2014-06-26 12:27:02 +02:00
Vicent Marti
1fd59361b5 Proper incremental diffing 2014-06-25 20:26:44 +02:00
Vicent Marti
5896bb8fa3 Missing file. Duh. 2014-06-24 17:52:43 +02:00
Vicent Marti
ea1fc90cf5 Handle nil blob names 2014-06-24 17:43:01 +02:00
Vicent Marti
463f48f04f Mode must always be a String 2014-06-24 17:41:16 +02:00
Vicent Marti
cd58a30c7c Only cache strings, thanks 2014-06-24 17:41:16 +02:00
Vicent Marti
c4260ae681 Use Rugged when computing Repository stats 2014-06-24 17:41:16 +02:00
Arfon Smith
d40b4a33de Sorted samples 2014-06-24 10:43:20 +01:00
Arfon Smith
87498679bd Merge pull request #1313 from pchaigno/samples-order
Set a sort order for the samples.json file's content
2014-06-24 10:42:25 +01:00
Paul Chaignon
f4e254202b Set a sort order for the samples.json file's content 2014-06-24 10:50:03 +02:00
Arfon Smith
e91d225e7d Merge pull request #1305 from neersighted/patch-1
Also ignore extern(al)
2014-06-23 23:12:34 +01:00
neersighted
b90d940aef Add tests for extern(al) being vendored 2014-06-23 14:50:31 -07:00
Max K.
b83a364b0e Added 3 character glsl extensions. 2014-06-23 15:46:28 -05:00
Vicent Marti
dbff196b08 Merge pull request #1309 from github/gameover-0x10c
Gameover 0x10c
2014-06-23 17:54:53 +02:00
Joshua Peek
5b7316fb2a Remove DCPU-16 ASM language 2014-06-23 10:48:09 -05:00
Paul Chaignon
2f4ea20fdd Update lexers from Pygments 2014-06-23 14:09:49 +02:00
Arfon Smith
fa4dfe39ba Merge pull request #1306 from github/1100-local
1100 local
2014-06-23 10:33:01 +01:00
Arfon Smith
89999e60bf Merge branch 'master' into 1100-local
Conflicts:
	lib/linguist/languages.yml
2014-06-23 10:28:41 +01:00
neersighted
4819fb12a3 Also ignore extern(al)
...because some of us don't like 'vendor'
2014-06-22 17:18:10 -07:00
Arfon Smith
27a4eeb206 Samples update 2014-06-22 16:19:04 +01:00
Arfon Smith
bacf4d5780 Merge pull request #1303 from geekflyer/master
Add .xsjs and .xsjslib as JavaScript extension (SAP HANA XS)
2014-06-22 16:18:04 +01:00
Christian Theilemann
f92fed60f8 Add .xsjs and .xsjslib as JavaScript file extension
.xsjs and .xsjslib is used to denote server-side JavaScript files in SAP
HANA XS
2014-06-22 15:24:21 +02:00
Arfon Smith
5e797b548c Merge pull request #1273 from k2b6s9j/maven
Add Mavenfile and Jarfile as Ruby files.
2014-06-22 10:17:54 +01:00
Arfon Smith
700e2f1b2b Merge pull request #1299 from pchaigno/idl-lexer
Lexer for IDL
2014-06-21 17:45:16 +01:00
Paul Chaignon
861656978b Lexer for IDL 2014-06-21 17:31:49 +02:00
Arfon Smith
9c05bdac85 Samples 2014-06-21 13:19:38 +01:00
Arfon Smith
bd34c16c8f Merge pull request #1297 from github/map-pryrc-to-ruby
Add .pryrc support
2014-06-21 13:13:10 +01:00
Paul Chaignon
81fcb4452e Rename file for the test on non-existing extension 2014-06-21 10:16:33 +02:00
Paul Chaignon
4f1a5cd456 Remove stylistic yet useless parentheses 2014-06-20 23:30:01 +02:00
Kevin Sawicki
13109bb9b8 Sort filenames 2014-06-20 11:28:35 -07:00
Kevin Sawicki
84f3b3720b Move .pryrc to filenames 2014-06-20 11:27:28 -07:00
Kevin Sawicki
858a66ccc8 Add .pryrc support 2014-06-20 11:18:08 -07:00
Arfon Smith
abb05eace6 Merge pull request #1295 from github/820-local
820 local
2014-06-20 12:42:21 +01:00
Arfon Smith
62bd96a778 Merge branch 'master' into 820-local
Conflicts:
	lib/linguist/samples.json
2014-06-20 12:37:20 +01:00
Arfon Smith
8cb736adfa Merge pull request #1294 from github/675-local
675 local
2014-06-20 12:29:20 +01:00
Arfon Smith
0758c05186 Merge branch 'master' into 675-local
Conflicts:
	.gitignore
	lib/linguist/languages.yml
	lib/linguist/samples.json
2014-06-20 12:22:58 +01:00
Arfon Smith
62bc6f0457 Merge pull request #1293 from github/1232-local
1232 local
2014-06-20 12:17:09 +01:00
Arfon Smith
ea7e894139 Explicit lexer 2014-06-20 12:13:04 +01:00
Arfon Smith
21f0ac99e6 Merge branch 'master' into 1232-local
Conflicts:
	lib/linguist/samples.json
2014-06-20 12:11:43 +01:00
Arfon Smith
b251866a29 Merge pull request #1292 from github/1261-local
1261 local
2014-06-20 11:02:17 +01:00
Arfon Smith
bf3db20a9d Samples 2014-06-20 10:58:44 +01:00
Arfon Smith
bd55147847 Merge branch 'master' into 1261-local 2014-06-20 10:58:21 +01:00
Arfon Smith
f4d64af39b Merge pull request #1291 from github/997-local
997 local
2014-06-20 10:49:46 +01:00
Arfon Smith
b7bda34645 Samples update 2014-06-20 10:46:38 +01:00
Arfon Smith
b13dea6df0 Merge branch 'master' into 997-local 2014-06-20 10:46:04 +01:00
Arfon Smith
28a64c9318 Samples 2014-06-20 10:27:47 +01:00
Arfon Smith
74be618fff Merge pull request #1290 from github/1258-local
1258 local
2014-06-20 10:26:59 +01:00
Arfon Smith
8bbe10bf50 Reordering 2014-06-20 10:22:14 +01:00
Arfon Smith
d275911624 Merge pull request #1289 from github/1132-local
1132 local
2014-06-20 10:17:44 +01:00
Arfon Smith
c26382301c Merge branch 'master' into 1132-local
Conflicts:
	lib/linguist/samples.json
2014-06-20 10:12:04 +01:00
Paul Chaignon
ae2d3d7e61 Merge conflicts from master fixed 2014-06-19 18:45:56 +02:00
Paul Chaignon
58ae0908e3 Sample files to test the new FileBlob.extension method 2014-06-19 18:34:37 +02:00
Arfon Smith
e12bc07041 Samples 2014-06-19 16:03:05 +01:00
Arfon Smith
20416369ac Merge pull request #1282 from github/map-nuspec-to-xml
Add .nuspec extension to XML
2014-06-19 16:02:36 +01:00
Kevin Sawicki
2be91e9b2e Add .nuspec sample 2014-06-19 07:53:52 -07:00
Paul Chaignon
e91caeaade Remove .rb test 2014-06-19 16:39:59 +02:00
Arfon Smith
dc1b8d9e80 Samples 2014-06-19 15:03:30 +01:00
Arfon Smith
bf0a814514 Merge pull request #1283 from LyricsMaster/add-xojo
Add Xojo language support
2014-06-19 15:03:04 +01:00
Kenichi Maehashi
b14267d40f add more samples for Xojo language 2014-06-19 22:59:12 +09:00
Arfon Smith
195a4115d8 Samples 2014-06-19 14:50:41 +01:00
Arfon Smith
e1da8eb841 Merge pull request #1280 from diekmann/patch-1
Added language Isabelle
2014-06-19 14:50:14 +01:00
Paul Chaignon
bd694c60e1 Custom File.extname method which returns the filename if it is an extension 2014-06-19 13:25:27 +02:00
Kenichi Maehashi
14738f037f remove non-source file extensions of Xojo language 2014-06-19 07:27:54 +09:00
Kenichi Maehashi
a437943516 Add Xojo language and example 2014-06-19 01:29:54 +09:00
Kevin Sawicki
900ee57de8 Add .nuspec extension to XML 2014-06-18 08:58:18 -07:00
diekmann
947f4e1c57 alphabetic sorting 2014-06-18 09:34:26 +02:00
diekmann
d9f17a65dd Isabelle language - fixed lexer and added sample
Also, Isabelle is very polular in academia.
See for example http://scholar.google.de/scholar?q=isabelle%2FHOL

In around 40 days, the seL4 microkernel [1] with its
Isabelle proofs is (probably) released on github [2].
[1] http://sel4.systems/
[2] https://lists.cam.ac.uk/mailman/htdig/cl-isabelle-users/2014-June/msg00011.html
2014-06-18 09:16:31 +02:00
Arfon Smith
f71def19ae Merge pull request #1279 from github/jdennes-vendored-octicon-styles
Vendor Octicon styles
2014-06-17 21:42:11 -05:00
Charles Strahan
e452e85cae add nix support 2014-06-17 19:32:22 -04:00
diekmann
5059fe90b0 Added language Isabelle
Isabelle is a generic proof assistant. It is comparables (to some degree) to Coq.

Used in
* diekmann/topoS
* 3of8/sturm
* formare/auctions
* larsrh/hol-falso
* dpthayer/MetaProof

Hello Wolrd example (file must be named HelloWorld.thy):
  theory HelloWorld
  imports Main
  begin
  (*put content here*)
  end
2014-06-17 21:27:03 +02:00
Arfon Smith
b90da731d6 Samples 2014-06-16 16:28:21 -05:00
Arfon Smith
d2012519ba Merge pull request #1268 from metopa/patch-1
Support of the .inc extension in Assembly group.
2014-06-16 16:27:35 -05:00
Gusakov Nikita
1b7f26091c Added generated rule for Zephir language 2014-06-16 19:20:43 +04:00
James Dennes
548e4f1845 Add Octicons entries to vendor.yml 2014-06-15 16:22:18 +02:00
James Dennes
625bed8fca Add failing test for vendored Octicons 2014-06-15 16:19:59 +02:00
Viacheslav Kroilov
db15367775 Rename X86_64.INC to X86_64.inc 2014-06-14 20:13:38 +04:00
Viacheslav Kroilov
309d14a955 Rename SYSTEM.INC to SYSTEM.inc 2014-06-14 20:13:19 +04:00
Viacheslav Kroilov
5ff16e1195 Rename FASM.ASM to FASM.asm 2014-06-14 20:12:50 +04:00
Viacheslav Kroilov
cf43aa9111 Rename ASSEMBLE.INC to ASSEMBLE.inc 2014-06-14 20:11:58 +04:00
metopa
138c1e6024 Added examples for Assembly
From FASM source under BSD
2014-06-14 19:21:02 +04:00
Kepler Sticka-Jones
382870a881 Add Mavenfile and Jarfile as Ruby files. 2014-06-12 13:11:56 -06:00
Andy Lindeman
31921838cd Merge pull request #1272 from github/cut-release-v2.12.0
Bumps to 2.12.0
2014-06-11 17:02:17 -04:00
Andy Lindeman
a707587182 Bumps to 2.12.0 2014-06-11 14:00:46 -04:00
Andy Lindeman
bc482af999 Merge pull request #1269 from github/pygments-bump
Bumps pygments.rb to 0.6.0
2014-06-11 13:58:37 -04:00
Andy Lindeman
6818744dae Merge remote-tracking branch 'origin/master' into pygments-bump 2014-06-11 13:56:53 -04:00
Andy Lindeman
607185ac61 Be explicit about lexer 2014-06-11 13:56:40 -04:00
Andy Lindeman
85479cc2de Swift has a lexer now 2014-06-10 15:54:56 -04:00
Andy Lindeman
3ad4eb2b59 Adds supports for Slim 2014-06-10 15:54:56 -04:00
Andy Lindeman
878fe95ec3 Upgrades to pygments.rb 0.6.0 2014-06-10 15:54:55 -04:00
Viacheslav Kroilov
3d23d1be69 Added .inc extension in Assembly group.
It`s include file for assembler source that helps to structure code. Usually contains normal assembly source.
2014-06-10 21:25:27 +04:00
Paul Chaignon
5580f39df2 Support of the .pp extension for Pascal 2014-06-10 15:40:26 +02:00
William Woodruff
de4d48b0fe added two notebook samples 2014-06-08 23:11:19 -04:00
William Woodruff
b5c49f6d1c added a sample package 2014-06-08 22:57:25 -04:00
William Woodruff
03cb7d6ffb Merge remote-tracking branch 'upstream/master' 2014-06-08 22:54:13 -04:00
William Woodruff
33c42638e9 added two more common mathematica suffixes 2014-06-07 21:21:47 -04:00
Niklas Rosenstein
a7cba23526 added .pyp suffix and an example source file. closes issue #1 2014-06-07 01:29:30 +02:00
Josh Oldenburg
04f4b05412 Ignore files related to Cocoapods.
These include Podfile, Podfile.lock, and Pods/.
2014-05-26 10:35:11 -04:00
Daniël W. Crompton
6d5da4c9ec update 2014-05-14 01:38:55 +02:00
Ricky Elrod
9d569c8bd5 Idris is upstream in Pygments now: https://bitbucket.org/birkenfeld/pygments-main/pull-request/210 2014-04-22 02:54:27 -04:00
Michael Hendricks
ee3c9bcdbd Add misclassified Prolog samples
These two files are incorrectly classified as Perl.  They should be
classified as Prolog.  There are many distinctive tokens in each file
which clearly differentiate between Perl and Prolog.
2014-03-17 08:56:45 -06:00
Paul Chaignon
d94bffb198 Merge branch 'master' of https://github.com/github/linguist into pro 2014-02-21 16:49:46 +01:00
Paul Chaignon
2beb450df6 Support of the .pro file extension for Prolog. 2014-02-10 18:10:20 +01:00
waddlesplash
aa78060e41 Adding QMake (Make-like) language.
Mostly because the file extension conflicts with that of Prolog.
2013-12-10 10:23:13 -05:00
Daniël W. Crompton
7c1716aa1e This pull request solves issue #674, see it for details. 2013-09-06 01:47:14 +02:00
154 changed files with 74185 additions and 67528 deletions

0
.gitattributes vendored Normal file
View File

2
.gitignore vendored
View File

@@ -1,3 +1,5 @@
Gemfile.lock
.bundle/
vendor/
benchmark/
lib/linguist/samples.json

View File

@@ -1,6 +1,8 @@
before_install:
- git fetch origin master:master
- git fetch origin v2.0.0:v2.0.0
- git fetch origin test/attributes:test/attributes
- sudo apt-get install libicu-dev -y
- gem update --system 2.1.11
rvm:
- 1.9.3
- 2.0.0

View File

@@ -1,2 +1,3 @@
source 'https://rubygems.org'
gemspec
gem 'rugged', '0.21.1b2'

View File

@@ -32,33 +32,57 @@ The Language stats bar that you see on every repository is built by aggregating
The repository stats API, accessed through `#languages`, can be used on a directory:
***API UPDATE***
Since [Version 3.0.0](https://github.com/github/linguist/releases/tag/v3.0.0) Linguist expects a git repository (in the form of a [Rugged::Repository](https://github.com/libgit2/rugged#repositories)) to be passed when initializing `Linguist::Repository`.
```ruby
project = Linguist::Repository.from_directory(".")
project.language.name #=> "Ruby"
project.languages #=> { "Ruby" => 0.98, "Shell" => 0.02 }
require 'rugged'
require 'linguist'
repo = Rugged::Repository.new('.')
project = Linguist::Repository.new(repo, repo.head.target_id)
project.language #=> "Ruby"
project.languages #=> { "Ruby" => 119387 }
```
These stats are also printed out by the `linguist` binary. You can use the
`--breakdown` flag, and the binary will also output the breakdown of files by language.
You can try running `linguist` on the `lib/` directory in this repository itself:
You can try running `linguist` on the root directory in this repository itself:
$ bundle exec linguist lib/ --breakdown
$ bundle exec linguist --breakdown
100.00% Ruby
Ruby:
linguist/blob_helper.rb
linguist/classifier.rb
linguist/file_blob.rb
linguist/generated.rb
linguist/heuristics.rb
linguist/language.rb
linguist/md5.rb
linguist/repository.rb
linguist/samples.rb
linguist/tokenizer.rb
linguist.rb
Gemfile
Rakefile
bin/linguist
github-linguist.gemspec
lib/linguist.rb
lib/linguist/blob_helper.rb
lib/linguist/classifier.rb
lib/linguist/file_blob.rb
lib/linguist/generated.rb
lib/linguist/heuristics.rb
lib/linguist/language.rb
lib/linguist/lazy_blob.rb
lib/linguist/md5.rb
lib/linguist/repository.rb
lib/linguist/samples.rb
lib/linguist/tokenizer.rb
lib/linguist/version.rb
test/test_blob.rb
test/test_classifier.rb
test/test_heuristics.rb
test/test_language.rb
test/test_md5.rb
test/test_pedantic.rb
test/test_repository.rb
test/test_samples.rb
test/test_tokenizer.rb
#### Ignore vendored files
@@ -102,10 +126,6 @@ We try to only add languages once they have some usage on GitHub, so please note
Almost all bug fixes or new language additions should come with some additional code samples. Just drop them under [`samples/`](https://github.com/github/linguist/tree/master/samples) in the correct subdirectory and our test suite will automatically test them. In most cases you shouldn't need to add any new assertions.
To update the `samples.json` after adding new files to [`samples/`](https://github.com/github/linguist/tree/master/samples):
bundle exec rake samples
### A note on language extensions
Linguist has a number of methods available to it for identifying the language of a particular file. The initial lookup is based upon the extension of the file, possible file extensions are defined in an array called `extensions`. Take a look at this example for example for `Perl`:
@@ -145,11 +165,11 @@ If you are the current maintainer of this gem:
0. Ensure that tests are green: `bundle exec rake test`
0. Bump gem version in `lib/linguist/version.rb`. For example, [like this](https://github.com/github/linguist/commit/8d2ea90a5ba3b2fe6e1508b7155aa4632eea2985).
0. Make a PR to github/linguist. For example, [#1238](https://github.com/github/linguist/pull/1238).
0. Build a local gem: `gem build github-linguist.gemspec`
0. Build a local gem: `bundle exec rake build_gem`
0. Testing:
0. Bump the Gemfile and Gemfile.lock versions for an app which relies on this gem
0. Install the new gem locally
0. Test behavior locally, branch deploy, whatever needs to happen
0. Merge github/linguist PR
0. Tag and push: `git tag vx.xx.xx; git push --tags`
0. Push to rubygems.org -- `gem push github-linguist-2.10.12.gem`
0. Push to rubygems.org -- `gem push github-linguist-3.0.0.gem`

View File

@@ -7,6 +7,16 @@ task :default => :test
Rake::TestTask.new
# Extend test task to check for samples
task :test => :check_samples
desc "Check that we have samples.json generated"
task :check_samples do
unless File.exist?('lib/linguist/samples.json')
Rake::Task[:samples].invoke
end
end
task :samples do
require 'linguist/samples'
require 'yajl'
@@ -15,13 +25,74 @@ task :samples do
File.open('lib/linguist/samples.json', 'w') { |io| io.write json }
end
task :build_gem do
task :build_gem => :samples do
languages = YAML.load_file("lib/linguist/languages.yml")
File.write("lib/linguist/languages.json", JSON.dump(languages))
`gem build github-linguist.gemspec`
File.delete("lib/linguist/languages.json")
end
namespace :benchmark do
benchmark_path = "benchmark/results"
# $ bundle exec rake benchmark:generate CORPUS=path/to/samples
desc "Generate results for"
task :generate do
ref = `git rev-parse HEAD`.strip[0,8]
corpus = File.expand_path(ENV["CORPUS"] || "samples")
require 'linguist/language'
results = Hash.new
Dir.glob("#{corpus}/**/*").each do |file|
next unless File.file?(file)
filename = file.gsub("#{corpus}/", "")
results[filename] = Linguist::FileBlob.new(file).language
end
# Ensure results directory exists
FileUtils.mkdir_p("benchmark/results")
# Write results
if `git status`.include?('working directory clean')
result_filename = "benchmark/results/#{File.basename(corpus)}-#{ref}.json"
else
result_filename = "benchmark/results/#{File.basename(corpus)}-#{ref}-unstaged.json"
end
File.write(result_filename, results.to_json)
puts "wrote #{result_filename}"
end
# $ bundle exec rake benchmark:compare REFERENCE=path/to/reference.json CANDIDATE=path/to/candidate.json
desc "Compare results"
task :compare do
reference_file = ENV["REFERENCE"]
candidate_file = ENV["CANDIDATE"]
reference = JSON.parse(File.read(reference_file))
reference_counts = Hash.new(0)
reference.each { |filename, language| reference_counts[language] += 1 }
candidate = JSON.parse(File.read(candidate_file))
candidate_counts = Hash.new(0)
candidate.each { |filename, language| candidate_counts[language] += 1 }
changes = diff(reference_counts, candidate_counts)
if changes.any?
changes.each do |language, (before, after)|
before_percent = 100 * before / reference.size.to_f
after_percent = 100 * after / candidate.size.to_f
puts "%s changed from %.1f%% to %.1f%%" % [language || 'unknown', before_percent, after_percent]
end
else
puts "No changes"
end
end
end
namespace :classifier do
LIMIT = 1_000
@@ -37,7 +108,7 @@ namespace :classifier do
next if file_language.nil? || file_language == 'Text'
begin
data = open(file_url).read
guessed_language, score = Linguist::Classifier.classify(Linguist::Samples::DATA, data).first
guessed_language, score = Linguist::Classifier.classify(Linguist::Samples.cache, data).first
total += 1
guessed_language == file_language ? correct += 1 : incorrect += 1
@@ -71,3 +142,10 @@ namespace :classifier do
end
end
end
def diff(a, b)
(a.keys | b.keys).each_with_object({}) do |key, diff|
diff[key] = [a[key], b[key]] unless a[key] == b[key]
end
end

View File

@@ -4,7 +4,9 @@
# usage: linguist <path> [<--breakdown>]
require 'linguist/file_blob'
require 'linguist/language'
require 'linguist/repository'
require 'rugged'
path = ARGV[0] || Dir.pwd
@@ -18,7 +20,8 @@ ARGV.shift
breakdown = true if ARGV[0] == "--breakdown"
if File.directory?(path)
repo = Linguist::Repository.from_directory(path)
rugged = Rugged::Repository.new(path)
repo = Linguist::Repository.new(rugged, rugged.head.target_id)
repo.languages.sort_by { |_, size| size }.reverse.each do |language, size|
percentage = ((size / repo.size.to_f) * 100)
percentage = sprintf '%.2f' % percentage

View File

@@ -16,10 +16,11 @@ Gem::Specification.new do |s|
s.add_dependency 'charlock_holmes', '~> 0.7.3'
s.add_dependency 'escape_utils', '~> 1.0.1'
s.add_dependency 'mime-types', '~> 1.19'
s.add_dependency 'pygments.rb', '~> 0.5.4'
s.add_dependency 'pygments.rb', '~> 0.6.0'
s.add_development_dependency 'json'
s.add_development_dependency 'mocha'
s.add_development_dependency 'pry'
s.add_development_dependency 'rake'
s.add_development_dependency 'yajl-ruby'
end

View File

@@ -1,6 +1,4 @@
require 'linguist/generated'
require 'linguist/language'
require 'charlock_holmes'
require 'escape_utils'
require 'mime/types'
@@ -313,15 +311,7 @@ module Linguist
#
# Returns a Language or nil if none is detected
def language
return @language if defined? @language
if defined?(@data) && @data.is_a?(String)
data = @data
else
data = lambda { (binary_mime_type? || binary?) ? "" : self.data }
end
@language = Language.detect(name.to_s, data, mode)
@language ||= Language.detect(self)
end
# Internal: Get the lexer of the blob.
@@ -331,6 +321,11 @@ module Linguist
language ? language.lexer : Pygments::Lexer.find_by_name('Text only')
end
# Internal: Get the TextMate compatible scope for the blob
def tm_scope
language && language.tm_scope
end
# Public: Highlight syntax of blob
#
# options - A Hash of options (defaults to {})

View File

@@ -52,5 +52,20 @@ module Linguist
def size
File.size(@path)
end
# Public: Get file extension.
#
# Returns a String.
def extension
# File.extname returns nil if the filename is an extension.
extension = File.extname(name)
basename = File.basename(name)
# Checks if the filename is an extension.
if extension.empty? && basename[0] == "."
basename
else
extension
end
end
end
end

View File

@@ -54,7 +54,7 @@ module Linguist
name == 'Gemfile.lock' ||
minified_files? ||
compiled_coffeescript? ||
xcode_project_file? ||
xcode_file? ||
generated_parser? ||
generated_net_docfile? ||
generated_net_designer_file? ||
@@ -63,17 +63,19 @@ module Linguist
generated_jni_header? ||
composer_lock? ||
node_modules? ||
vcr_cassette?
godeps? ||
vcr_cassette? ||
generated_by_zephir?
end
# Internal: Is the blob an XCode project file?
# Internal: Is the blob an Xcode file?
#
# Generated if the file extension is an XCode project
# Generated if the file extension is an Xcode
# file extension.
#
# Returns true of false.
def xcode_project_file?
['.xib', '.nib', '.storyboard', '.pbxproj', '.xcworkspacedata', '.xcuserstate'].include?(extname)
def xcode_file?
['.nib', '.xcworkspacedata', '.xcuserstate'].include?(extname)
end
# Internal: Is the blob minified files?
@@ -230,11 +232,26 @@ module Linguist
!!name.match(/node_modules\//)
end
# Internal: Is the blob part of Godeps/,
# which are not meant for humans in pull requests.
#
# Returns true or false.
def godeps?
!!name.match(/Godeps\//)
end
# Internal: Is the blob a generated php composer lock file?
#
# Returns true or false.
def composer_lock?
!!name.match(/composer.lock/)
!!name.match(/composer\.lock/)
end
# Internal: Is the blob a generated by Zephir
#
# Returns true or false.
def generated_by_zephir?
!!name.match(/.\.zep\.(?:c|h|php)$/)
end
# Is the blob a VCR Cassette file?
@@ -248,3 +265,4 @@ module Linguist
end
end
end

View File

@@ -1,7 +1,7 @@
module Linguist
# A collection of simple heuristics that can be used to better analyze languages.
class Heuristics
ACTIVE = false
ACTIVE = true
# Public: Given an array of String language names,
# apply heuristics against the given data and return an array
@@ -13,28 +13,23 @@ module Linguist
# Returns an array of Languages or []
def self.find_by_heuristics(data, languages)
if active?
if languages.all? { |l| ["Objective-C", "C++"].include?(l) }
disambiguate_c(data, languages)
end
if languages.all? { |l| ["Perl", "Prolog"].include?(l) }
disambiguate_pl(data, languages)
result = disambiguate_pl(data, languages)
end
if languages.all? { |l| ["ECL", "Prolog"].include?(l) }
disambiguate_ecl(data, languages)
result = disambiguate_ecl(data, languages)
end
if languages.all? { |l| ["TypeScript", "XML"].include?(l) }
disambiguate_ts(data, languages)
if languages.all? { |l| ["IDL", "Prolog"].include?(l) }
result = disambiguate_pro(data, languages)
end
if languages.all? { |l| ["Common Lisp", "OpenCL"].include?(l) }
disambiguate_cl(data, languages)
end
if languages.all? { |l| ["Rebol", "R"].include?(l) }
disambiguate_r(data, languages)
result = disambiguate_cl(data, languages)
end
return result
end
end
# .h extensions are ambigious between C, C++, and Objective-C.
# .h extensions are ambiguous between C, C++, and Objective-C.
# We want to shortcut look for Objective-C _and_ now C++ too!
#
# Returns an array of Languages or []
@@ -59,6 +54,16 @@ module Linguist
matches
end
def self.disambiguate_pro(data, languages)
matches = []
if (data.include?(":-"))
matches << Language["Prolog"]
else
matches << Language["IDL"]
end
matches
end
def self.disambiguate_ts(data, languages)
matches = []
if (data.include?("</translation>"))

View File

@@ -9,6 +9,8 @@ end
require 'linguist/classifier'
require 'linguist/heuristics'
require 'linguist/samples'
require 'linguist/file_blob'
require 'linguist/blob_helper'
module Linguist
# Language names that are recognizable by GitHub. Defined languages
@@ -92,18 +94,25 @@ module Linguist
# Public: Detects the Language of the blob.
#
# name - String filename
# data - String blob data. A block also maybe passed in for lazy
# loading. This behavior is deprecated and you should always
# pass in a String.
# mode - Optional String mode (defaults to nil)
# blob - an object that includes the Linguist `BlobHelper` interface;
# see Linguist::LazyBlob and Linguist::FileBlob for examples
#
# Returns Language or nil.
def self.detect(name, data, mode = nil)
def self.detect(blob)
name = blob.name.to_s
# Check if the blob is possibly binary and bail early; this is a cheap
# test that uses the extension name to guess a binary binary mime type.
#
# We'll perform a more comprehensive test later which actually involves
# looking for binary characters in the blob
return nil if blob.likely_binary? || blob.binary?
# A bit of an elegant hack. If the file is executable but extensionless,
# append a "magic" extension so it can be classified with other
# languages that have shebang scripts.
if File.extname(name).empty? && mode && (mode.to_i(8) & 05) == 05
extension = FileBlob.new(name).extension
if extension.empty? && blob.mode && (blob.mode.to_i(8) & 05) == 05
name += ".script!"
end
@@ -114,10 +123,10 @@ module Linguist
# extension at all, in the case of extensionless scripts), we need to continue
# our detection work
if possible_languages.length > 1
data = data.call() if data.respond_to?(:call)
data = blob.data
possible_language_names = possible_languages.map(&:name)
# Don't bother with emptiness
# Don't bother with binary contents or an empty file
if data.nil? || data == ""
nil
# Check if there's a shebang line and use that as authoritative
@@ -126,8 +135,8 @@ module Linguist
# No shebang. Still more work to do. Try to find it with our heuristics.
elsif (determined = Heuristics.find_by_heuristics(data, possible_language_names)) && !determined.empty?
determined.first
# Lastly, fall back to the probablistic classifier.
elsif classified = Classifier.classify(Samples::DATA, data, possible_language_names ).first
# Lastly, fall back to the probabilistic classifier.
elsif classified = Classifier.classify(Samples.cache, data, possible_language_names).first
# Return the actual Language object based of the string language name (i.e., first element of `#classify`)
Language[classified[0]]
end
@@ -183,7 +192,8 @@ module Linguist
#
# Returns all matching Languages or [] if none were found.
def self.find_by_filename(filename)
basename, extname = File.basename(filename), File.extname(filename)
basename = File.basename(filename)
extname = FileBlob.new(filename).extension
langs = @filename_index[basename] +
@extension_index[extname]
langs.compact.uniq
@@ -280,6 +290,16 @@ module Linguist
@lexer = Pygments::Lexer.find_by_name(attributes[:lexer] || name) ||
raise(ArgumentError, "#{@name} is missing lexer")
@tm_scope = attributes[:tm_scope] || begin
context = case @type
when :data, :markup, :prose
'text'
when :programming, nil
'source'
end
"#{context}.#{@name.downcase}"
end
@ace_mode = attributes[:ace_mode]
@wrap = attributes[:wrap] || false
@@ -353,6 +373,11 @@ module Linguist
# Returns the Lexer
attr_reader :lexer
# Public: Get the name of a TextMate-compatible scope
#
# Returns the scope
attr_reader :tm_scope
# Public: Get Ace mode
#
# Examples
@@ -500,9 +525,9 @@ module Linguist
end
end
extensions = Samples::DATA['extnames']
interpreters = Samples::DATA['interpreters']
filenames = Samples::DATA['filenames']
extensions = Samples.cache['extnames']
interpreters = Samples.cache['interpreters']
filenames = Samples.cache['filenames']
popular = YAML.load_file(File.expand_path("../popular.yml", __FILE__))
languages_yml = File.expand_path("../languages.yml", __FILE__)
@@ -522,6 +547,7 @@ module Linguist
if extnames = extensions[name]
extnames.each do |extname|
if !options['extensions'].include?(extname)
warn "#{name} has a sample with extension (#{extname}) that isn't explicitly defined in languages.yml" unless extname == '.script!'
options['extensions'] << extname
end
end
@@ -553,6 +579,7 @@ module Linguist
:type => options['type'],
:aliases => options['aliases'],
:lexer => options['lexer'],
:tm_scope => options['tm_scope'],
:ace_mode => options['ace_mode'],
:wrap => options['wrap'],
:group_name => options['group'],

View File

@@ -28,6 +28,16 @@ ABAP:
extensions:
- .abap
AGS Script:
type: programming
lexer: C++
color: "#B9D9FF"
aliases:
- ags
extensions:
- .asc
- .ash
ANTLR:
type: programming
color: "#9DC3FF"
@@ -35,6 +45,12 @@ ANTLR:
extensions:
- .g4
APL:
type: programming
color: "#8a0707"
extensions:
- .apl
ASP:
type: programming
color: "#6a40fd"
@@ -67,6 +83,7 @@ ATS:
ActionScript:
type: programming
lexer: ActionScript 3
tm_scope: source.actionscript.3
color: "#e3491a"
search_term: as3
aliases:
@@ -89,7 +106,7 @@ Agda:
Alloy:
type: programming # 'modeling' would be more appropiate
lexer: Text only
lexer: Alloy
color: "#cc5c24"
extensions:
- .als
@@ -103,7 +120,7 @@ ApacheConf:
Apex:
type: programming
lexer: Text only
lexer: Java
extensions:
- .cls
@@ -221,6 +238,8 @@ BlitzBasic:
- .decls
BlitzMax:
type: programming
color: "#cd6400"
extensions:
- .bmx
@@ -258,13 +277,15 @@ C:
extensions:
- .c
- .cats
- .h
- .w
C#:
type: programming
ace_mode: csharp
tm_scope: source.cs
search_term: csharp
color: "#5a25a2"
color: "#178600"
aliases:
- csharp
extensions:
@@ -286,6 +307,7 @@ C++:
- .cc
- .cxx
- .H
- .h
- .h++
- .hh
- .hpp
@@ -319,7 +341,7 @@ CLIPS:
CMake:
extensions:
- .cmake
- .cmake.in
- .in
filenames:
- CMakeLists.txt
@@ -344,6 +366,14 @@ Ceylon:
extensions:
- .ceylon
Chapel:
type: programming
color: "#8dc63f"
aliases:
- chpl
extensions:
- .chpl
ChucK:
lexer: Java
extensions:
@@ -352,9 +382,8 @@ ChucK:
Cirru:
type: programming
color: "#aaaaff"
# ace_mode: cirru
# lexer: Cirru
lexer: Text only
ace_mode: cirru
lexer: Cirru
extensions:
- .cirru
@@ -378,12 +407,13 @@ Clojure:
- .cljscm
- .cljx
- .hic
- .cljs.hl
- .hl
filenames:
- riemann.config
CoffeeScript:
type: programming
tm_scope: source.coffee
ace_mode: coffee
color: "#244776"
aliases:
@@ -401,18 +431,32 @@ CoffeeScript:
ColdFusion:
type: programming
group: ColdFusion
lexer: Coldfusion HTML
ace_mode: coldfusion
color: "#ed2cd6"
search_term: cfm
aliases:
- cfm
- cfml
extensions:
- .cfm
ColdFusion CFC:
type: programming
group: ColdFusion
lexer: Coldfusion CFC
ace_mode: coldfusion
color: "#ed2cd6"
search_term: cfc
aliases:
- cfc
extensions:
- .cfc
Common Lisp:
type: programming
tm_scope: source.lisp
color: "#3fb68b"
aliases:
- lisp
@@ -442,6 +486,7 @@ Coq:
type: programming
extensions:
- .coq
- .v
Cpp-ObjDump:
type: data
@@ -477,6 +522,12 @@ Cuda:
- .cu
- .cuh
Cycript:
type: programming
lexer: JavaScript
extensions:
- .cy
Cython:
type: programming
group: Python
@@ -528,18 +579,10 @@ Dart:
extensions:
- .dart
DCPU-16 ASM:
type: programming
lexer: dasm16
extensions:
- .dasm16
- .dasm
aliases:
- dasm16
Diff:
extensions:
- .diff
- .patch
Dogescript:
type: programming
@@ -588,7 +631,7 @@ Eagle:
Eiffel:
type: programming
lexer: Text only
lexer: Eiffel
color: "#946d57"
extensions:
- .e
@@ -608,7 +651,8 @@ Elm:
Emacs Lisp:
type: programming
lexer: Scheme
lexer: Common Lisp
tm_scope: source.lisp
color: "#c065db"
aliases:
- elisp
@@ -619,11 +663,20 @@ Emacs Lisp:
- .el
- .emacs
EmberScript:
type: programming
color: "#f64e3e"
lexer: CoffeeScript
extensions:
- .em
- .emberscript
Erlang:
type: programming
color: "#0faf8d"
extensions:
- .erl
- .escript
- .hrl
F#:
@@ -699,6 +752,8 @@ Forth:
extensions:
- .fth
- .4th
- .forth
- .frt
Frege:
type: programming
@@ -707,6 +762,14 @@ Frege:
extensions:
- .fr
G-code:
type: data
lexer: Text only
extensions:
- .g
- .gco
- .gcode
Game Maker Language:
type: programming
color: "#8ad353"
@@ -736,6 +799,12 @@ GAS:
- .s
- .S
GDScript:
type: programming
lexer: Text only
extensions:
- .gd
GLSL:
group: C
type: programming
@@ -743,12 +812,14 @@ GLSL:
- .glsl
- .fp
- .frag
- .frg
- .fshader
- .geom
- .glslv
- .gshader
- .shader
- .vert
- .vrx
- .vshader
Genshi:
@@ -805,6 +876,15 @@ Gosu:
color: "#82937f"
extensions:
- .gs
- .gst
- .gsx
- .vark
Grace:
type: programming
lexer: Text only
extensions:
- .grace
Grammatical Framework:
type: programming
@@ -817,6 +897,12 @@ Grammatical Framework:
searchable: true
color: "#ff0000"
Graph Modeling Language:
type: data
lexer: Text only
extensions:
- .gml
Groff:
extensions:
- .man
@@ -834,6 +920,7 @@ Groovy:
color: "#e69f56"
extensions:
- .groovy
- .gradle
- .grt
- .gtpl
- .gvy
@@ -850,18 +937,19 @@ Groovy Server Pages:
HTML:
type: markup
tm_scope: text.html.basic
ace_mode: html
aliases:
- xhtml
extensions:
- .html
- .htm
- .html.hl
- .st
- .xhtml
HTML+Django:
type: markup
tm_scope: text.html.django
group: HTML
lexer: HTML+Django/Jinja
extensions:
@@ -870,18 +958,18 @@ HTML+Django:
HTML+ERB:
type: markup
tm_scope: text.html.ruby
group: HTML
lexer: RHTML
aliases:
- erb
extensions:
- .erb
- .erb.deface
- .html.erb
- .html.erb.deface
- .deface
HTML+PHP:
type: markup
tm_scope: text.html.php
group: HTML
extensions:
- .phtml
@@ -896,17 +984,14 @@ Haml:
type: markup
extensions:
- .haml
- .haml.deface
- .html.haml.deface
- .deface
Handlebars:
type: markup
lexer: Text only
lexer: Handlebars
extensions:
- .handlebars
- .hbs
- .html.handlebars
- .html.hbs
Harbour:
type: programming
@@ -932,7 +1017,7 @@ Haxe:
Hy:
type: programming
lexer: Clojure
lexer: Hy
ace_mode: clojure
color: "#7891b1"
extensions:
@@ -940,10 +1025,17 @@ Hy:
IDL:
type: programming
lexer: Text only
lexer: IDL
color: "#e3592c"
extensions:
- .pro
- .dlm
IGOR Pro:
type: programming
lexer: Igor
extensions:
- .ipf
INI:
type: data
@@ -959,14 +1051,14 @@ Inno Setup:
Idris:
type: programming
lexer: Text only
lexer: Idris
extensions:
- .idr
- .lidr
Inform 7:
type: programming
lexer: Text only
lexer: Inform 7
wrap: true
extensions:
- .ni
@@ -998,6 +1090,13 @@ Ioke:
extensions:
- .ik
Isabelle:
type: programming
lexer: Text only
color: "#fdcd00"
extensions:
- .thy
J:
type: programming
lexer: Text only
@@ -1006,11 +1105,13 @@ J:
JSON:
type: data
tm_scope: source.json
group: JavaScript
ace_mode: json
searchable: false
extensions:
- .json
- .lock
- .sublime-keymap
- .sublime-mousemap
- .sublime-project
@@ -1067,6 +1168,7 @@ Java Server Pages:
JavaScript:
type: programming
tm_scope: source.js
ace_mode: javascript
color: "#f1e05a"
aliases:
@@ -1079,6 +1181,7 @@ JavaScript:
- .es6
- .frag
- .jake
- .jsb
- .jsfl
- .jsm
- .jss
@@ -1087,6 +1190,8 @@ JavaScript:
- .pac
- .sjs
- .ssjs
- .xsjs
- .xsjslib
filenames:
- Jakefile
interpreters:
@@ -1131,12 +1236,31 @@ LLVM:
extensions:
- .ll
LSL:
type: programming
lexer: LSL
ace_mode: lsl
extensions:
- .lsl
interpreters:
- lsl
color: '#3d9970'
LabVIEW:
type: programming
lexer: Text only
extensions:
- .lvproj
Lasso:
type: programming
lexer: Lasso
color: "#2584c3"
extensions:
- .lasso
- .las
- .lasso9
- .ldml
Latte:
type: markup
@@ -1173,6 +1297,7 @@ Literate Agda:
Literate CoffeeScript:
type: programming
tm_scope: source.litcoffee
group: CoffeeScript
lexer: Text only
ace_mode: markdown
@@ -1215,6 +1340,14 @@ Logtalk:
- .lgt
- .logtalk
LookML:
type: programming
lexer: YAML
ace_mode: yaml
color: "#652B81"
extensions:
- .lookml
Lua:
type: programming
ace_mode: lua
@@ -1222,6 +1355,7 @@ Lua:
extensions:
- .lua
- .nse
- .pd_lua
- .rbxs
interpreters:
- lua
@@ -1285,7 +1419,9 @@ Mathematica:
type: programming
extensions:
- .mathematica
lexer: Text only
- .m
- .nb
lexer: Mathematica
Matlab:
type: programming
@@ -1333,7 +1469,7 @@ MiniD: # Legacy
Mirah:
type: programming
lexer: Ruby
search_term: ruby
search_term: mirah
color: "#c7a938"
extensions:
- .druby
@@ -1365,6 +1501,7 @@ Myghty:
NSIS:
extensions:
- .nsi
- .nsh
Nemerle:
type: programming
@@ -1392,6 +1529,19 @@ Nimrod:
- .nim
- .nimrod
Nit:
type: programming
lexer: Text only
color: "#0d8921"
extensions:
- .nit
Nix:
type: programming
lexer: Nix
extensions:
- .nix
Nu:
type: programming
lexer: Scheme
@@ -1416,6 +1566,7 @@ OCaml:
color: "#3be133"
extensions:
- .ml
- .eliom
- .eliomi
- .ml4
- .mli
@@ -1430,15 +1581,18 @@ ObjDump:
Objective-C:
type: programming
tm_scope: source.objc
color: "#438eff"
aliases:
- obj-c
- objc
extensions:
- .m
- .h
Objective-C++:
type: programming
tm_scope: source.objc++
color: "#4886FC"
aliases:
- obj-c++
@@ -1467,6 +1621,13 @@ Opa:
extensions:
- .opa
Opal:
type: programming
color: "#f7ede0"
lexer: Text only
extensions:
- .opal
OpenCL:
type: programming
group: C
@@ -1483,6 +1644,13 @@ OpenEdge ABL:
- abl
extensions:
- .p
- .cls
OpenSCAD:
type: programming
lexer: Text only
extensions:
- .scad
Org:
type: prose
@@ -1515,22 +1683,26 @@ PAWN:
PHP:
type: programming
tm_scope: text.html.php
ace_mode: php
color: "#4F5D95"
extensions:
- .php
- .aw
- .ctp
- .module
- .php3
- .php4
- .php5
- .phpt
filenames:
- Phakefile
interpreters:
- php
Pan:
type: programming
lexer: Text only
lexer: Pan
color: '#cc0000'
extensions:
- .pan
@@ -1567,7 +1739,9 @@ Pascal:
extensions:
- .pas
- .dfm
- .dpr
- .lpr
- .pp
Perl:
type: programming
@@ -1576,12 +1750,15 @@ Perl:
extensions:
- .pl
- .PL
- .cgi
- .fcgi
- .perl
- .ph
- .plx
- .pm
- .pod
- .psgi
- .t
interpreters:
- perl
@@ -1598,10 +1775,17 @@ Perl6:
- .pl6
- .pm6
PigLatin:
type: programming
color: "#fcd7de"
lexer: Text only
extensions:
- .pig
Pike:
type: programming
color: "#066ab2"
lexer: C
lexer: Pike
extensions:
- .pike
- .pmod
@@ -1646,11 +1830,13 @@ Processing:
Prolog:
type: programming
lexer: Logtalk
color: "#74283c"
extensions:
- .prolog
- .ecl
- .pl
- .ecl
- .pro
- .prolog
Propeller Spin:
type: programming
@@ -1695,9 +1881,11 @@ Python:
color: "#3581ba"
extensions:
- .py
- .cgi
- .gyp
- .lmi
- .pyde
- .pyp
- .pyt
- .pyw
- .wsgi
@@ -1723,6 +1911,12 @@ QML:
extensions:
- .qml
QMake:
lexer: Text only
extensions:
- .pro
- .pri
R:
type: programming
color: "#198ce7"
@@ -1743,7 +1937,7 @@ R:
RDoc:
type: prose
lexer: Text only
lexer: Rd
ace_mode: rdoc
wrap: true
extensions:
@@ -1783,6 +1977,7 @@ Racket:
- .rkt
- .rktd
- .rktl
- .scrbl
Ragel in Ruby Host:
type: programming
@@ -1852,7 +2047,10 @@ Ruby:
- .god
- .irbrc
- .mspec
- .pluginspec
- .podspec
- .rabl
- .rake
- .rbuild
- .rbw
- .rbx
@@ -1862,13 +2060,17 @@ Ruby:
interpreters:
- ruby
filenames:
- .pryrc
- Appraisals
- Berksfile
- Buildfile
- Gemfile
- Gemfile.lock
- Guardfile
- Jarfile
- Mavenfile
- Podfile
- Puppetfile
- Thorfile
- Vagrantfile
- buildfile
@@ -1888,13 +2090,23 @@ SAS:
SCSS:
type: markup
tm_scope: source.scss
group: CSS
ace_mode: scss
extensions:
- .scss
SQF:
type: programming
color: "#FFCB1F"
lexer: C++
extensions:
- .sqf
- .hqf
SQL:
type: data
tm_scope: source.sql
ace_mode: sql
extensions:
- .sql
@@ -1919,9 +2131,11 @@ Sage:
Sass:
type: markup
tm_scope: source.sass
group: CSS
extensions:
- .sass
- .scss
Scala:
type: programming
@@ -1929,6 +2143,7 @@ Scala:
color: "#7dd3b0"
extensions:
- .scala
- .sbt
- .sc
Scaml:
@@ -1944,6 +2159,7 @@ Scheme:
- .scm
- .sld
- .sls
- .sps
- .ss
interpreters:
- guile
@@ -1955,6 +2171,8 @@ Scilab:
type: programming
extensions:
- .sci
- .sce
- .tst
Self:
type: programming
@@ -1974,8 +2192,11 @@ Shell:
- zsh
extensions:
- .sh
- .bash
- .bats
- .cgi
- .tmux
- .zsh
interpreters:
- bash
- sh
@@ -2002,6 +2223,14 @@ Slash:
extensions:
- .sl
Slim:
group: HTML
type: markup
lexer: Slim
color: "#ff8877"
extensions:
- .slim
Smalltalk:
type: programming
color: "#596706"
@@ -2034,6 +2263,7 @@ Standard ML:
extensions:
- .ML
- .fun
- .sig
- .sml
Stata:
@@ -2064,8 +2294,8 @@ SuperCollider:
Swift:
type: programming
lexer: Swift
color: "#ffac45"
lexer: Text only
extensions:
- .swift
@@ -2114,10 +2344,13 @@ TeX:
extensions:
- .tex
- .aux
- .bbx
- .bib
- .cbx
- .cls
- .dtx
- .ins
- .lbx
- .ltx
- .mkii
- .mkiv
@@ -2234,6 +2467,7 @@ Visual Basic:
extensions:
- .vb
- .bas
- .cls
- .frm
- .frx
- .vba
@@ -2262,6 +2496,7 @@ XML:
- wsdl
extensions:
- .xml
- .ant
- .axml
- .ccxml
- .clixml
@@ -2275,11 +2510,13 @@ XML:
- .fsproj
- .glade
- .grxml
- .ivy
- .jelly
- .kml
- .launch
- .mxml
- .nproj
- .nuspec
- .osm
- .plist
- .pluginspec
@@ -2351,6 +2588,17 @@ XSLT:
- .xslt
- .xsl
Xojo:
type: programming
lexer: VB.net
extensions:
- .xojo_code
- .xojo_menu
- .xojo_report
- .xojo_script
- .xojo_toolbar
- .xojo_window
Xtend:
type: programming
extensions:
@@ -2358,6 +2606,7 @@ Xtend:
YAML:
type: data
tm_scope: source.yaml
aliases:
- yml
extensions:

71
lib/linguist/lazy_blob.rb Normal file
View File

@@ -0,0 +1,71 @@
require 'linguist/blob_helper'
require 'linguist/language'
require 'rugged'
module Linguist
class LazyBlob
GIT_ATTR = ['linguist-language', 'linguist-vendored']
GIT_ATTR_OPTS = { :priority => [:index], :skip_system => true }
GIT_ATTR_FLAGS = Rugged::Repository::Attributes.parse_opts(GIT_ATTR_OPTS)
include BlobHelper
MAX_SIZE = 128 * 1024
attr_reader :repository
attr_reader :oid
attr_reader :name
attr_reader :mode
def initialize(repo, oid, name, mode = nil)
@repository = repo
@oid = oid
@name = name
@mode = mode
end
def git_attributes
@git_attributes ||= repository.fetch_attributes(
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 language
return @language if defined?(@language)
@language = if lang = git_attributes['linguist-language']
Language.find_by_name(lang)
else
super
end
end
def data
load_blob!
@data
end
def size
load_blob!
@size
end
protected
# Returns true if the attribute is present and not the string "false".
def boolean_attribute(attr)
attr != "false"
end
def load_blob!
@data, @size = Rugged::Blob.to_buffer(repository, oid, MAX_SIZE) if @data.nil?
end
end
end

View File

@@ -1,4 +1,5 @@
require 'linguist/file_blob'
require 'linguist/lazy_blob'
require 'rugged'
module Linguist
# A Repository is an abstraction of a Grit::Repo or a basic file
@@ -7,100 +8,165 @@ module Linguist
# Its primary purpose is for gathering language statistics across
# the entire project.
class Repository
# Public: Initialize a new Repository from a File directory
#
# base_path - A path String
#
# Returns a Repository
def self.from_directory(base_path)
new Dir["#{base_path}/**/*"].
select { |f| File.file?(f) }.
map { |path| FileBlob.new(path, base_path) }
attr_reader :repository
# Public: Create a new Repository based on the stats of
# an existing one
def self.incremental(repo, commit_oid, old_commit_oid, old_stats)
repo = self.new(repo, commit_oid)
repo.load_existing_stats(old_commit_oid, old_stats)
repo
end
# Public: Initialize a new Repository
# Public: Initialize a new Repository to be analyzed for language
# data
#
# enum - Enumerator that responds to `each` and
# yields Blob objects
# repo - a Rugged::Repository object
# commit_oid - the sha1 of the commit that will be analyzed;
# this is usually the master branch
#
# Returns a Repository
def initialize(enum)
@enum = enum
@computed_stats = false
@language = @size = nil
@sizes = Hash.new { 0 }
@file_breakdown = Hash.new { |h,k| h[k] = Array.new }
def initialize(repo, commit_oid)
@repository = repo
@commit_oid = commit_oid
raise TypeError, 'commit_oid must be a commit SHA1' unless commit_oid.is_a?(String)
end
# Public: Load the results of a previous analysis on this repository
# to speed up the new scan.
#
# The new analysis will be performed incrementally as to only take
# into account the file changes since the last time the repository
# was scanned
#
# old_commit_oid - the sha1 of the commit that was previously analyzed
# old_stats - the result of the previous analysis, obtained by calling
# Repository#cache on the old repository
#
# Returns nothing
def load_existing_stats(old_commit_oid, old_stats)
@old_commit_oid = old_commit_oid
@old_stats = old_stats
nil
end
# Public: Returns a breakdown of language stats.
#
# Examples
#
# # => { Language['Ruby'] => 46319,
# Language['JavaScript'] => 258 }
# # => { 'Ruby' => 46319,
# 'JavaScript' => 258 }
#
# Returns a Hash of Language keys and Integer size values.
# Returns a Hash of language names and Integer size values.
def languages
compute_stats
@sizes
@sizes ||= begin
sizes = Hash.new { 0 }
cache.each do |_, (language, size)|
sizes[language] += size
end
sizes
end
end
# Public: Get primary Language of repository.
#
# Returns a Language
# Returns a language name
def language
compute_stats
@language
@language ||= begin
primary = languages.max_by { |(_, size)| size }
primary && primary[0]
end
end
# Public: Get the total size of the repository.
#
# Returns a byte size Integer
def size
compute_stats
@size
@size ||= languages.inject(0) { |s,(_,v)| s + v }
end
# Public: Return the language breakdown of this repository by file
#
# Returns a map of language names => [filenames...]
def breakdown_by_file
compute_stats
@file_breakdown
@file_breakdown ||= begin
breakdown = Hash.new { |h,k| h[k] = Array.new }
cache.each do |filename, (language, _)|
breakdown[language] << filename
end
breakdown
end
end
# Internal: Compute language breakdown for each blob in the Repository.
# Public: Return the cached results of the analysis
#
# Returns nothing
def compute_stats
return if @computed_stats
# This is a per-file breakdown that can be passed to other instances
# of Linguist::Repository to perform incremental scans
#
# Returns a map of filename => [language, size]
def cache
@cache ||= begin
if @old_commit_oid == @commit_oid
@old_stats
else
compute_stats(@old_commit_oid, @old_stats)
end
end
end
@enum.each do |blob|
# Skip files that are likely binary
next if blob.likely_binary?
def read_index
attr_index = Rugged::Index.new
attr_index.read_tree(current_tree)
repository.index = attr_index
end
# Skip vendored or generated blobs
next if blob.vendored? || blob.generated? || blob.language.nil?
def current_tree
@tree ||= Rugged::Commit.lookup(repository, @commit_oid).tree
end
# Only include programming languages and acceptable markup languages
if blob.language.type == :programming || Language.detectable_markup.include?(blob.language.name)
protected
# Build up the per-file breakdown stats
@file_breakdown[blob.language.group.name] << blob.name
def compute_stats(old_commit_oid, cache = nil)
old_tree = old_commit_oid && Rugged::Commit.lookup(repository, old_commit_oid).tree
@sizes[blob.language.group] += blob.size
read_index
diff = Rugged::Tree.diff(repository, old_tree, current_tree)
# Clear file map and fetch full diff if any .gitattributes files are changed
if cache && diff.each_delta.any? { |delta| File.basename(delta.new_file[:path]) == ".gitattributes" }
diff = Rugged::Tree.diff(repository, old_tree = nil, current_tree)
file_map = {}
else
file_map = cache ? cache.dup : {}
end
diff.each_delta do |delta|
old = delta.old_file[:path]
new = delta.new_file[:path]
file_map.delete(old)
next if delta.binary
if [:added, :modified].include? delta.status
# Skip submodules
mode = delta.new_file[:mode]
next if (mode & 040000) != 0
blob = Linguist::LazyBlob.new(repository, delta.new_file[:oid], new, mode.to_s(8))
# Skip vendored or generated blobs
next if blob.vendored? || blob.generated? || blob.language.nil?
# Only include programming languages and acceptable markup languages
if blob.language.type == :programming || Language.detectable_markup.include?(blob.language.name)
file_map[new] = [blob.language.group.name, blob.size]
end
end
end
# Compute total size
@size = @sizes.inject(0) { |s,(_,v)| s + v }
# Get primary language
if primary = @sizes.max_by { |(_, size)| size }
@language = primary[0]
end
@computed_stats = true
nil
file_map
end
end
end

File diff suppressed because it is too large Load Diff

View File

@@ -17,9 +17,11 @@ module Linguist
PATH = File.expand_path('../samples.json', __FILE__)
# Hash of serialized samples object
if File.exist?(PATH)
serializer = defined?(JSON) ? JSON : YAML
DATA = serializer.load(File.read(PATH))
def self.cache
@cache ||= begin
serializer = defined?(JSON) ? JSON : YAML
serializer.load(File.read(PATH))
end
end
# Public: Iterate over each sample.
@@ -28,7 +30,7 @@ module Linguist
#
# Returns nothing.
def self.each(&block)
Dir.entries(ROOT).each do |category|
Dir.entries(ROOT).sort!.each do |category|
next if category == '.' || category == '..'
# Skip text and binary for now

View File

@@ -33,16 +33,36 @@
# Erlang bundles
- ^rebar$
# Go dependencies
- Godeps/_workspace/
# Bootstrap minified css and js
- (^|/)bootstrap([^.]*)(\.min)?\.(js|css)$
# Font Awesome
- font-awesome.min.css
- font-awesome.css
# Foundation css
- foundation.min.css
- foundation.css
# Normalize.css
- normalize.css
# Bourbon SCSS
- (^|/)[Bb]ourbon/.*\.css$
- (^|/)[Bb]ourbon/.*\.scss$
# Animate.css
- animate.css
- animate.min.css
# Vendored dependencies
- thirdparty/
- third[-_]?party/
- 3rd[-_]?party/
- vendors?/
- extern(al)?/
# Debian packaging
- ^debian/
@@ -108,6 +128,10 @@
- (^|/)modernizr\-\d\.\d+(\.\d+)?(\.min)?\.js$
- (^|/)modernizr\.custom\.\d+\.js$
# Knockout
- (^|/)knockout-(\d+\.){3}(debug\.)?js$
- knockout-min.js
## Python ##
# django
@@ -124,6 +148,9 @@
## Obj-C ##
# Cocoapods
- ^Pods/
# Sparkle
- (^|/)Sparkle/
@@ -191,6 +218,9 @@
- (^|/)cordova([^.]*)(\.min)?\.js$
- (^|/)cordova\-\d\.\d(\.\d)?(\.min)?\.js$
# Foundation js
- foundation(\..*)?\.js$
# Vagrant
- ^Vagrantfile$
@@ -204,3 +234,11 @@
- ^vignettes/
- ^inst/extdata/
# Octicons
- octicons.css
- octicons.min.css
- sprockets-octicons.scss
# Typesafe Activator
- (^|/)activator$
- (^|/)activator\.bat$

View File

@@ -1,3 +1,3 @@
module Linguist
VERSION = "2.11.5"
VERSION = "3.4.0"
end

View File

@@ -0,0 +1,521 @@
// main global script file
// A function that initializes a bunch of stuff.
function initialize_control_panel() {
// Centre the control panel
gPanel.Centre();
// Centre the Restart dialog as well
gRestartYN.Centre();
if (!IsSpeechVoxAvailable()) {
// If there is no speech-vox file, and therefore no speech,
// disable all the controls related with speech.
lblVoice.Visible = false;
btnVoice.Visible = false;
sldVoice.Visible = false;
}
else {
// If there *is*, then set it to voice and text. It's best to use
// both whenever possible, for the player's sake.
SetVoiceMode(eSpeechVoiceAndText);
// And reflect this in the control panel.
btnVoice.Text = "Voice and Text";
}
if (!System.SupportsGammaControl) {
// If we can't change the gamma settings, disable the relevant options.
sldGamma.Visible = false;
lblGamma.Visible = false;
}
//And now, set all the defaults
System.Volume = 100;
sldAudio.Value = System.Volume;
SetGameSpeed(40);
sldSpeed.Value = 40;
if (IsSpeechVoxAvailable()) {
SetVoiceMode(eSpeechVoiceAndText);
btnVoice.Text = "Voice and Text";
sldVoice.Value = 255;
SetSpeechVolume(255);
}
if (System.SupportsGammaControl) {
System.Gamma = 100;
sldGamma.Value = 100;
}
}
// Called when the game starts, before the first room is loaded
function game_start() {
// Put the code all in a function and then just call the function.
// It saves cluttering up places like game_start.
initialize_control_panel();
// Use the KeyboardMovement module to, per default, replicate the standard
// keyboard movement of most Sierra games. See KeyboardMovement.txt for more info
KeyboardMovement.SetMode(eKeyboardMovement_Tapping);
}
function repeatedly_execute() {
// Put here anything you want to happen every game cycle, even when
// the game is paused. This will not run when the game is blocked
// inside a command like a blocking Walk()
if (IsGamePaused() == 1) return;
// Put here anything you want to happen every game cycle, but not
// when the game is paused.
}
function repeatedly_execute_always() {
// Put anything you want to happen every game cycle, even
// when the game is blocked inside a command like a
// blocking Walk().
// You cannot run blocking commands from this function.
}
function show_inventory_window ()
{
gInventory.Visible = true;
// switch to the Use cursor (to select items with)
mouse.Mode = eModeInteract;
// But, override the appearance to look like the arrow
mouse.UseModeGraphic(eModePointer);
}
function show_save_game_dialog()
{
gSaveGame.Visible = true;
// Get the list of save games
lstSaveGamesList.FillSaveGameList();
if (lstSaveGamesList.ItemCount > 0)
{
// If there is at least one, set the default text
// to be the first game's name
txtNewSaveName.Text = lstSaveGamesList.Items[0];
}
else
{
// No save games yet, default empty text.
txtNewSaveName.Text = "";
}
mouse.UseModeGraphic(eModePointer);
gIconbar.Visible = false;
}
function show_restore_game_dialog()
{
gRestoreGame.Visible = true;
lstRestoreGamesList.FillSaveGameList();
mouse.UseModeGraphic(eModePointer);
gIconbar.Visible = false;
}
function close_save_game_dialog()
{
gSaveGame.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
}
function close_restore_game_dialog()
{
gRestoreGame.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
}
// Called when a key is pressed. keycode holds the key's ASCII code
function on_key_press(eKeyCode keycode) {
// The following is called before "if game is paused keycode=0", so
// it'll happen even when the game is paused.
if ((keycode == eKeyEscape) && gRestartYN.Visible) {
//Use ESC to cancel restart.
gRestartYN.Visible = false;
gIconbar.Visible = true;
// If the panel's not ON, then the player must have gotten here by tapping F9,
// therefore his cursor needs restoring. If the panel IS on, then it doesn't,
// because it's already a pointer. Get used to thinking like this!!
if (!gPanel.Visible) mouse.UseDefaultGraphic();
return;
}
if ((keycode == eKeyEscape) && gPanel.Visible) {
// Use ESC to turn the panel off.
gPanel.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
return;
}
if ((keycode == eKeyEscape) && (gSaveGame.Visible))
{
// Use ESC to close the save game dialog
close_save_game_dialog();
return;
}
if ((keycode == eKeyEscape) && (gRestoreGame.Visible))
{
// Use ESC to close the restore game dialog
close_restore_game_dialog();
return;
}
if (keycode == eKeyReturn) {
// ENTER, in this case merely confirms restart
if (gRestartYN.Visible) RestartGame();
}
if (IsGamePaused() || (IsInterfaceEnabled() == 0))
{
// If the game is paused with a modal GUI on the
// screen, or the player interface is disabled in
// a cut scene, ignore any keypresses.
return;
}
// FUNCTION KEYS AND SYSTEM SHORTCUTS
if (keycode == eKeyEscape) {
// ESC
gPanel.Visible = true;
gIconbar.Visible = false;
mouse.UseModeGraphic(eModePointer);
}
if (keycode == eKeyCtrlQ) QuitGame(1); // Ctrl-Q
if (keycode == eKeyF5) show_save_game_dialog(); // F5
if (keycode == eKeyF7) show_restore_game_dialog(); // F7
if (keycode == eKeyF9) {
// F9, asks the player to confirm restarting (so much better to always confirm first)
gRestartYN.Visible = true;
gIconbar.Visible = false;
mouse.UseModeGraphic(eModePointer);
}
if (keycode == eKeyF12) SaveScreenShot("scrnshot.bmp"); // F12
if (keycode == eKeyTab) show_inventory_window(); // Tab, show inventory
// GAME COMMAND SHORTCUTS
if (keycode == 'W') mouse.Mode=eModeWalkto; //Notice this alternate way to indicate keycodes.
if (keycode == 'L') mouse.Mode=eModeLookat; //Note that all we do here is set modes.
if (keycode == 'U') mouse.Mode=eModeInteract; //If you want something else to happen, such as GUI buttons highlighting,
if (keycode == 'T') mouse.Mode=eModeTalkto; //you'll need some more scripting done.
if (keycode == 'I') mouse.Mode=eModeUseinv; //But this will, as-is, give you some standard keyboard shortcuts your players will very much appreciate.
// For extra cursor modes, such as pick up, feel free to add as you will.
// Uncomment the line below if you use the "Pick Up" mode.
//if (keycode == 'P' || keycode == 'G') mouse.Mode=eModePickup;
// DEBUG FUNCTIONS
if (keycode == eKeyCtrlS) Debug(0,0); // Ctrl-S, give all inventory
if (keycode == eKeyCtrlV) Debug(1,0); // Ctrl-V, version
if (keycode == eKeyCtrlA) Debug(2,0); // Ctrl-A, show walkable areas
if (keycode == eKeyCtrlX) Debug(3,0); // Ctrl-X, teleport to room
if (keycode == eKeyCtrlW && game.debug_mode)
player.PlaceOnWalkableArea(); //Ctrl-W, move to walkable area
}
function on_mouse_click(MouseButton button) {
// called when a mouse button is clicked. button is either LEFT or RIGHT
if (IsGamePaused() == 1) {
// Game is paused, so do nothing (ie. don't allow mouse click)
}
else if (button == eMouseLeft) {
ProcessClick(mouse.x, mouse.y, mouse.Mode );
}
else if (button == eMouseRight || button == eMouseWheelSouth){
// right-click our mouse-wheel down, so cycle cursor
mouse.SelectNextMode();
}
else if (button == eMouseMiddle) {
// Middle-button-click, default make character walk to clicked area (a little shortcut)
// Could have been just "player.Walk(mouse.x,mouse.y)", but it's best to
// leave our options open - what if you have a special script triggered
// on "walking" mode?
ProcessClick(mouse.x, mouse.y, eModeWalkto);
}
else if (button == eMouseWheelNorth) {
// Mouse-wheel up, cycle cursors
// If mode isn't WALK, set the previous mode (notice usage of numbers instead
// of eNums, when it suits us)...
if (mouse.Mode>0) mouse.Mode=mouse.Mode-1;
else
{
// ...but if it is WALK mode...
if (player.ActiveInventory!=null)
{
//...and the player has a selected inventory item, set mouse mode to UseInv.
mouse.Mode=eModeUseinv;
}
else
{
// If they don't, however, just set it to mode TALK (change this line if you add more cursor modes)
mouse.Mode=eModeTalkto;
}
}
}
}
function interface_click(int interface, int button) {
// This function is obsolete, from 2.62 and earlier versions.
}
function btnInvUp_Click(GUIControl *control, MouseButton button) {
invCustomInv.ScrollUp();
}
function btnInvDown_Click(GUIControl *control, MouseButton button) {
invCustomInv.ScrollDown();
}
function btnInvOK_Click(GUIControl *control, MouseButton button) {
// They pressed the OK button, close the GUI
gInventory.Visible = false;
mouse.UseDefaultGraphic();
}
function btnInvSelect_Click(GUIControl *control, MouseButton button) {
// They pressed SELECT, so switch to the Get cursor
mouse.Mode = eModeInteract;
// But, override the appearance to look like the arrow
mouse.UseModeGraphic(eModePointer);
}
function btnIconInv_Click(GUIControl *control, MouseButton button) {
show_inventory_window();
}
function btnIconCurInv_Click(GUIControl *control, MouseButton button) {
if (player.ActiveInventory != null)
mouse.Mode = eModeUseinv;
}
function btnIconSave_Click(GUIControl *control, MouseButton button)
{
show_save_game_dialog();
}
function btnIconLoad_Click(GUIControl *control, MouseButton button)
{
show_restore_game_dialog();
}
function btnIconExit_Click(GUIControl *control, MouseButton button) {
QuitGame(1);
}
function btnIconAbout_Click(GUIControl *control, MouseButton button) {
gPanel.Visible=true;
gIconbar.Visible=false;
mouse.UseModeGraphic(eModePointer);
}
function cEgo_Look()
{
Display("Damn, I'm looking good!");
}
function cEgo_Interact()
{
Display("You rub your hands up and down your clothes.");
}
function cEgo_Talk()
{
Display("Talking to yourself is a sign of madness!");
}
//START OF CONTROL PANEL FUNCTIONS
function btnSave_OnClick(GUIControl *control, MouseButton button)
{
gPanel.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
Wait(1);
btnIconSave_Click(btnIconSave, eMouseLeft);
}
function gControl_OnClick(GUI *theGui, MouseButton button)
{
}
function btnAbout_OnClick(GUIControl *control, MouseButton button)
{
Display("Adventure Game Studio run-time engine default game.");
}
function btnQuit_OnClick(GUIControl *control, MouseButton button)
{
gPanel.Visible = false;
Wait(1);
QuitGame(1);
gPanel.Visible = true;
gIconbar.Visible = false;
mouse.UseModeGraphic(eModePointer);
}
function btnLoad_OnClick(GUIControl *control, MouseButton button)
{
gPanel.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
Wait(1);
btnIconLoad_Click(btnIconLoad, eMouseLeft);
}
function btnResume_OnClick(GUIControl *control, MouseButton button)
{
gPanel.Visible = false;
mouse.UseDefaultGraphic();
gIconbar.Visible = true;
}
function sldAudio_OnChange(GUIControl *control)
{
System.Volume = sldAudio.Value;
}
function sldVoice_OnChange(GUIControl *control)
{
// Sets voice volume. Note that we don't check for the existence of speech.vox -
// we did that in game_start, so if it's not there the slider won't even be available.
SetSpeechVolume(sldVoice.Value);
}
function btnVoice_OnClick(GUIControl *control, MouseButton button)
{
// Note that we don't check for the existence of speech.vox - we did that in game_start,
// so if it's not there the button won't even be available.
if (btnVoice.Text == "Voice and Text") {
SetVoiceMode(eSpeechVoiceOnly);
btnVoice.Text = "Voice only";
}
else if (btnVoice.Text == "Voice only") {
SetVoiceMode(eSpeechTextOnly);
btnVoice.Text = "Text only";
}
else if (btnVoice.Text == "Text only") {
SetVoiceMode(eSpeechVoiceAndText);
btnVoice.Text = "Voice and Text";
}
}
function sldGamma_OnChange(GUIControl *control)
{
// Set the gamma. Note there's no need to check for anything else, as we ensured,
// in game_start, that the slider won't even appear if it's not possible to do this.
System.Gamma = sldGamma.Value;
}
function btnDefault_OnClick(GUIControl *control, MouseButton button)
{
// Reset everything to default. You'll have to edit these as well as the sliders
// if you'd rather have different default parameters.
System.Volume = 100;
sldAudio.Value = System.Volume;
sldSpeed.Value = 40;
SetGameSpeed(40);
if (IsSpeechVoxAvailable()) {
SetVoiceMode(eSpeechVoiceAndText);
btnVoice.Text = "Voice and Text";
sldVoice.Value = 255;
SetSpeechVolume(255);
}
if (System.SupportsGammaControl) {
System.Gamma = 100;
sldGamma.Value = 100;
}
}
//END OF CONTROL PANEL FUNCTIONS
function dialog_request(int param)
{
// This is used by the dialog text parser if you need to process
// text that the player types in to the parser.
// It is not used by default.
}
function sldSpeed_OnChange(GUIControl *control)
{
SetGameSpeed(sldSpeed.Value);
}
function btnRestart_OnClick(GUIControl *control, MouseButton button)
{
gRestartYN.Visible=true;
gIconbar.Visible=false;
}
function btnRestartYes_OnClick(GUIControl *control, MouseButton button)
{
RestartGame();
}
function btnRestartNo_OnClick(GUIControl *control, MouseButton button)
{
gRestartYN.Visible = false;
gIconbar.Visible = true;
// If the panel's not ON, then the player must have gotten here by tapping F9,
// therefore his cursor needs restoring. If the panel IS on, then it doesn't,
// because it's already a pointer. Get used to thinking like this!!
if (!gPanel.Visible) mouse.UseDefaultGraphic();
}
function btnCancelSave_OnClick(GUIControl *control, MouseButton button)
{
close_save_game_dialog();
}
function btnSaveGame_OnClick(GUIControl *control, MouseButton button)
{
int gameSlotToSaveInto = lstSaveGamesList.ItemCount + 1;
int i = 0;
while (i < lstSaveGamesList.ItemCount)
{
if (lstSaveGamesList.Items[i] == txtNewSaveName.Text)
{
gameSlotToSaveInto = lstSaveGamesList.SaveGameSlots[i];
}
i++;
}
SaveGameSlot(gameSlotToSaveInto, txtNewSaveName.Text);
close_save_game_dialog();
}
function btnCancelRestore_OnClick(GUIControl *control, MouseButton button)
{
close_restore_game_dialog();
}
function btnRestoreGame_OnClick(GUIControl *control, MouseButton button)
{
if (lstRestoreGamesList.SelectedIndex >= 0)
{
RestoreGameSlot(lstRestoreGamesList.SaveGameSlots[lstRestoreGamesList.SelectedIndex]);
}
close_restore_game_dialog();
}
function lstSaveGamesList_OnSelectionCh(GUIControl *control)
{
txtNewSaveName.Text = lstSaveGamesList.Items[lstSaveGamesList.SelectedIndex];
}
function txtNewSaveName_OnActivate(GUIControl *control)
{
// Pressing return in the text box simulates clicking the Save button
btnSaveGame_OnClick(control, eMouseLeft);
}
function btnDeleteSave_OnClick(GUIControl *control, MouseButton button)
{
if (lstSaveGamesList.SelectedIndex >= 0)
{
DeleteSaveSlot(lstSaveGamesList.SaveGameSlots[lstSaveGamesList.SelectedIndex]);
lstSaveGamesList.FillSaveGameList();
}
}

View File

@@ -0,0 +1,4 @@
// Main header script - this will be included into every script in
// the game (local and global). Do not place functions here; rather,
// place import definitions and #define names here to be used by all
// scripts.

View File

@@ -0,0 +1,216 @@
// Main script for module 'KeyboardMovement'
//****************************************************************************************************
// DEFINITIONS
//****************************************************************************************************
#define DISTANCE 10000// distance player walks in Tapping mode before he stops
enum KeyboardMovement_Directions {
eKeyboardMovement_Stop,
eKeyboardMovement_DownLeft,
eKeyboardMovement_Down,
eKeyboardMovement_DownRight,
eKeyboardMovement_Left,
eKeyboardMovement_Right,
eKeyboardMovement_UpLeft,
eKeyboardMovement_Up,
eKeyboardMovement_UpRight
};
//****************************************************************************************************
// VARIABLES
//****************************************************************************************************
// keycodes as variables for future key customization functions (static variables?):
int KeyboardMovement_KeyDown = 380; // down arrow
int KeyboardMovement_KeyLeft = 375; // left arrow
int KeyboardMovement_KeyRight = 377; // right arrow
int KeyboardMovement_KeyUp = 372; // up arrow
int KeyboardMovement_KeyDownRight = 381; // PgDn (numpad)
int KeyboardMovement_KeyUpRight = 373; // PgUp (numpad)
int KeyboardMovement_KeyDownLeft = 379; // End (numpad)
int KeyboardMovement_KeyUpLeft = 371; // Home (numpad)
int KeyboardMovement_KeyStop = 376; // 5 (numpad)
KeyboardMovement_Modes KeyboardMovement_Mode = eKeyboardMovement_None; // stores current keyboard control mode (disabled by default)
KeyboardMovement_Directions KeyboardMovement_CurrentDirection = eKeyboardMovement_Stop; // stores current walking direction of player character
//****************************************************************************************************
// USER FUNCTIONS
//****************************************************************************************************
//====================================================================================================
static function KeyboardMovement::SetMode(KeyboardMovement_Modes mode) {
KeyboardMovement_Mode = mode;
}
//====================================================================================================
// key customization functions here
//====================================================================================================
//****************************************************************************************************
// EVENT HANDLER FUNCTIONS
//****************************************************************************************************
//====================================================================================================
function repeatedly_execute() {
//--------------------------------------------------
// Pressing mode
//--------------------------------------------------
if ((IsGamePaused() == true) || (KeyboardMovement_Mode != eKeyboardMovement_Pressing) || (IsInterfaceEnabled() == false) || (player.on == false)) return 0;
// if game is paused, module or mode disabled, interface disabled or player character hidden, quit function
KeyboardMovement_Directions newdirection; // declare variable storing new direction
// get new direction:
if ( ((IsKeyPressed(KeyboardMovement_KeyDown)) && (IsKeyPressed(KeyboardMovement_KeyRight))) || (IsKeyPressed(KeyboardMovement_KeyDownRight)) ) newdirection = eKeyboardMovement_DownRight; // if down&right arrows or PgDn (numeric pad) held down, set new direction to Down-Right
else if ( ((IsKeyPressed(KeyboardMovement_KeyUp)) && (IsKeyPressed(KeyboardMovement_KeyRight))) || (IsKeyPressed(KeyboardMovement_KeyUpRight)) ) newdirection = eKeyboardMovement_UpRight; // up&right arrows or PgUp (numpad)
else if ( ((IsKeyPressed(KeyboardMovement_KeyDown)) && (IsKeyPressed(KeyboardMovement_KeyLeft))) || (IsKeyPressed(KeyboardMovement_KeyDownLeft)) ) newdirection = eKeyboardMovement_DownLeft; // down&left arrows or End (numpad)
else if ( ((IsKeyPressed(KeyboardMovement_KeyUp)) && (IsKeyPressed(KeyboardMovement_KeyLeft))) || (IsKeyPressed(KeyboardMovement_KeyUpLeft)) ) newdirection = eKeyboardMovement_UpLeft; // up&left arrows or Home (numpad)
else if (IsKeyPressed(KeyboardMovement_KeyDown)) newdirection = eKeyboardMovement_Down; // down arrow
else if (IsKeyPressed(KeyboardMovement_KeyLeft)) newdirection = eKeyboardMovement_Left; // left arrow
else if (IsKeyPressed(KeyboardMovement_KeyRight)) newdirection = eKeyboardMovement_Right; // right arrow
else if (IsKeyPressed(KeyboardMovement_KeyUp)) newdirection = eKeyboardMovement_Up; // up arrow
else newdirection = eKeyboardMovement_Stop; // if none of the above held down, set it to stop player character
if (IsKeyPressed(KeyboardMovement_KeyStop)) newdirection = eKeyboardMovement_Stop; // if 5 (numeric pad) held down, stop player character, regardless of whether some of the above are held down
if (newdirection != KeyboardMovement_CurrentDirection) { // if new direction is different from current direction
if (newdirection == eKeyboardMovement_Stop) player.StopMoving(); // if new direction is the Stop command, stop movement of player character
else { // if new direction is NOT the Stop command
int dx, dy; // declare variables storing new walk coordinates
if (newdirection == eKeyboardMovement_DownRight) {
dx = DISTANCE;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_UpRight) {
dx = DISTANCE;
dy = -DISTANCE;
}
else if (newdirection == eKeyboardMovement_DownLeft) {
dx = -DISTANCE;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_UpLeft) {
dx = -DISTANCE;
dy = -DISTANCE;
}
else if (newdirection == eKeyboardMovement_Down) {
dx = 0;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_Left) {
dx = -DISTANCE;
dy = 0;
}
else if (newdirection == eKeyboardMovement_Right) {
dx = DISTANCE;
dy = 0;
}
else if (newdirection == eKeyboardMovement_Up) {
dx = 0;
dy = -DISTANCE;
}
player.WalkStraight(player.x + dx, player.y + dy, eNoBlock); // walk player character to the new coordinates
}
KeyboardMovement_CurrentDirection = newdirection; // update current direction to new direction
}
}
//====================================================================================================
function on_key_press(int keycode) {
//--------------------------------------------------
// Tapping mode
//--------------------------------------------------
if ((IsGamePaused() == true) || (KeyboardMovement_Mode != eKeyboardMovement_Tapping) || (IsInterfaceEnabled() == false) || (player.on == false)) return 0;
// if game is paused, module or mode disabled, interface disabled or player character hidden, quit function
KeyboardMovement_Directions newdirection; // declare variable storing new direction
// get new direction:
if (keycode == KeyboardMovement_KeyDownRight) newdirection = eKeyboardMovement_DownRight; // if down-right key pressed, set new direction to Down-Right
else if (keycode == KeyboardMovement_KeyUpRight) newdirection = eKeyboardMovement_UpRight;
else if (keycode == KeyboardMovement_KeyDownLeft) newdirection = eKeyboardMovement_DownLeft;
else if (keycode == KeyboardMovement_KeyUpLeft) newdirection = eKeyboardMovement_UpLeft;
else if (keycode == KeyboardMovement_KeyDown) newdirection = eKeyboardMovement_Down;
else if (keycode == KeyboardMovement_KeyLeft) newdirection = eKeyboardMovement_Left;
else if (keycode == KeyboardMovement_KeyRight) newdirection = eKeyboardMovement_Right;
else if (keycode == KeyboardMovement_KeyUp) newdirection = eKeyboardMovement_Up;
else if (keycode == KeyboardMovement_KeyStop) newdirection = eKeyboardMovement_Stop; // if stop key pressed, set to stop player character
if (newdirection != KeyboardMovement_CurrentDirection) { // if new direction is different from current direction
if (newdirection == eKeyboardMovement_Stop) player.StopMoving(); // if new direction is the Stop command, stop movement of player character
else { // if new direction is NOT the Stop command
int dx, dy; // declare variables storing new walk coordinates
if (newdirection == eKeyboardMovement_DownRight) {
dx = DISTANCE;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_UpRight) {
dx = DISTANCE;
dy = -DISTANCE;
}
else if (newdirection == eKeyboardMovement_DownLeft) {
dx = -DISTANCE;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_UpLeft) {
dx = -DISTANCE;
dy = -DISTANCE;
}
else if (newdirection == eKeyboardMovement_Down) {
dx = 0;
dy = DISTANCE;
}
else if (newdirection == eKeyboardMovement_Left) {
dx = -DISTANCE;
dy = 0;
}
else if (newdirection == eKeyboardMovement_Right) {
dx = DISTANCE;
dy = 0;
}
else if (newdirection == eKeyboardMovement_Up) {
dx = 0;
dy = -DISTANCE;
}
player.WalkStraight(player.x + dx, player.y + dy, eNoBlock); // walk player character to the new coordinates
}
KeyboardMovement_CurrentDirection = newdirection; // update current direction to new direction
}
else { // if new direction is same as current direction
player.StopMoving(); // stop player character
KeyboardMovement_CurrentDirection = eKeyboardMovement_Stop; // update current direction
}
}
//====================================================================================================
function on_event(EventType event, int data) {
if (event == eEventLeaveRoom) KeyboardMovement_CurrentDirection = eKeyboardMovement_Stop;
}
//====================================================================================================

View File

@@ -0,0 +1,13 @@
// Script header for module 'KeyboardMovement'
#define KeyboardMovement_VERSION 101
enum KeyboardMovement_Modes {
eKeyboardMovement_None,
eKeyboardMovement_Tapping,
eKeyboardMovement_Pressing
};
struct KeyboardMovement {
import static function SetMode(KeyboardMovement_Modes mode);
};

View File

@@ -0,0 +1,18 @@
⍝ You can try this at http://tryapl.org/
⍝ I can not explain how much I suddenly love this crypto-language
Starts 'Experiential truth ' 'The physical world ' 'Non-judgment ' 'Quantum physics '
Middles 'nurtures an ' 'projects onto ' 'imparts reality to ' 'constructs with '
Qualifiers 'abundance of ' 'the barrier of ' 'self-righteous ' 'potential '
Finishes 'marvel.' 'choices.' 'creativity.' 'actions.'
rf {(?)}
erf {rf ¨ }
deepak {erf Starts Middles Qualifiers Finishes}
deepak

350
samples/Assembly/FASM.asm Normal file
View File

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

View File

@@ -0,0 +1,25 @@
SuperStrict
Framework Brl.StandardIO
Type TMyType
Field property:int
Function A:int(param:int)
'do nothing
End Function
Method B:int(param:int)
'do nothing
End Method
End Type
Global my:TMyType = new TMyType
?Win32
my.A()
my.B()
?Linux
my.B()
my.A()
?

View File

@@ -1,13 +1,13 @@
doc "Test function for Ceylon"
by "Enrique"
"Test function for Ceylon"
by ("Enrique")
shared void test() {
print("test");
print("test");
}
doc "Test class for Ceylon"
"Test class for Ceylon"
shared class Test(name) satisfies Comparable<Test> {
shared String name;
shared actual String string = "Test " name ".";
shared actual String string = "Test ``name``.";
shared actual Comparison compare(Test other) {
return name<=>other.name;

View File

@@ -0,0 +1,304 @@
//
// Distributions Primer
//
// This primer demonstrates uses of some of Chapel's standard
// distributions. To use these distributions in a Chapel program,
// the respective module must be used:
//
use BlockDist, CyclicDist, BlockCycDist, ReplicatedDist;
use DimensionalDist2D, ReplicatedDim, BlockCycDim;
//
// For each distribution, we'll create a distributed domain and array
// and then initialize it just to give a brief flavor of how the
// distribution maps across locales. Running this example on 6
// locales does a nice job of illustrating the distribution
// characteristics.
//
// All of these distributions support options to map to a different
// virtual locale grid than the one used by default (a
// multidimensional factoring of the built-in Locales array), as well
// as to control the amount of parallelism used in data parallel
// loops. See the Standard Distributions chapter of the language spec
// for more details.
//
//
// Make the program size configurable from the command line.
//
config const n = 8;
//
// Declare a 2-dimensional domain Space that we will later use to
// initialize the distributed domains.
//
const Space = {1..n, 1..n};
//
// The Block distribution distributes a bounding box from
// n-dimensional space across the target locale array viewed as an
// n-dimensional virtual locale grid. The bounding box is blocked
// into roughly equal portions across the locales. Note that domains
// declared over a Block distribution can also store indices outside
// of the bounding box; the bounding box is merely used to compute
// the blocking of space.
//
// In this example, we declare a 2-dimensional Block-distributed
// domain BlockSpace and a Block-distributed array BA declared over
// the domain.
//
const BlockSpace = Space dmapped Block(boundingBox=Space);
var BA: [BlockSpace] int;
//
// To illustrate how the index set is distributed across locales,
// we'll use a forall loop to initialize each array element to the
// locale ID that stores that index/element/iteration.
//
forall ba in BA do
ba = here.id;
//
// Output the Block-distributed array to visually see how the elements
// are partitioned across the locales.
//
writeln("Block Array Index Map");
writeln(BA);
writeln();
//
// Most of Chapel's standard distributions support an optional
// targetLocales argument that permits you to pass in your own
// array of locales to be targeted. In general, the targetLocales
// argument should match the rank of the distribution. So for
// example, to map a Block to a [numLocales x 1] view of the
// locale set, one could do something like this:
//
// We start by creating our own array of the locale values. Here
// we use the standard array reshape function for convenience,
// but more generally, this array could be accessed/assigned like any
// other.
//
var MyLocaleView = {0..#numLocales, 1..1};
var MyLocales: [MyLocaleView] locale = reshape(Locales, MyLocaleView);
//
// Then we'll declare a distributed domain/array that targets
// this view of the locales:
//
const BlockSpace2 = Space dmapped Block(boundingBox=Space,
targetLocales=MyLocales);
var BA2: [BlockSpace2] int;
//
// Then we'll do a similar computation as before to verify where
// everything ended up:
//
forall ba in BA2 do
ba = here.id;
writeln("Block Array Index Map");
writeln(BA2);
writeln();
//
// Next, we'll perform a similar computation for the Cyclic distribution.
// Cyclic distributions start at a designated n-dimensional index and
// distribute the n-dimensional space across an n-dimensional array
// of locales in a round-robin fashion (in each dimension). As with
// the Block distribution, domains may be declared using the
// distribution who have lower indices that the starting index; that
// value should just be considered a parameterization of how the
// distribution is defined.
//
const CyclicSpace = Space dmapped Cyclic(startIdx=Space.low);
var CA: [CyclicSpace] int;
forall ca in CA do
ca = here.id;
writeln("Cyclic Array Index Map");
writeln(CA);
writeln();
//
// Next, we'll declare a Block-Cyclic distribution. These
// distributions also deal out indices in a round-robin fashion,
// but rather than dealing out singleton indices, they deal out blocks
// of indices. Thus, the BlockCyclic distribution is parameterized
// by a starting index (as with Cyclic) and a block size (per
// dimension) specifying how large the chunks to be dealt out are.
//
const BlkCycSpace = Space dmapped BlockCyclic(startIdx=Space.low,
blocksize=(2, 3));
var BCA: [BlkCycSpace] int;
forall bca in BCA do
bca = here.id;
writeln("Block-Cyclic Array Index Map");
writeln(BCA);
writeln();
//
// The ReplicatedDist distribution is different: each of the
// original domain's indices - and the corresponding array elements -
// is replicated onto each locale. (Note: consistency among these
// array replicands is NOT maintained automatically.)
//
// This replication is observable in some cases but not others,
// as shown below. Note: this behavior may change in the future.
//
const ReplicatedSpace = Space dmapped ReplicatedDist();
var RA: [ReplicatedSpace] int;
// The replication is observable - this visits each replicand.
forall ra in RA do
ra = here.id;
writeln("Replicated Array Index Map, ", RA.numElements, " elements total");
writeln(RA);
writeln();
//
// The replication is observable when the replicated array is
// on the left-hand side. If the right-hand side is not replicated,
// it is copied into each replicand.
// We illustrate this using a non-distributed array.
//
var A: [Space] int = [(i,j) in Space] i*100 + j;
RA = A;
writeln("Replicated Array after being array-assigned into");
writeln(RA);
writeln();
//
// Analogously, each replicand will be visited and
// other participated expressions will be computed on each locale
// (a) when the replicated array is assigned a scalar:
// RA = 5;
// (b) when it appears first in a zippered forall loop:
// forall (ra, a) in zip(RA, A) do ...;
// (c) when it appears in a for loop:
// for ra in RA do ...;
//
// Zippering (RA,A) or (A,RA) in a 'for' loop will generate
// an error due to their different number of elements.
// Let RA store the Index Map again, for the examples below.
forall ra in RA do
ra = here.id;
//
// Only the local replicand is accessed - replication is NOT observable
// and consistency is NOT maintained - when:
// (a) the replicated array is indexed - an individual element is read...
//
on Locales(0) do
writeln("on ", here, ": ", RA(Space.low));
on Locales(LocaleSpace.high) do
writeln("on ", here, ": ", RA(Space.low));
writeln();
// ...or an individual element is written;
on Locales(LocaleSpace.high) do
RA(Space.low) = 7777;
writeln("Replicated Array after being indexed into");
writeln(RA);
writeln();
//
// (b) the replicated array is on the right-hand side of an assignment...
//
on Locales(LocaleSpace.high) do
A = RA + 4;
writeln("Non-Replicated Array after assignment from Replicated Array + 4");
writeln(A);
writeln();
//
// (c) ...or, generally, the replicated array or domain participates
// in a zippered forall loop, but not in the first position.
// The loop could look like:
//
// forall (a, (i,j), ra) in (A, ReplicatedSpace, RA) do ...;
//
//
// The DimensionalDist2D distribution lets us build a 2D distribution
// as a composition of specifiers for individual dimensions.
// Under such a "dimensional" distribution each dimension is handled
// independently of the other.
//
// The dimension specifiers are similar to the corresponding multi-dimensional
// distributions in constructor arguments and index-to-locale mapping rules.
// However, instead of an array of locales, a specifier constructor
// accepts just the number of locales that the indices in the corresponding
// dimension will be distributed across.
//
// The DimensionalDist2D constructor requires:
// * an [0..nl1-1, 0..nl2-1] array of locales, where
// nl1 and nl2 are the number of locales in each dimension, and
// * two dimension specifiers, created for nl1 and nl2 locale counts, resp.
//
// Presently, the following dimension specifiers are available
// (shown here with their constructor arguments):
//
// * ReplicatedDim(numLocales)
// * BlockDim(numLocales, boundingBoxLow, boundingBoxHigh)
// * BlockCyclicDim(lowIdx, blockSize, numLocales)
//
//
// The following example creates a dimensional distribution that
// replicates over 2 locales (when available) in the first dimemsion
// and distributes using block-cyclic distribution in the second dimension.
// The example computes nl1 and nl2 and reshapes MyLocales correspondingly.
//
var (nl1, nl2) = if numLocales == 1 then (1, 1) else (2, numLocales/2);
MyLocaleView = {0..#nl1, 0..#nl2};
MyLocales = reshape(Locales[0..#nl1*nl2], MyLocaleView);
const DimReplicatedBlockcyclicSpace = Space
dmapped DimensionalDist2D(MyLocales,
new ReplicatedDim(numLocales = nl1),
new BlockCyclicDim(numLocales = nl2,
lowIdx = 1, blockSize = 2));
var DRBA: [DimReplicatedBlockcyclicSpace] int;
// The ReplicatedDim specifier always accesses the local replicand.
// (This differs from how the ReplicatedDist distribution works.)
//
// This example visits each replicand. The behavior is the same
// regardless of the second index into MyLocales below.
for locId1 in 0..#nl1 do on MyLocales[locId1, 0] {
forall drba in DRBA do
drba = here.id;
writeln("Dimensional2D(Replicated,BlockCyclic) Array Index Map",
" from ", here);
// Technicality: 'writeln(DRBA)' would read DRBA always on Locale 0.
// Since we want to see what DRBA contains on the current locale,
// we use 'Helper' that is mapped using the default distribution.
// 'Helper = DRBA' captures the view of DRBA on the current locale,
// which we then print out.
const Helper: [Space] int = DRBA;
writeln(Helper);
writeln();
}

View File

@@ -0,0 +1 @@
writeln("Hello, world!"); // print 'Hello, world!' to the console

1692
samples/Chapel/lulesh.chpl Normal file

File diff suppressed because it is too large Load Diff

147
samples/Chapel/nbody.chpl Normal file
View File

@@ -0,0 +1,147 @@
/* The Computer Language Benchmarks Game
http://benchmarksgame.alioth.debian.org/
contributed by Albert Sidelnik
modified by Brad Chamberlain
*/
//
// The number of timesteps to simulate; may be set via the command-line
//
config const n = 10000;
//
// Constants representing pi, the solar mass, and the number of days per year
//
const pi = 3.141592653589793,
solarMass = 4 * pi**2,
daysPerYear = 365.24;
//
// a record representing one of the bodies in the solar system
//
record body {
var pos: 3*real;
var v: 3*real;
var mass: real; // does not change after it is set up
}
//
// the array of bodies that we'll be simulating
//
var bodies = [/* sun */
new body(mass = solarMass),
/* jupiter */
new body(pos = ( 4.84143144246472090e+00,
-1.16032004402742839e+00,
-1.03622044471123109e-01),
v = ( 1.66007664274403694e-03 * daysPerYear,
7.69901118419740425e-03 * daysPerYear,
-6.90460016972063023e-05 * daysPerYear),
mass = 9.54791938424326609e-04 * solarMass),
/* saturn */
new body(pos = ( 8.34336671824457987e+00,
4.12479856412430479e+00,
-4.03523417114321381e-01),
v = (-2.76742510726862411e-03 * daysPerYear,
4.99852801234917238e-03 * daysPerYear,
2.30417297573763929e-05 * daysPerYear),
mass = 2.85885980666130812e-04 * solarMass),
/* uranus */
new body(pos = ( 1.28943695621391310e+01,
-1.51111514016986312e+01,
-2.23307578892655734e-01),
v = ( 2.96460137564761618e-03 * daysPerYear,
2.37847173959480950e-03 * daysPerYear,
-2.96589568540237556e-05 * daysPerYear),
mass = 4.36624404335156298e-05 * solarMass),
/* neptune */
new body(pos = ( 1.53796971148509165e+01,
-2.59193146099879641e+01,
1.79258772950371181e-01),
v = ( 2.68067772490389322e-03 * daysPerYear,
1.62824170038242295e-03 * daysPerYear,
-9.51592254519715870e-05 * daysPerYear),
mass = 5.15138902046611451e-05 * solarMass)
];
//
// the number of bodies to be simulated
//
const numbodies = bodies.numElements;
//
// The computation involves initializing the sun's velocity,
// writing the initial energy, advancing the system through 'n'
// timesteps, and writing the final energy.
//
proc main() {
initSun();
writef("%.9r\n", energy());
for 1..n do
advance(0.01);
writef("%.9r\n", energy());
}
//
// compute the sun's initial velocity
//
proc initSun() {
const p = + reduce (for b in bodies do (b.v * b.mass));
bodies[1].v = -p / solarMass;
}
//
// advance the positions and velocities of all the bodies
//
proc advance(dt) {
for i in 1..numbodies {
for j in i+1..numbodies {
updateVelocities(bodies[i], bodies[j]);
inline proc updateVelocities(ref b1, ref b2) {
const dpos = b1.pos - b2.pos,
mag = dt / sqrt(sumOfSquares(dpos))**3;
b1.v -= dpos * b2.mass * mag;
b2.v += dpos * b1.mass * mag;
}
}
}
for b in bodies do
b.pos += dt * b.v;
}
//
// compute the energy of the bodies
//
proc energy() {
var e = 0.0;
for i in 1..numbodies {
const b1 = bodies[i];
e += 0.5 * b1.mass * sumOfSquares(b1.v);
for j in i+1..numbodies {
const b2 = bodies[j];
e -= (b1.mass * b2.mass) / sqrt(sumOfSquares(b1.pos - b2.pos));
}
}
return e;
}
//
// a helper routine to compute the sum of squares of a 3-tuple's components
//
inline proc sumOfSquares(x)
return x(1)**2 + x(2)**2 + x(3)**2;

View File

@@ -0,0 +1,145 @@
//
// An example of a parallel quick sort implementation that uses
// "cobegin" to make each recursive call in parallel and "serial" to
// limit the number of threads.
//
use Random, Time; // for random number generation and the Timer class
var timer: Timer; // to time the sort
config var n: int = 2**15; // the size of the array to be sorted
config var thresh: int = 1; // the recursive depth to serialize
config var verbose: int = 0; // print out this many elements in array
config var timing: bool = true; // set timing to false to disable timer
var A: [1..n] real; // array of real numbers
//
// initialize array with random numbers
//
fillRandom(A);
//
// print out front of array if verbose flag is set
//
if verbose > 0 then
writeln("A[1..", verbose, "] = ", A[1..verbose]);
//
// start timer, call parallel quick sort routine, stop timer
//
if timing then timer.start();
pqsort(A, thresh);
if timing then timer.stop();
//
// report sort time
//
if timing then writeln("sorted in ", timer.elapsed(), " seconds");
//
// print out front of array if verbose flag is set
// values should now be in sorted order
//
if verbose > 0 then
writeln("A[1..", verbose, "] = ", A[1..verbose]);
//
// verify that array is sorted or halt
//
for i in 2..n do
if A(i) < A(i-1) then
halt("A(", i-1, ") == ", A(i-1), " > A(", i, ") == ", A(i));
writeln("verification success");
//
// pqsort -- parallel quick sort
//
// arr: generic 1D array of values (real, int, ...)
// thresh: number of recursive calls to make before serializing
// low: lower bound of array to start sort at, defaults to whole array
// high: upper bound of array to stop sort at, defaults to whole array
//
proc pqsort(arr: [],
thresh: int,
low: int = arr.domain.low,
high: int = arr.domain.high) where arr.rank == 1 {
//
// base case: arr[low..high] is small enough to bubble sort
//
if high - low < 8 {
bubbleSort(arr, low, high);
return;
}
//
// determine pivot and partition arr[low..high]
//
const pivotVal = findPivot();
const pivotLoc = partition(pivotVal);
//
// make recursive calls to parallel quick sort each unsorted half of
// the array; if thresh is 0 or less, start executing conquer tasks
// serially
//
serial thresh <= 0 do cobegin {
pqsort(arr, thresh-1, low, pivotLoc-1);
pqsort(arr, thresh-1, pivotLoc+1, high);
}
//
// findPivot -- helper routine to find pivot value using simple
// median-of-3 method, returns pivot value
//
proc findPivot() {
const mid = low + (high-low+1) / 2;
if arr(mid) < arr(low) then arr(mid) <=> arr(low);
if arr(high) < arr(low) then arr(high) <=> arr(low);
if arr(high) < arr(mid) then arr(high) <=> arr(mid);
const pivotVal = arr(mid);
arr(mid) = arr(high-1);
arr(high-1) = pivotVal;
return pivotVal;
}
//
// partition -- helper routine to partition array such that all
// values less than pivot are to its left and all
// values greater than pivot are to its right, returns
// pivot location
//
proc partition(pivotVal) {
var ilo = low, ihi = high-1;
while (ilo < ihi) {
do { ilo += 1; } while arr(ilo) < pivotVal;
do { ihi -= 1; } while pivotVal < arr(ihi);
if (ilo < ihi) {
arr(ilo) <=> arr(ihi);
}
}
arr(high-1) = arr(ilo);
arr(ilo) = pivotVal;
return ilo;
}
}
//
// bubbleSort -- bubble sort for base case of quick sort
//
// arr: generic 1D array of values (real, int, ...)
// low: lower bound of array to start sort at
// high: upper bound of array to stop sort at
//
proc bubbleSort(arr: [], low: int, high: int) where arr.rank == 1 {
for i in low..high do
for j in low..high-1 do
if arr(j) > arr(j+1) then
arr(j) <=> arr(j+1);
}

11
samples/Clean/GenHylo.dcl Normal file
View File

@@ -0,0 +1,11 @@
definition module GenHylo
import StdGeneric, GenMap
:: Fix f = In (f .(Fix f))
Out :: !u:(Fix v:a) -> v:(a w:(Fix v:a)), [u <= w]
hylo :: ((.f .b) -> .b) (.a -> (.f .a)) -> (.a -> .b) | gMap{|*->*|} f
cata :: (u:(f .a) -> .a) -> (Fix u:f) -> .a | gMap{|*->*|} f
ana :: (.a -> u:(f .a)) -> .a -> (Fix u:f) | gMap{|*->*|} f

9
samples/Clean/GenMap.dcl Normal file
View File

@@ -0,0 +1,9 @@
definition module GenMap
import StdGeneric
generic gMap a b :: .a -> .b
derive gMap c, UNIT, PAIR, EITHER, CONS, FIELD, OBJECT, {}, {!}
derive gMap [], (,), (,,), (,,,), (,,,,), (,,,,,), (,,,,,,), (,,,,,,,)

19
samples/Clean/GenMap.icl Normal file
View File

@@ -0,0 +1,19 @@
implementation module GenMap
import StdClass, StdArray, StdInt, StdFunc
import StdGeneric, _Array
generic gMap a b :: .a -> .b
gMap{|c|} x = x
gMap{|UNIT|} x = x
gMap{|PAIR|} fx fy (PAIR x y) = PAIR (fx x) (fy y)
gMap{|EITHER|} fl fr (LEFT x) = LEFT (fl x)
gMap{|EITHER|} fl fr (RIGHT x) = RIGHT (fr x)
gMap{|CONS|} f (CONS x) = CONS (f x)
gMap{|FIELD|} f (FIELD x) = FIELD (f x)
gMap{|OBJECT|} f (OBJECT x) = OBJECT (f x)
gMap{|{}|} f xs = mapArray f xs
gMap{|{!}|} f xs = mapArray f xs
derive gMap [], (,), (,,), (,,,), (,,,,), (,,,,,), (,,,,,,), (,,,,,,,)

54
samples/Clean/fsieve.icl Normal file
View File

@@ -0,0 +1,54 @@
module fsieve
/*
The Fast Sieve of Eratosthenes.
A sequential and optimized version of the sieve of Eratosthenes.
The program calculates a list of the first NrOfPrime primes.
The result of the program is the NrOfPrimes'th prime.
Strictness annotations have been added because the strictness analyser
is not able to deduce all strictness information. Removal of these !'s
will make the program about 20% slower.
On a machine without a math coprocessor the execution of this
program might take a (very) long time. Set NrOfPrimes to a smaller value.
*/
import StdClass; // RWS
import StdInt, StdReal
NrOfPrimes :== 3000
// The sieve algorithm: generate an infinite list of all primes.
Primes::[Int]
Primes = pr where pr = [5 : Sieve 7 4 pr]
Sieve::Int !Int [Int] -> [Int]
Sieve g i prs
| IsPrime prs g (toInt (sqrt (toReal g))) = [g : Sieve` g i prs]
= Sieve (g + i) (6 - i) prs
Sieve`::Int Int [Int] -> [Int]
Sieve` g i prs = Sieve (g + i) (6 - i) prs
IsPrime::[Int] !Int Int -> Bool
IsPrime [f:r] pr bd | f>bd = True
| pr rem f==0 = False
= IsPrime r pr bd
// Select is used to get the NrOfPrimes'th prime from the infinite list.
Select::[x] Int -> x
Select [f:r] 1 = f
Select [f:r] n = Select r (n - 1)
/* The Start rule: Select the NrOfPrimes'th prime from the list of primes
generated by Primes.
*/
Start::Int
Start = Select [2, 3 : Primes] NrOfPrimes

99
samples/Clean/sem.icl Normal file
View File

@@ -0,0 +1,99 @@
module monadicSemantics
import StdEnv, StdGeneric, GenMap, GenHylo
/* For fun I implemented the recursive datastructre Exp and Stm as fixpoints
This helps us define recursive functions on them (only a little bit though)
However deriving gMap for Fix did not works out of the box
I had to remove some uniqueness typing in GenMap and GenHylo */
:: Op = Plus | Minus | Times | Rem | Equal | LessThan
:: Var :== String
:: ExpP a = Int Int | Var Var | Op Op a a
:: Exp :== Fix ExpP
:: StmP a = Assign Var Exp | If Exp a a | While Exp a | Seq a a | Cont
:: Stm :== Fix StmP
derive gMap ExpP, StmP, Fix
// Environment. Semantics is basically Env -> Env
:: Env :== Var -> Int
:: Sem :== Env -> (Int, Env)
empty = \v . 0
// return
rtn :: Int -> Sem
rtn i = \e. (i, e)
// the usual bind
(>>=) infixl 1 :: Sem (Int->Sem) -> Sem
(>>=) x y = \e. (\(i,e2).y i e2) (x e)
(>>|) infixl 1 :: Sem Sem -> Sem
(>>|) x y = x >>= \_. y
// read variable from environment
read :: Var -> Sem
read v = \e. (e v, e)
// assign value to give variable in environment
write :: Var Int -> Sem
write v i = \e. (i, \w. if (w==v) i (e w))
// semantics
class sem a :: a -> Sem
operator :: Op -> Int -> Int -> Int
operator Plus = (+)
operator Minus = (-)
operator Times = (*)
operator Rem = rem
operator Equal = \x y . if (x==y) 1 0
operator LessThan = \x y . if (x< y) 1 0
// semantics of expressions
instance sem Exp where
sem x = cata phi x where
phi (Int n) = rtn n
phi (Var v) = read v
phi (Op op x y) = x >>= \v1. y >>= return o (operator op v1)
// semantics of statments
// NOTE: while will always return 0, as it might not even be executed
instance sem Stm where
sem x = cata phi x where
phi (Assign v e) = sem e >>= write v
phi (If e s1 s2) = sem e >>= \b . if (b<>0) s1 s2
phi stm=:(While e s) = sem e >>= \b . if (b<>0) (s >>| phi stm) (phi Cont)
phi (Seq s1 s2) = s1 >>| s2 // Here the cata *finally* pays off :D
phi Cont = rtn 0
// convenience functions
int = In o Int
var = In o Var
op o = In o2 (Op o)
assign = In o2 Assign
ifte e = In o2 (If e)
while = In o2 While
seq = In o2 Seq
cont = In Cont
// test case, also testing the new operator <
pEuclides =
while (op LessThan (int 0) (var "b"))(
seq (assign "r" (op Rem (var "a") (var "b")))
(seq (assign "a" (var "b"))
( (assign "b" (var "r")))
)
)
Start = fst (program start) where
program = sem pEuclides >>| read "a"
start "a" = 9
start "b" = 12
start _ = 0
// Helper
(o2) infixr 9
(o2) f g x :== f o (g x)

14
samples/Clean/stack.dcl Normal file
View File

@@ -0,0 +1,14 @@
definition module stack
:: Stack a
newStack :: (Stack a)
push :: a (Stack a) -> Stack a
pushes :: [a] (Stack a) -> Stack a
pop :: (Stack a) -> Stack a
popn :: Int (Stack a) -> Stack a
top :: (Stack a) -> a
topn :: Int (Stack a) -> [a]
elements :: (Stack a) -> [a]
count :: (Stack a) -> Int

33
samples/Clean/stack.icl Normal file
View File

@@ -0,0 +1,33 @@
implementation module stack
import StdEnv
:: Stack a :== [a]
newStack :: (Stack a)
newStack = []
push :: a (Stack a) -> Stack a
push x s = [x:s]
pushes :: [a] (Stack a) -> Stack a
pushes x s = x ++ s
pop :: (Stack a) -> Stack a
pop [] = abort "Cannot use pop on an empty stack"
pop [e:s] = s
popn :: Int (Stack a) -> Stack a
popn n s = drop n s
top :: (Stack a) -> a
top [] = abort "Cannot use top on an empty stack"
top [e:s] = e
topn :: Int (Stack a) -> [a]
topn n s = take n s
elements :: (Stack a) -> [a]
elements s = s
count :: (Stack a) -> Int
count s = length s

16
samples/Clean/streams.dcl Normal file
View File

@@ -0,0 +1,16 @@
definition module streams
import StdEnv
instance zero [Real]
instance one [Real]
instance + [Real]
instance - [Real]
instance * [Real]
instance / [Real]
X :: [Real]
invert :: [Real] -> [Real]
pow :: [Real] Int -> [Real]
(shuffle) infixl 7 :: [Real] [Real] -> [Real]

49
samples/Clean/streams.icl Normal file
View File

@@ -0,0 +1,49 @@
implementation module streams
import StdEnv
instance zero [Real]
where
zero = [] //Infinite row of zeroes represented as empty list to ease computation
instance one [Real]
where
one = [1.0:zero]
instance + [Real]
where
(+) [s:s`] [t:t`] = [s+t:s`+t`]
(+) [s:s`] [] = [s:s`]
(+) [] [t:t`] = [t:t`]
(+) [] [] = []
instance - [Real]
where
(-) [s:s`] [t:t`] = [s-t:s`-t`]
(-) [s:s`] [] = [s:s`]
(-) [] [t:t`] = [-1.0] * [t:t`]
(-) [] [] = []
instance * [Real]
where
(*) [s:s`] [t:t`] = [s*t:s`*[t:t`]+[s]*t`]
(*) _ _ = []
instance / [Real]
where
(/) s t = s * (invert t)
X :: [Real]
X = [0.0:one]
invert :: [Real] -> [Real]
invert [s:s`] = [1.0/s:(invert [s:s`]) * s` * [-1.0/s]]
pow :: [Real] Int -> [Real]
pow s 0 = one
pow s n = s * pow s (n-1)
(shuffle) infixl 7 :: [Real] [Real] -> [Real]
(shuffle) [s:s`] [t:t`] = [s*t:s` shuffle [t:t`] + [s:s`] shuffle t`]
(shuffle) _ _ = []

View File

@@ -0,0 +1,146 @@
;; Copyright (c) Alan Dipert and Micha Niskin. All rights reserved.
;; The use and distribution terms for this software are covered by the
;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;; which can be found in the file epl-v10.html at the root of this distribution.
;; By using this software in any fashion, you are agreeing to be bound by
;; the terms of this license.
;; You must not remove this notice, or any other, from this software.
(page "index.html"
(:refer-clojure :exclude [nth])
(:require
[tailrecursion.hoplon.reload :refer [reload-all]]
[tailrecursion.hoplon.util :refer [nth name pluralize]]
[tailrecursion.hoplon.storage-atom :refer [local-storage]]))
;; utility functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(declare route state editing)
(reload-all)
(def mapvi (comp vec map-indexed))
(defn dissocv [v i]
(let [z (- (dec (count v)) i)]
(cond (neg? z) v
(zero? z) (pop v)
(pos? z) (into (subvec v 0 i) (subvec v (inc i))))))
(defn decorate [todo route editing i]
(let [{done? :completed text :text} todo]
(-> todo (assoc :editing (= editing i)
:visible (and (not (empty? text))
(or (= "#/" route)
(and (= "#/active" route) (not done?))
(and (= "#/completed" route) done?)))))))
;; persisted state cell (AKA: stem cell) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(def state (-> (cell []) (local-storage ::store)))
;; local state cells ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defc loaded? false)
(defc editing nil)
(def route (route-cell "#/"))
;; formula cells (computed state) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defc= completed (filter :completed state))
(defc= active (remove :completed state))
(defc= plural-item (pluralize "item" (count active)))
(defc= todos (mapvi #(list %1 (decorate %2 route editing %1)) state))
;; state transition functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defn todo [t] {:completed false :text t})
(defn destroy! [i] (swap! state dissocv i))
(defn done! [i v] (swap! state assoc-in [i :completed] v))
(defn clear-done! [& _] (swap! state #(vec (remove :completed %))))
(defn new! [t] (when (not (empty? t)) (swap! state conj (todo t))))
(defn all-done! [v] (swap! state #(mapv (fn [x] (assoc x :completed v)) %)))
(defn editing! [i v] (reset! editing (if v i nil)))
(defn text! [i v] (if (empty? v) (destroy! i) (swap! state assoc-in [i :text] v)))
;; page ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(html :lang "en"
(head
(meta :charset "utf-8")
(meta :http-equiv "X-UA-Compatible" :content "IE=edge,chrome=1")
(link :rel "stylesheet" :href "base.css")
(title "Hoplon • TodoMVC"))
(body
(noscript
(div :id "noscript"
(p "JavaScript is required to view this page.")))
(div
(section :id "todoapp"
(header :id "header"
(h1 "todos")
(form :on-submit #(do (new! (val-id :new-todo))
(do! (by-id :new-todo) :value ""))
(input
:id "new-todo"
:type "text"
:autofocus true
:placeholder "What needs to be done?"
:on-blur #(do! (by-id :new-todo) :value ""))))
(section
:id "main"
:do-toggle (cell= (not (and (empty? active) (empty? completed))))
(input
:id "toggle-all"
:type "checkbox"
:do-attr (cell= {:checked (empty? active)})
:on-click #(all-done! (val-id :toggle-all)))
(label :for "toggle-all"
"Mark all as complete")
(ul :id "todo-list"
(loop-tpl
:reverse true
:bind-ids [done# edit#]
:bindings [[i {edit? :editing done? :completed todo-text :text show? :visible}] todos]
(li
:do-class (cell= {:completed done? :editing edit?})
:do-toggle show?
(div :class "view" :on-dblclick #(editing! @i true)
(input
:id done#
:type "checkbox"
:class "toggle"
:do-attr (cell= {:checked done?})
:on-click #(done! @i (val-id done#)))
(label (text "~{todo-text}"))
(button
:type "submit"
:class "destroy"
:on-click #(destroy! @i)))
(form :on-submit #(editing! @i false)
(input
:id edit#
:type "text"
:class "edit"
:do-value todo-text
:do-focus edit?
:on-blur #(when @edit? (editing! @i false))
:on-change #(when @edit? (text! @i (val-id edit#)))))))))
(footer
:id "footer"
:do-toggle (cell= (not (and (empty? active) (empty? completed))))
(span :id "todo-count"
(strong (text "~(count active) "))
(span (text "~{plural-item} left")))
(ul :id "filters"
(li (a :href "#/" :do-class (cell= {:selected (= "#/" route)}) "All"))
(li (a :href "#/active" :do-class (cell= {:selected (= "#/active" route)}) "Active"))
(li (a :href "#/completed" :do-class (cell= {:selected (= "#/completed" route)}) "Completed")))
(button
:type "submit"
:id "clear-completed"
:on-click #(clear-done!)
(text "Clear completed (~(count completed))"))))
(footer :id "info"
(p "Double-click to edit a todo")
(p "Part of " (a :href "http://github.com/tailrecursion/hoplon-demos/" "hoplon-demos"))))))

View File

@@ -0,0 +1,239 @@
/**
********************************************************************************
ContentBox - A Modular Content Platform
Copyright 2012 by Luis Majano and Ortus Solutions, Corp
www.gocontentbox.org | www.luismajano.com | www.ortussolutions.com
********************************************************************************
Apache License, Version 2.0
Copyright Since [2012] [Luis Majano and Ortus Solutions,Corp]
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.
********************************************************************************
* A generic content service for content objects
*/
component extends="coldbox.system.orm.hibernate.VirtualEntityService" singleton{
// DI
property name="settingService" inject="id:settingService@cb";
property name="cacheBox" inject="cachebox";
property name="log" inject="logbox:logger:{this}";
property name="customFieldService" inject="customFieldService@cb";
property name="categoryService" inject="categoryService@cb";
property name="commentService" inject="commentService@cb";
property name="contentVersionService" inject="contentVersionService@cb";
property name="authorService" inject="authorService@cb";
property name="populator" inject="wirebox:populator";
property name="systemUtil" inject="SystemUtil@cb";
/*
* Constructor
* @entityName.hint The content entity name to bind this service to.
*/
ContentService function init(entityName="cbContent"){
// init it
super.init(entityName=arguments.entityName, useQueryCaching=true);
// Test scope coloring in pygments
this.colorTestVar = "Just for testing pygments!";
cookie.colorTestVar = "";
client.colorTestVar = ""
session.colorTestVar = "";
application.colorTestVar = "";
return this;
}
/**
* Clear all content caches
* @async.hint Run it asynchronously or not, defaults to false
*/
function clearAllCaches(boolean async=false){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clearByKeySnippet(keySnippet="cb-content",async=arguments.async);
return this;
}
/**
* Clear all page wrapper caches
* @async.hint Run it asynchronously or not, defaults to false
*/
function clearAllPageWrapperCaches(boolean async=false){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper",async=arguments.async);
return this;
}
/**
* Clear all page wrapper caches
* @slug.hint The slug partial to clean on
* @async.hint Run it asynchronously or not, defaults to false
*/
function clearPageWrapperCaches(required any slug, boolean async=false){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper-#arguments.slug#",async=arguments.async);
return this;
}
/**
* Clear a page wrapper cache
* @slug.hint The slug to clean
* @async.hint Run it asynchronously or not, defaults to false
*/
function clearPageWrapper(required any slug, boolean async=false){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clear("cb-content-pagewrapper-#arguments.slug#/");
return this;
}
/**
* Searches published content with cool paramters, remember published content only
* @searchTerm.hint The search term to search
* @max.hint The maximum number of records to paginate
* @offset.hint The offset in the pagination
* @asQuery.hint Return as query or array of objects, defaults to array of objects
* @sortOrder.hint The sorting of the search results, defaults to publishedDate DESC
* @isPublished.hint Search for published, non-published or both content objects [true, false, 'all']
* @searchActiveContent.hint Search only content titles or both title and active content. Defaults to both.
*/
function searchContent(
any searchTerm="",
numeric max=0,
numeric offset=0,
boolean asQuery=false,
any sortOrder="publishedDate DESC",
any isPublished=true,
boolean searchActiveContent=true){
var results = {};
var c = newCriteria();
// only published content
if( isBoolean( arguments.isPublished ) ){
// Published bit
c.isEq( "isPublished", javaCast( "Boolean", arguments.isPublished ) );
// Published eq true evaluate other params
if( arguments.isPublished ){
c.isLt("publishedDate", now() )
.$or( c.restrictions.isNull("expireDate"), c.restrictions.isGT("expireDate", now() ) )
.isEq("passwordProtection","");
}
}
// Search Criteria
if( len( arguments.searchTerm ) ){
// like disjunctions
c.createAlias("activeContent","ac");
// Do we search title and active content or just title?
if( arguments.searchActiveContent ){
c.$or( c.restrictions.like("title","%#arguments.searchTerm#%"),
c.restrictions.like("ac.content", "%#arguments.searchTerm#%") );
}
else{
c.like( "title", "%#arguments.searchTerm#%" );
}
}
// run criteria query and projections count
results.count = c.count( "contentID" );
results.content = c.resultTransformer( c.DISTINCT_ROOT_ENTITY )
.list(offset=arguments.offset, max=arguments.max, sortOrder=arguments.sortOrder, asQuery=arguments.asQuery);
return results;
}
/********************************************* PRIVATE *********************************************/
/**
* Update the content hits
* @contentID.hint The content id to update
*/
private function syncUpdateHits(required contentID){
var q = new Query(sql="UPDATE cb_content SET hits = hits + 1 WHERE contentID = #arguments.contentID#").execute();
return this;
}
private function closureTest(){
methodCall(
param1,
function( arg1, required arg2 ){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clear("cb-content-pagewrapper-#arguments.slug#/");
return this;
},
param1
);
}
private function StructliteralTest(){
return {
foo = bar,
brad = 'Wood',
func = function( arg1, required arg2 ){
var settings = settingService.getAllSettings(asStruct=true);
// Get appropriate cache provider
var cache = cacheBox.getCache( settings.cb_content_cacheName );
cache.clear("cb-content-pagewrapper-#arguments.slug#/");
return this;
},
array = [
1,
2,
3,
4,
5,
'test',
'testing',
'testerton',
{
foo = true,
brad = false,
wood = null
}
],
last = "final"
};
}
private function arrayliteralTest(){
return [
1,
2,
3,
4,
5,
'test',
'testing',
'testerton',
{
foo = true,
brad = false,
wood = null
},
'testy-von-testavich'
];
}
}

View File

@@ -0,0 +1,18 @@
<cfcomponent>
<cffunction name="init" access="public" returntype="any">
<cfargument name="arg1" type="any" required="true">
<cfset this.myVariable = arguments.arg1>
<cfreturn this>
</cffunction>
<cffunction name="testFunc" access="private" returntype="void">
<cfargument name="arg1" type="any" required="false">
<cfif structKeyExists(arguments, "arg1")>
<cfset writeoutput("Argument exists")>
</cfif>
</cffunction>
</cfcomponent>

View File

@@ -0,0 +1,50 @@
<!--- cfcomment --->
<!--- nested <!--- cfcomment ---> --->
<!--- multi-line
nested
<!---
cfcomment
--->
--->
<!-- html comment -->
<html>
<head>
<title>Date Functions</title>
</head>
<body>
<cfset RightNow = Now()>
<cfoutput>
#RightNow#<br />
#DateFormat(RightNow)#<br />
#DateFormat(RightNow,"mm/dd/yy")#<br />
#TimeFormat(RightNow)#<br />
#TimeFormat(RightNow,"hh:mm tt")#<br />
#IsDate(RightNow)#<br />
#IsDate("January 31, 2007")#<br />
#IsDate("foo")#<br />
#DaysInMonth(RightNow)#
</cfoutput>
<cfset x="x">
<cfset y="y">
<cfset z="z">
<cfoutput group="x">
#x#
<cfoutput>#y#</cfoutput>
#z#
</cfoutput>
</body>
</html>
<cfset person = "Paul">
<cfset greeting = "Hello #person#">
<cfset greeting = "Hello" & " world!">
<cfset a = 5>
<cfset b = 10>
<cfset c = a^b>
<cfset c = a MOD b>
<cfset c = a / b>
<cfset c = a * b>
<cfset c = a + b>
<cfset c = a - b>
<!--- <!-- another <!--- nested --> ---> comment --->

580
samples/Cycript/utils.cy Normal file
View File

@@ -0,0 +1,580 @@
(function(utils) {
// Load C functions declared in utils.loadFuncs
var shouldLoadCFuncs = true;
// Expose the C functions to cycript's global scope
var shouldExposeCFuncs = true;
// Expose C constants to cycript's global scope
var shouldExposeConsts = true;
// Expose functions defined here to cycript's global scope
var shouldExposeFuncs = true;
// Which functions to expose
var funcsToExpose = ["exec", "include", "sizeof", "logify", "apply", "str2voidPtr", "voidPtr2str", "double2voidPtr", "voidPtr2double", "isMemoryReadable", "isObject", "makeStruct"];
// C functions that utils.loadFuncs loads
var CFuncsDeclarations = [
// <stdlib.h>
"void *calloc(size_t num, size_t size)",
// <string.h>
"char *strcpy(char *restrict dst, const char *restrict src)",
"char *strdup(const char *s1)",
"void* memset(void* dest, int ch, size_t count)",
// <stdio.h>
"FILE *fopen(const char *, const char *)",
"int fclose(FILE *)",
"size_t fread(void *restrict, size_t, size_t, FILE *restrict)",
"size_t fwrite(const void *restrict, size_t, size_t, FILE *restrict)",
// <mach.h>
"mach_port_t mach_task_self()",
"kern_return_t task_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *tn)",
"kern_return_t mach_vm_protect(vm_map_t target_task, mach_vm_address_t address, mach_vm_size_t size, boolean_t set_maximum, vm_prot_t new_protection)",
"kern_return_t mach_vm_write(vm_map_t target_task, mach_vm_address_t address, vm_offset_t data, mach_msg_type_number_t dataCnt)",
"kern_return_t mach_vm_read(vm_map_t target_task, mach_vm_address_t address, mach_vm_size_t size, vm_offset_t *data, mach_msg_type_number_t *dataCnt)",
];
/*
Replacement for eval that can handle @encode etc.
Usage:
cy# utils.exec("@encode(void *(int, char))")
@encode(void*(int,char))
*/
utils.exec = function(str) {
var mkdir = @encode(int (const char *, int))(dlsym(RTLD_DEFAULT, "mkdir"));
var tempnam = @encode(char *(const char *, const char *))(dlsym(RTLD_DEFAULT, "tempnam"));
var fopen = @encode(void *(const char *, const char *))(dlsym(RTLD_DEFAULT, "fopen"));
var fclose = @encode(int (void *))(dlsym(RTLD_DEFAULT, "fclose"));
var fwrite = @encode(int (const char *, int, int, void *))(dlsym(RTLD_DEFAULT, "fwrite"));
var symlink = @encode(int (const char *, const char *))(dlsym(RTLD_DEFAULT, "symlink"));
var unlink = @encode(int (const char *))(dlsym(RTLD_DEFAULT, "unlink"));
var getenv = @encode(const char *(const char *))(dlsym(RTLD_DEFAULT, "getenv"));
var setenv = @encode(int (const char *, const char *, int))(dlsym(RTLD_DEFAULT, "setenv"));
var libdir = "/usr/lib/cycript0.9";
var dir = libdir + "/tmp";
mkdir(dir, 0777);
// This is needed because tempnam seems to ignore the first argument on i386
var old_tmpdir = getenv("TMPDIR");
setenv("TMPDIR", dir, 1);
// No freeing :(
var f = tempnam(dir, "exec-");
setenv("TMPDIR", old_tmpdir, 1);
if(!f) {
return false;
}
symlink(f, f + ".cy");
str = "exports.result = " + str;
var handle = fopen(f, "w");
fwrite(str, str.length, 1, handle);
fclose(handle);
var r;
var except = null;
try {
r = require(f.replace(libdir + "/", ""));
} catch(e) {
except = e;
}
unlink(f + ".cy");
unlink(f);
if(except !== null) {
throw except;
}
return r.result;
};
/*
Applies known typedefs
Used in utils.include and utils.makeStruct
Usage:
cy# utils.applyTypedefs("mach_vm_address_t")
"uint64_t"
*/
utils.applyTypedefs = function(str) {
var typedefs = {
"struct": "",
"restrict": "",
"FILE": "void",
"size_t": "uint64_t",
"uintptr_t": "unsigned long",
"kern_return_t": "int",
"mach_port_t": "unsigned int",
"mach_port_name_t": "unsigned int",
"vm_offset_t": "unsigned long",
"vm_size_t": "unsigned long",
"mach_vm_address_t": "uint64_t",
"mach_vm_offset_t": "uint64_t",
"mach_vm_size_t": "uint64_t",
"vm_map_offset_t": "uint64_t",
"vm_map_address_t": "uint64_t",
"vm_map_size_t": "uint64_t",
"mach_port_context_t": "uint64_t",
"vm_map_t": "unsigned int",
"boolean_t": "unsigned int",
"vm_prot_t": "int",
"mach_msg_type_number_t": "unsigned int",
"cpu_type_t": "int",
"cpu_subtype_t": "int",
"cpu_threadtype_t": "int",
};
for(var k in typedefs) {
str = str.replace(new RegExp("(\\s|\\*|,|\\(|^)" + k + "(\\s|\\*|,|\\)|$)", "g"), "$1" + typedefs[k] + "$2");
}
return str;
};
/*
Parses a C function declaration and returns the function name and cycript type
If load is true, tries to load it into cycript using utils.exec
Usage:
cy# var str = "void *calloc(size_t num, size_t size)";
"void *calloc(size_t num, size_t size)"
cy# utils.include(str)
["calloc","@encode(void *(uint64_t num, uint64_t size))(140735674376857)"]
cy# var ret = utils.include(str, true)
["calloc",0x7fff93e0e299]
cy# ret[1].type
@encode(void*(unsigned long long int,unsigned long long int))
cy# ret[1](100, 1)
0x100444100
*/
utils.include = function(str, load) {
var re = /^\s*([^(]*(?:\s+|\*))(\w*)\s*\(([^)]*)\)\s*;?\s*$/;
var match = re.exec(str);
if(!match) {
return -1;
}
var rType = utils.applyTypedefs(match[1]);
var name = match[2];
var args = match[3];
var argsRe = /([^,]+)(?:,|$)/g;
var argsTypes = [];
while((match = argsRe.exec(args)) !== null) {
var type = utils.applyTypedefs(match[1]);
argsTypes.push(type);
}
var encodeString = "@encode(";
encodeString += rType + "(";
encodeString += argsTypes.join(", ") + "))";
var fun = dlsym(RTLD_DEFAULT, name);
if(fun !== null) {
encodeString += "(" + fun + ")";
if(load) {
return [name, utils.exec(encodeString)];
}
} else if(load) {
throw "Function couldn't be found with dlsym!";
}
return [name, encodeString];
};
/*
Loads the function declaration in the defs array using utils.exec and exposes to cycript's global scope
Is automatically called if shouldLoadCFuncs is true
*/
utils.funcs = {};
utils.loadfuncs = function(expose) {
for(var i = 0; i < CFuncsDeclarations.length; i++) {
try {
var o = utils.include(CFuncsDeclarations[i], true);
utils.funcs[o[0]] = o[1];
if(expose) {
Cycript.all[o[0]] = o[1];
}
} catch(e) {
system.print("Failed to load function: " + i);
try {
system.print(utils.include(CFuncsDeclarations[i]));
} catch(e2) {
}
}
}
};
/*
Calculates the size of a type like the C operator sizeof
Usage:
cy# utils.sizeof(int)
4
cy# utils.sizeof(@encode(void *))
8
cy# utils.sizeof("mach_vm_address_t")
8
*/
utils.sizeof = function(type) {
if(typeof type === "string") {
type = utils.applyTypedefs(type);
type = utils.exec("@encode(" + type + ")");
}
// (const) char * has "infinite" preceision
if(type.toString().slice(-1) === "*") {
return utils.sizeof(@encode(void *));
}
// float and double
if(type.toString() === @encode(float).toString()) {
return 4;
} else if (type.toString() === @encode(double).toString()) {
return 8;
}
var typeInstance = type(0);
if(typeInstance instanceof Object) {
// Arrays
if("length" in typeInstance) {
return typeInstance.length * utils.sizeof(typeInstance.type);
}
// Structs
if(typeInstance.toString() === "[object Struct]") {
var typeStr = type.toString();
var arrayTypeStr = "[2" + typeStr + "]";
var arrayType = new Type(arrayTypeStr);
var arrayInstance = new arrayType;
return @encode(void *)(&(arrayInstance[1])) - @encode(void *)(&(arrayInstance[0]));
}
}
for(var i = 0; i < 5; i++) {
var maxSigned = Math.pow(2, 8 * Math.pow(2, i) - 1) - 1;
if(i === 3) {
// Floating point fix ;^)
maxSigned /= 1000;
}
// can't use !== or sizeof(void *) === 0.5
if(type(maxSigned) != maxSigned) {
return Math.pow(2, i - 1);
}
}
};
/*
Logs a specific message sent to an instance of a class like logify.pl in theos
Requires Cydia Substrate (com.saurik.substrate.MS) and NSLog (org.cycript.NSLog) modules
Returns the old message returned by MS.hookMessage (Note: this is not just the old message!)
Usage:
cy# var oldm = utils.logify(objc_getMetaClass(NSNumber), @selector(numberWithDouble:))
...
cy# var n = [NSNumber numberWithDouble:1.5]
2014-07-28 02:26:39.805 cycript[71213:507] +[<NSNumber: 0x10032d0c4> numberWithDouble:1.5]
2014-07-28 02:26:39.806 cycript[71213:507] = 1.5
@1.5
*/
utils.logify = function(cls, sel) {
@import com.saurik.substrate.MS;
@import org.cycript.NSLog;
var oldm = {};
MS.hookMessage(cls, sel, function() {
var args = [].slice.call(arguments);
var selFormat = sel.toString().replace(/:/g, ":%@ ").trim();
var logFormat = "%@[<%@: 0x%@> " + selFormat + "]";
var standardArgs = [logFormat, class_isMetaClass(cls)? "+": "-", cls.toString(), (&this).valueOf().toString(16)];
var logArgs = standardArgs.concat(args);
NSLog.apply(null, logArgs);
var r = oldm->apply(this, arguments);
if(r !== undefined) {
NSLog(" = %@", r);
}
return r;
}, oldm);
return oldm;
};
/*
Calls a C function by providing its name and arguments
Doesn't support structs
Return value is always a void pointer
Usage:
cy# utils.apply("printf", ["%s %.3s, %d -> %c, float: %f\n", "foo", "barrrr", 97, 97, 1.5])
foo bar, 97 -> a, float: 1.500000
0x22
*/
utils.apply = function(fun, args) {
if(!(args instanceof Array)) {
throw "Args needs to be an array!";
}
var argc = args.length;
var voidPtr = @encode(void *);
var argTypes = [];
for(var i = 0; i < argc; i++) {
var argType = voidPtr;
var arg = args[i];
if(typeof arg === "string") {
argType = @encode(char *);
}
if(typeof arg === "number" && arg % 1 !== 0) {
argType = @encode(double);
}
argTypes.push(argType);
}
var type = voidPtr.functionWith.apply(voidPtr, argTypes);
if(typeof fun === "string") {
fun = dlsym(RTLD_DEFAULT, fun);
}
if(!fun) {
throw "Function not found!";
}
return type(fun).apply(null, args);
};
/*
Converts a string (char *) to a void pointer (void *)
You can't cast to strings to void pointers and vice versa in cycript. Blame saurik.
Usage:
cy# var voidPtr = utils.str2voidPtr("foobar")
0x100331590
cy# utils.voidPtr2str(voidPtr)
"foobar"
*/
utils.str2voidPtr = function(str) {
var strdup = @encode(void *(char *))(dlsym(RTLD_DEFAULT, "strdup"));
return strdup(str);
};
/*
The inverse function of str2voidPtr
*/
utils.voidPtr2str = function(voidPtr) {
var strdup = @encode(char *(void *))(dlsym(RTLD_DEFAULT, "strdup"));
return strdup(voidPtr);
};
/*
Converts a double into a void pointer
This can be used to view the binary representation of a floating point number
Usage:
cy# var n = utils.double2voidPtr(-1.5)
0xbff8000000000000
cy# utils.voidPtr2double(n)
-1.5
*/
utils.double2voidPtr = function(n) {
var doublePtr = new double;
*doublePtr = n;
var voidPtrPtr = @encode(void **)(doublePtr);
return *voidPtrPtr;
};
/*
The inverse function of double2voidPtr
*/
utils.voidPtr2double = function(voidPtr) {
var voidPtrPtr = new @encode(void **);
*voidPtrPtr = voidPtr;
var doublePtr = @encode(double *)(voidPtrPtr);
return *doublePtr;
};
/*
Determines in a safe way if a memory location is readable
Usage:
cy# utils.isMemoryReadable(0)
false
cy# utils.isMemoryReadable(0x1337)
false
cy# utils.isMemoryReadable(NSObject)
true
cy# var a = malloc(100); utils.isMemoryReadable(a)
true
*/
utils.isMemoryReadable = function(ptr) {
if(typeof ptr === "string") {
return true;
}
var fds = new @encode(int [2]);
utils.apply("pipe", [fds]);
var result = utils.apply("write", [fds[1], ptr, 1]) == 1;
utils.apply("close", [fds[0]]);
utils.apply("close", [fds[1]]);
return result;
};
/*
Determines in a safe way if the memory location contains an Objective-C object
Usage:
cy# utils.isObject(0)
false
cy# utils.isObject(0x1337)
false
cy# utils.isObject(NSObject)
true
cy# utils.isObject(objc_getMetaClass(NSObject))
true
cy# utils.isObject([new NSObject init])
true
cy# var a = malloc(100); utils.isObject(a)
false
cy# *@encode(void **)(a) = NSObject; utils.isObject(a)
true
*/
utils.isObject = function(obj) {
obj = @encode(void *)(obj);
var lastObj = -1;
function objc_isa_ptr(obj) {
// See http://www.sealiesoftware.com/blog/archive/2013/09/24/objc_explain_Non-pointer_isa.html
var objc_debug_isa_class_mask = 0x00000001fffffffa;
obj = (obj & 1)? (obj & objc_debug_isa_class_mask): obj;
if((obj & (utils.sizeof(@encode(void *)) - 1)) != 0) {
return null;
} else {
return obj;
}
}
function ptrValue(obj) {
return obj? obj.valueOf(): null;
}
var foundMetaClass = false;
for(obj = objc_isa_ptr(obj); utils.isMemoryReadable(obj); ) {
obj = *@encode(void **)(obj);
if(ptrValue(obj) == ptrValue(lastObj)) {
foundMetaClass = true;
break;
}
lastObj = obj;
}
if(!foundMetaClass) {
return false;
}
if(lastObj === -1 || lastObj === null) {
return false;
}
var obj_class = objc_isa_ptr(@encode(void **)(obj)[1]);
if(!utils.isMemoryReadable(obj_class)) {
return false;
}
var metaclass = objc_isa_ptr(@encode(void **)(obj_class)[0]);
var superclass = objc_isa_ptr(@encode(void **)(obj_class)[1]);
return ptrValue(obj) == ptrValue(metaclass) && superclass == null;
};
/*
Creates a cycript struct type from a C struct definition
Usage:
cy# var foo = makeStruct("int a; short b; char c; uint64_t d; double e;", "foo");
@encode(foo)
cy# var f = new foo
&{a:0,b:0,c:0,d:0,e:0}
cy# f->a = 100; f
&{a:100,b:0,c:0,d:0,e:0}
cy# *@encode(int *)(f)
100
*/
utils.makeStruct = function(str, name) {
var fieldRe = /(?:\s|\n)*([^;]+\s*(?:\s|\*))([^;]+)\s*;/g;
if(!name) {
name = "struct" + Math.floor(Math.random() * 100000);
}
var typeStr = "{" + name + "=";
while((match = fieldRe.exec(str)) !== null) {
var fieldType = utils.applyTypedefs(match[1]);
var fieldName = match[2];
var encodedType = utils.exec("@encode(" + fieldType + ")").toString();
typeStr += '"' + fieldName + '"' + encodedType;
}
typeStr += "}";
return new Type(typeStr);
};
// Various constants
utils.constants = {
VM_PROT_NONE: 0x0,
VM_PROT_READ: 0x1,
VM_PROT_WRITE: 0x2,
VM_PROT_EXECUTE: 0x4,
VM_PROT_NO_CHANGE: 0x8,
VM_PROT_COPY: 0x10,
VM_PROT_WANTS_COPY: 0x10,
VM_PROT_IS_MASK: 0x40,
};
var c = utils.constants;
c.VM_PROT_DEFAULT = c.VM_PROT_READ | c.VM_PROT_WRITE;
c.VM_PROT_ALL = c.VM_PROT_READ | c.VM_PROT_WRITE | c.VM_PROT_EXECUTE;
if(shouldExposeConsts) {
for(var k in c) {
Cycript.all[k] = c[k];
}
}
if(shouldExposeFuncs) {
for(var i = 0; i < funcsToExpose.length; i++) {
var name = funcsToExpose[i];
Cycript.all[name] = utils[name];
}
}
if(shouldLoadCFuncs) {
utils.loadfuncs(shouldExposeCFuncs);
}
})(exports);

View File

@@ -0,0 +1,23 @@
class App.FromNowView extends Ember.View
tagName: 'time'
template: Ember.Handlebars.compile '{{view.output}}'
output: ~>
return moment(@value).fromNow()
didInsertElement: ->
@tick()
tick: ->
f = ->
@notifyPropertyChange 'output'
@tick()
nextTick = Ember.run.later(this, f, 1000)
@set 'nextTick', nextTick
willDestroyElement: ->
nextTick = @nextTick
Ember.run.cancel nextTick
Ember.Handlebars.helper 'fromNow', App.FromNowView

8
samples/Forth/bitmap.frt Normal file
View File

@@ -0,0 +1,8 @@
\ Bit arrays.
: bits ( u1 -- u2 ) 7 + 3 rshift ;
: bitmap ( u "name" -- ) create bits here over erase allot
does> ( u -- a x ) over 3 rshift + 1 rot 7 and lshift ;
: bit@ ( a x -- f ) swap c@ and ;
: 1bit ( a x -- ) over c@ or swap c! ;
: 0bit ( a x -- ) invert over c@ and swap c! ;
: bit! ( f a x -- ) rot if 1bit else 0bit then ;

7
samples/Forth/enum.frt Normal file
View File

@@ -0,0 +1,7 @@
\ Implements ENUM.
\ Double DOES>!
: enum create 0 , does> create dup @ 1 rot +! , does> @ ;
\ But this is simpler.
: enum create 0 , does> dup @ constant 1 swap +! ;

8
samples/Forth/macros.frt Normal file
View File

@@ -0,0 +1,8 @@
\ Simplifies compiling words.
: [[ ; immediate
: '<> >in @ ' swap >in ! <> ;
: (]]) begin dup '<> while postpone postpone repeat drop ;
: ]] ['] [[ (]]) ; immediate
( Usage: : foo ]] dup * [[ ; immediate : bar 42 foo . ; )

57
samples/G-code/duettest.g Normal file
View File

@@ -0,0 +1,57 @@
; RepRapPro Ormerod
; Board test GCodes
M111 S1; Debug on
G21 ; mm
G90 ; Absolute positioning
M83 ; Extrusion relative
M906 X800 Y800 Z800 E800 ; Motor currents (mA)
T0 ; Extruder 0
G1 X50 F500
G1 X0
G4 P500
G1 Y50 F500
G1 Y0
G4 P500
G1 Z20 F200
G1 Z0
G4 P500
G1 E20 F200
G1 E-20
G4 P500
M106 S255
G4 P500
M106 S0
G4 P500
M105
G10 P0 S100
T0
M140 S100
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
G4 P5000
M105
M0

25912
samples/G-code/lm.g Normal file

File diff suppressed because it is too large Load Diff

29735
samples/G-code/rm.g Normal file

File diff suppressed because it is too large Load Diff

13
samples/G-code/square.g Normal file
View File

@@ -0,0 +1,13 @@
G28 X0 Y0
G1 X55 Y5 F2000
G1 Y180
G1 X180
G1 Y5
G1 X55
G1 Y180
G1 X180
G1 Y5
G1 X55
M0

View File

@@ -0,0 +1,57 @@
# Taken from https://github.com/okamstudio/godot/wiki/gdscript
# a file is a class!
# inheritance
extends BaseClass
# member variables
var a = 5
var s = "Hello"
var arr = [1, 2, 3]
var dict = {"key":"value", 2:3}
# constants
const answer = 42
const thename = "Charly"
# built-in vector types
var v2 = Vector2(1, 2)
var v3 = Vector3(1, 2, 3)
# function
func some_function(param1, param2):
var local_var = 5
if param1 < local_var:
print(param1)
elif param2 > 5:
print(param2)
else:
print("fail!")
for i in range(20):
print(i)
while(param2 != 0):
param2 -= 1
var local_var2 = param1+3
return local_var2
# subclass
class Something:
var a = 10
# constructor
func _init():
print("constructed!")
var lv = Something.new()
print(lv.a)

216
samples/GDScript/grid.gd Normal file
View File

@@ -0,0 +1,216 @@
extends Control
# Simple Tetris-like demo, (c) 2012 Juan Linietsky
# Implemented by using a regular Control and drawing on it during the _draw() callback.
# The drawing surface is updated only when changes happen (by calling update())
var score = 0
var score_label=null
const MAX_SHAPES = 7
var block = preload("block.png")
var block_colors=[
Color(1,0.5,0.5),
Color(0.5,1,0.5),
Color(0.5,0.5,1),
Color(0.8,0.4,0.8),
Color(0.8,0.8,0.4),
Color(0.4,0.8,0.8),
Color(0.7,0.7,0.7)]
var block_shapes=[
[ Vector2(0,-1),Vector2(0,0),Vector2(0,1),Vector2(0,2) ], # I
[ Vector2(0,0),Vector2(1,0),Vector2(1,1),Vector2(0,1) ], # O
[ Vector2(-1,1),Vector2(0,1),Vector2(0,0),Vector2(1,0) ], # S
[ Vector2(1,1),Vector2(0,1),Vector2(0,0),Vector2(-1,0) ], # Z
[ Vector2(-1,1),Vector2(-1,0),Vector2(0,0),Vector2(1,0) ], # L
[ Vector2(1,1),Vector2(1,0),Vector2(0,0),Vector2(-1,0) ], # J
[ Vector2(0,1),Vector2(1,0),Vector2(0,0),Vector2(-1,0) ]] # T
var block_rotations=[
Matrix32( Vector2(1,0),Vector2(0,1), Vector2() ),
Matrix32( Vector2(0,1),Vector2(-1,0), Vector2() ),
Matrix32( Vector2(-1,0),Vector2(0,-1), Vector2() ),
Matrix32( Vector2(0,-1),Vector2(1,0), Vector2() )
]
var width=0
var height=0
var cells={}
var piece_active=false
var piece_shape=0
var piece_pos=Vector2()
var piece_rot=0
func piece_cell_xform(p,er=0):
var r = (4+er+piece_rot)%4
return piece_pos+block_rotations[r].xform(p)
func _draw():
var sb = get_stylebox("bg","Tree") # use line edit bg
draw_style_box(sb,Rect2(Vector2(),get_size()).grow(3))
var bs = block.get_size()
for y in range(height):
for x in range(width):
if (Vector2(x,y) in cells):
draw_texture_rect(block,Rect2(Vector2(x,y)*bs,bs),false,block_colors[cells[Vector2(x,y)]])
if (piece_active):
for c in block_shapes[piece_shape]:
draw_texture_rect(block,Rect2(piece_cell_xform(c)*bs,bs),false,block_colors[piece_shape])
func piece_check_fit(ofs,er=0):
for c in block_shapes[piece_shape]:
var pos = piece_cell_xform(c,er)+ofs
if (pos.x < 0):
return false
if (pos.y < 0):
return false
if (pos.x >= width):
return false
if (pos.y >= height):
return false
if (pos in cells):
return false
return true
func new_piece():
piece_shape = randi() % MAX_SHAPES
piece_pos = Vector2(width/2,0)
piece_active=true
piece_rot=0
if (piece_shape==0):
piece_pos.y+=1
if (not piece_check_fit(Vector2())):
#game over
#print("GAME OVER!")
game_over()
update()
func test_collapse_rows():
var accum_down=0
for i in range(height):
var y = height - i - 1
var collapse = true
for x in range(width):
if (Vector2(x,y) in cells):
if (accum_down):
cells[ Vector2(x,y+accum_down) ] = cells[Vector2(x,y)]
else:
collapse=false
if (accum_down):
cells.erase( Vector2(x,y+accum_down) )
if (collapse):
accum_down+=1
score+=accum_down*100
score_label.set_text(str(score))
func game_over():
piece_active=false
get_node("gameover").set_text("Game Over")
update()
func restart_pressed():
score=0
score_label.set_text("0")
cells.clear()
get_node("gameover").set_text("")
piece_active=true
update()
func piece_move_down():
if (!piece_active):
return
if (piece_check_fit(Vector2(0,1))):
piece_pos.y+=1
update()
else:
for c in block_shapes[piece_shape]:
var pos = piece_cell_xform(c)
cells[pos]=piece_shape
test_collapse_rows()
new_piece()
func piece_rotate():
var adv = 1
if (not piece_check_fit(Vector2(),1)):
return
piece_rot = (piece_rot + adv) % 4
update()
func _input(ie):
if (not piece_active):
return
if (!ie.is_pressed()):
return
if (ie.is_action("move_left")):
if (piece_check_fit(Vector2(-1,0))):
piece_pos.x-=1
update()
elif (ie.is_action("move_right")):
if (piece_check_fit(Vector2(1,0))):
piece_pos.x+=1
update()
elif (ie.is_action("move_down")):
piece_move_down()
elif (ie.is_action("rotate")):
piece_rotate()
func setup(w,h):
width=w
height=h
set_size( Vector2(w,h)*block.get_size() )
new_piece()
get_node("timer").start()
func _ready():
# Initalization here
setup(10,20)
score_label = get_node("../score")
set_process_input(true)

243
samples/GDScript/player.gd Normal file
View File

@@ -0,0 +1,243 @@
extends RigidBody
# member variables here, example:
# var a=2
# var b="textvar"
#var dir=Vector3()
const ANIM_FLOOR = 0
const ANIM_AIR_UP = 1
const ANIM_AIR_DOWN = 2
const SHOOT_TIME = 1.5
const SHOOT_SCALE = 2
const CHAR_SCALE = Vector3(0.3,0.3,0.3)
var facing_dir = Vector3(1, 0, 0)
var movement_dir = Vector3()
var jumping=false
var turn_speed=40
var keep_jump_inertia = true
var air_idle_deaccel = false
var accel=19.0
var deaccel=14.0
var sharp_turn_threshhold = 140
var max_speed=3.1
var on_floor = false
var prev_shoot = false
var last_floor_velocity = Vector3()
var shoot_blend = 0
func adjust_facing(p_facing, p_target,p_step, p_adjust_rate,current_gn):
var n = p_target # normal
var t = n.cross(current_gn).normalized()
var x = n.dot(p_facing)
var y = t.dot(p_facing)
var ang = atan2(y,x)
if (abs(ang)<0.001): # too small
return p_facing
var s = sign(ang)
ang = ang * s
var turn = ang * p_adjust_rate * p_step
var a
if (ang<turn):
a=ang
else:
a=turn
ang = (ang - a) * s
return ((n * cos(ang)) + (t * sin(ang))) * p_facing.length()
func _integrate_forces( state ):
var lv = state.get_linear_velocity() # linear velocity
var g = state.get_total_gravity()
var delta = state.get_step()
var d = 1.0 - delta*state.get_total_density()
if (d<0):
d=0
lv += g * delta #apply gravity
var anim = ANIM_FLOOR
var up = -g.normalized() # (up is against gravity)
var vv = up.dot(lv) # vertical velocity
var hv = lv - (up*vv) # horizontal velocity
var hdir = hv.normalized() # horizontal direction
var hspeed = hv.length() #horizontal speed
var floor_velocity
var onfloor = false
if (state.get_contact_count() == 0):
floor_velocity = last_floor_velocity
else:
for i in range(state.get_contact_count()):
if (state.get_contact_local_shape(i) != 1):
continue
onfloor = true
floor_velocity = state.get_contact_collider_velocity_at_pos(i)
break
var dir = Vector3() #where does the player intend to walk to
var cam_xform = get_node("target/camera").get_global_transform()
if (Input.is_action_pressed("move_forward")):
dir+=-cam_xform.basis[2]
if (Input.is_action_pressed("move_backwards")):
dir+=cam_xform.basis[2]
if (Input.is_action_pressed("move_left")):
dir+=-cam_xform.basis[0]
if (Input.is_action_pressed("move_right")):
dir+=cam_xform.basis[0]
var jump_attempt = Input.is_action_pressed("jump")
var shoot_attempt = Input.is_action_pressed("shoot")
var target_dir = (dir - up*dir.dot(up)).normalized()
if (onfloor):
var sharp_turn = hspeed > 0.1 and rad2deg(acos(target_dir.dot(hdir))) > sharp_turn_threshhold
if (dir.length()>0.1 and !sharp_turn) :
if (hspeed > 0.001) :
#linear_dir = linear_h_velocity/linear_vel
#if (linear_vel > brake_velocity_limit and linear_dir.dot(ctarget_dir)<-cos(Math::deg2rad(brake_angular_limit)))
# brake=true
#else
hdir = adjust_facing(hdir,target_dir,delta,1.0/hspeed*turn_speed,up)
facing_dir = hdir
else:
hdir = target_dir
if (hspeed<max_speed):
hspeed+=accel*delta
else:
hspeed-=deaccel*delta
if (hspeed<0):
hspeed=0
hv = hdir*hspeed
var mesh_xform = get_node("Armature").get_transform()
var facing_mesh=-mesh_xform.basis[0].normalized()
facing_mesh = (facing_mesh - up*facing_mesh.dot(up)).normalized()
facing_mesh = adjust_facing(facing_mesh,target_dir,delta,1.0/hspeed*turn_speed,up)
var m3 = Matrix3(-facing_mesh,up,-facing_mesh.cross(up).normalized()).scaled( CHAR_SCALE )
get_node("Armature").set_transform(Transform(m3,mesh_xform.origin))
if (not jumping and jump_attempt):
vv = 7.0
jumping = true
get_node("sfx").play("jump")
else:
if (vv>0):
anim=ANIM_AIR_UP
else:
anim=ANIM_AIR_DOWN
var hs
if (dir.length()>0.1):
hv += target_dir * (accel * 0.2) * delta
if (hv.length() > max_speed):
hv = hv.normalized() * max_speed
else:
if (air_idle_deaccel):
hspeed = hspeed - (deaccel * 0.2) * delta
if (hspeed<0):
hspeed=0
hv = hdir*hspeed
if (jumping and vv < 0):
jumping=false
lv = hv+up*vv
if (onfloor):
movement_dir = lv
#lv += floor_velocity
last_floor_velocity = floor_velocity
else:
if (on_floor) :
#if (keep_jump_inertia):
# lv += last_floor_velocity
pass
last_floor_velocity = Vector3()
movement_dir = lv
on_floor = onfloor
state.set_linear_velocity(lv)
if (shoot_blend>0):
shoot_blend -= delta * SHOOT_SCALE
if (shoot_blend<0):
shoot_blend=0
if (shoot_attempt and not prev_shoot):
shoot_blend = SHOOT_TIME
var bullet = preload("res://bullet.scn").instance()
bullet.set_transform( get_node("Armature/bullet").get_global_transform().orthonormalized() )
get_parent().add_child( bullet )
bullet.set_linear_velocity( get_node("Armature/bullet").get_global_transform().basis[2].normalized() * 20 )
PS.body_add_collision_exception( bullet.get_rid(), get_rid() ) #add it to bullet
get_node("sfx").play("shoot")
prev_shoot = shoot_attempt
if (onfloor):
get_node("AnimationTreePlayer").blend2_node_set_amount("walk",hspeed / max_speed)
get_node("AnimationTreePlayer").transition_node_set_current("state",anim)
get_node("AnimationTreePlayer").blend2_node_set_amount("gun",min(shoot_blend,1.0))
# state.set_angular_velocity(Vector3())
func _ready():
# Initalization here
get_node("AnimationTreePlayer").set_active(true)
pass

73
samples/GDScript/pong.gd Normal file
View File

@@ -0,0 +1,73 @@
extends Node2D
# member variables here, example:
# var a=2
# var b="textvar"
const INITIAL_BALL_SPEED = 80
var ball_speed = INITIAL_BALL_SPEED
var screen_size = Vector2(640,400)
#default ball direction
var direction = Vector2(-1,0)
var pad_size = Vector2(8,32)
const PAD_SPEED = 150
func _process(delta):
# get ball positio and pad rectangles
var ball_pos = get_node("ball").get_pos()
var left_rect = Rect2( get_node("left").get_pos() - pad_size*0.5, pad_size )
var right_rect = Rect2( get_node("right").get_pos() - pad_size*0.5, pad_size )
#integrate new ball postion
ball_pos+=direction*ball_speed*delta
#flip when touching roof or floor
if ( (ball_pos.y<0 and direction.y <0) or (ball_pos.y>screen_size.y and direction.y>0)):
direction.y = -direction.y
#flip, change direction and increase speed when touching pads
if ( (left_rect.has_point(ball_pos) and direction.x < 0) or (right_rect.has_point(ball_pos) and direction.x > 0)):
direction.x=-direction.x
ball_speed*=1.1
direction.y=randf()*2.0-1
direction = direction.normalized()
#check gameover
if (ball_pos.x<0 or ball_pos.x>screen_size.x):
ball_pos=screen_size*0.5
ball_speed=INITIAL_BALL_SPEED
direction=Vector2(-1,0)
get_node("ball").set_pos(ball_pos)
#move left pad
var left_pos = get_node("left").get_pos()
if (left_pos.y > 0 and Input.is_action_pressed("left_move_up")):
left_pos.y+=-PAD_SPEED*delta
if (left_pos.y < screen_size.y and Input.is_action_pressed("left_move_down")):
left_pos.y+=PAD_SPEED*delta
get_node("left").set_pos(left_pos)
#move right pad
var right_pos = get_node("right").get_pos()
if (right_pos.y > 0 and Input.is_action_pressed("right_move_up")):
right_pos.y+=-PAD_SPEED*delta
if (right_pos.y < screen_size.y and Input.is_action_pressed("right_move_down")):
right_pos.y+=PAD_SPEED*delta
get_node("right").set_pos(right_pos)
func _ready():
screen_size = get_viewport_rect().size # get actual size
pad_size = get_node("left").get_texture().get_size()
set_process(true)

View File

@@ -0,0 +1,6 @@
varying vec4 v_color;
void main()
{
gl_FragColor = v_color;
}

12
samples/GLSL/myvertex.vrx Normal file
View File

@@ -0,0 +1,12 @@
uniform mat4 u_MVPMatrix;
attribute vec4 a_position;
attribute vec4 a_color;
varying vec4 v_color;
void main()
{
v_color = a_color;
gl_Position = u_MVPMatrix * pos;
}

View File

@@ -0,0 +1,6 @@
method ack (m : Number, n : Number) -> Number {
print "ack {m} {n}"
if (m < = 0) then {n + 1}
elseif {n <= 0} then {ack((m -1), 1)}
else {ack(m -1, ack(m, n-1))}
}

View File

@@ -0,0 +1,554 @@
import "gtk" as gtk
import "io" as io
import "mgcollections" as collections
import "button_factory" as button_factory
import "dialog_factory" as dialog_factory
import "syntax_highlighter" as highlighter
import "auto_completer" as aComp
//TODO
// Autocomplete typing
// FileChooser
// Themes
// Details for the Top Level Window
def window = gtk.window(gtk.GTK_WINDOW_TOPLEVEL)
window.title := "Grace"
window.set_default_size(700, 700)
// -------------
// Placeholder for the console window that can be popped out
// of the main window
var popped := gtk.window(gtk.GTK_WINDOW_TOPLEVEL)
// Initialise the Boxes
def mBox = gtk.box(gtk.GTK_ORIENTATION_VERTICAL, 2)
def buttonBox = gtk.box(gtk.GTK_ORIENTATION_HORIZONTAL, 2)
var consoleButtons := gtk.box(gtk.GTK_ORIENTATION_HORIZONTAL, 3)
var consoleBox := gtk.box(gtk.GTK_ORIENTATION_VERTICAL, 2)
var editorBox := gtk.box(gtk.GTK_ORIENTATION_VERTICAL, 2)
var splitPane := gtk.paned(gtk.GTK_ORIENTATION_VERTICAL, 2)
def menuBox = gtk.box(gtk.GTK_ORIENTATION_HORIZONTAL, 4)
// -------------
// Initialise the buttons
def runButton = button_factory.make("run")
var clearButton := button_factory.make("clear")
var outButton := button_factory.make("out")
var errorButton := button_factory.make("error")
var popButton := button_factory.make("pop")
def newButton = button_factory.make("new")
def openButton = button_factory.make("open")
def saveButton = button_factory.make("save")
def saveAsButton = button_factory.make("saveAs")
def closeButton = button_factory.make("close")
// -------------
// Details for the default text editor and scrolled window
var tEdit := gtk.text_view
tEdit.set_size_request(700, 400)
var scrolled_main := gtk.scrolled_window
scrolled_main.set_size_request(700, 400)
scrolled_main.add(tEdit)
// -------------
// Widget that allows multiple files to be edited (tabs)
var notebook := gtk.notebook
notebook.scrollable := true
// -------------
// Maps for holding the text_views and scrolled_windows
var editor_map := collections.map.new
editor_map.put(0, tEdit)
var scrolled_map := collections.map.new
scrolled_map.put(0, scrolled_main)
// -------------
// Class that manages the syntax highlighting (This needs to be passed around otherwise
// the text_tag table gets confused, ie there can only be one)
def lighter = highlighter.Syntax_Highlighter.new(notebook, editor_map)
tEdit.buffer.on "changed" do {
lighter.highlightLine
}
// Class that manages any auto completion that is required
def completer = aComp.Auto_Completer.new(window, notebook, editor_map)
// Utility methods
// -------------
method deleteCompileFiles(page_num : Number) {
def cur_scrolled = scrolled_map.get(page_num)
var filename := notebook.get_tab_label_text(cur_scrolled)
filename := filename.substringFrom(0)to(filename.size - 7) //Removes .grace extension
io.system("rm -f files/" ++ filename)
io.system("rm -f files/" ++ filename ++ ".c")
io.system("rm -f files/" ++ filename ++ ".gcn")
io.system("rm -f files/" ++ filename ++ ".gct")
}
// -------------
var currentConsole := "output" // Which console is being shown
var out := false
var outText := ""
var errorText := ""
// Give actions to the buttons
// -------------
runButton.on "clicked" do {
clearConsoles()
// Get the details for the current page selected
def cur_page_num = notebook.current_page
def cur_page = editor_map.get(cur_page_num)
def cur_scrolled = scrolled_map.get(cur_page_num)
def cur_page_label = notebook.get_tab_label_text(cur_scrolled)
// Initialise text iterators
def sIter = gtk.text_iter
def eIter = gtk.text_iter
// Set one at the beggining and one at the end of the text
cur_page.buffer.get_iter_at_offset(sIter, 0)
cur_page.buffer.get_iter_at_offset(eIter, -1)
// Get the text between the text iterators
def text = cur_page.buffer.get_text(sIter, eIter, true)
// Save the text to the file (in case the user hasn't already saved it)
def file = io.open("files/" ++ cur_page_label, "w")
file.write(text)
file.close
// Run the program and pipe the output and errors into files to be read
io.system("../minigrace/minigrace " ++ "files/" ++ cur_page_label ++ " > output.txt 2> error.txt")
def outputFile = io.open("output.txt", "r")
def errorFile = io.open("error.txt", "r")
outText := outputFile.read
errorText := errorFile.read
io.system("rm -f output.txt error.txt")
var switched := false
// Change the console to output if there is output text
if((outText.size > 0) && (currentConsole != "output")) then {
switch_to_output()
switched := true
}
// Change the console to errors if there were errors
if((errorText.size > 0) && (currentConsole != "errors")) then {
switch_to_errors()
switched := true
}
// Remember to populate the console if it wasn't switched
if(!switched) then {
populateConsoles
}
}
clearButton.on "clicked" do {
clearConsoles()
}
outButton.on "clicked" do {
switch_to_output()
}
errorButton.on "clicked" do {
switch_to_errors()
}
popButton.on "clicked" do {
if(out) then {
popIn()
} else {
popOut()
}
}
// Gives a dialog to let the user create a new file to edit
newButton.on "clicked" do {
def new_window_class = dialog_factory.new.new(notebook, editor_map, scrolled_map, lighter)
def new_window = new_window_class.window()
new_window.show_all
}
// Gives a dialog that lets the user open a file to edit
openButton.on "clicked" do {
def open_window_class = dialog_factory.open.new(notebook, editor_map, scrolled_map, lighter)
def open_window = open_window_class.window()
open_window.show_all
}
// Saves the current file (if the name is Untitled.grace it will ask for a new name)
saveButton.on "clicked" do {
def cur_page_num = notebook.current_page
def cur_page = editor_map.get(cur_page_num)
def cur_scrolled = scrolled_map.get(cur_page_num)
def cur_page_label = notebook.get_tab_label_text(cur_scrolled)
if(cur_page_label == "Untitled.grace") then {
def saveAs_window_class = dialog_factory.save.new(notebook, editor_map, scrolled_map, true)
def saveAs_window = saveAs_window_class.window()
saveAs_window.show_all
} else {
// Initialise text iterators
def sIter = gtk.text_iter
def eIter = gtk.text_iter
// Set one at the beggining and one at the end of the text
cur_page.buffer.get_iter_at_offset(sIter, 0)
cur_page.buffer.get_iter_at_offset(eIter, -1)
// Get the text between the text iterators
def text = cur_page.buffer.get_text(sIter, eIter, true)
// Save the file
def file = io.open("files/" ++ cur_page_label, "w")
file.write(text)
file.close
}
}
// Gives a dialog that lets the user save the file with a new name
saveAsButton.on "clicked" do {
def saveAs_window_class = dialog_factory.save.new(notebook, editor_map, scrolled_map, false)
def saveAs_window = saveAs_window_class.window()
saveAs_window.show_all
}
// This will close a tab on the notebook
// It also "removes" the page from the map,
// by creating a new temporary map and putting all but
// the removed page in.
closeButton.on "clicked" do {
def page_num = notebook.current_page
def num_pages = notebook.n_pages
if(num_pages > 1) then {
deleteCompileFiles(page_num)
def e_map = collections.map.new
def s_map = collections.map.new
// Copy every page up to the current page into the new maps
var x := 0
while {x < page_num} do {
var eValue := editor_map.get(x)
var sValue := scrolled_map.get(x)
e_map.put(x, eValue)
s_map.put(x, sValue)
x := x + 1
}
// Copy every page after the current page into the new map (shifted one down)
x := page_num + 1
while {x < num_pages} do {
var eValue := editor_map.get(x)
var sValue := scrolled_map.get(x)
e_map.put((x - 1), eValue)
s_map.put((x - 1), sValue)
x := x + 1
}
editor_map := e_map
scrolled_map := s_map
notebook.remove_page(page_num)
notebook.show_all
}
}
// -------------
// Consoles:
// -------------
var outConsole := gtk.text_view
var outScroll := gtk.scrolled_window
var errorConsole := gtk.text_view
var errorScroll := gtk.scrolled_window
var errorTag := errorConsole.buffer.create_tag("fixed", "foreground", "red")
// Creates a new output console
method createOut {
outConsole := gtk.text_view
outScroll := gtk.scrolled_window
outScroll.add(outConsole)
if(out) then {
outConsole.set_size_request(400, 400)
outScroll.set_size_request(400, 400)
} else {
outConsole.set_size_request(700, 200)
outScroll.set_size_request(700, 200)
}
outConsole.editable := false
outConsole.buffer.set_text("[Output]:", -1)
}
createOut()
// Creates a new error console
method createError {
errorConsole := gtk.text_view
errorScroll := gtk.scrolled_window
errorScroll.add(errorConsole)
if(out) then {
errorConsole.set_size_request(400, 400)
errorScroll.set_size_request(400, 400)
} else {
errorConsole.set_size_request(700, 200)
errorScroll.set_size_request(700, 200)
}
errorConsole.editable := false
errorConsole.buffer.set_text("[Errors]:", -1)
errorTag := errorConsole.buffer.create_tag("fixed", "foreground", "red")
}
createError()
// Switches the console being shown to be output. This requires
// the output console to be remade as it would have been destroyed when
// it was switched previously
method switch_to_output {
if(currentConsole != "output") then {
currentConsole := "output"
consoleBox.remove(errorScroll) // This destroys the errorConsole
createOut()
consoleBox.add(outScroll)
populateConsoles()
if(out) then {
popped.show_all
} else {
window.show_all
}
}
}
// Switches the console being shown to be errors. This requires
// the error console to be remade as it would have been destroyed when
// it was switched previously
method switch_to_errors {
if(currentConsole != "errors") then {
currentConsole := "errors"
consoleBox.remove(outScroll) // This destroys the outConsole
createError()
consoleBox.add(errorScroll)
populateConsoles()
if(out) then {
popped.show_all
} else {
window.show_all
}
}
}
// If there is text to be put into the consoles this will add it
method populateConsoles {
if((outText.size > 0) && (currentConsole == "output")) then {
outConsole.buffer.set_text(outText, -1)
}
if((errorText.size > 0) && (currentConsole == "errors")) then {
def sIter = gtk.text_iter
def eIter = gtk.text_iter
errorConsole.buffer.set_text(errorText, -1)
errorConsole.buffer.get_iter_at_offset(sIter, 0)
errorConsole.buffer.get_iter_at_offset(eIter, -1)
errorConsole.buffer.apply_tag(errorTag, sIter, eIter)
}
}
method clearConsoles {
if(currentConsole == "output") then {
outConsole.buffer.set_text("[Output]:", -1)
outText := ""
}
if(currentConsole == "errors") then {
errorConsole.buffer.set_text("[Errors]:", -1)
errorText := ""
}
}
// Identical as the popIn method, but can be connected to the window's destroy button
def popInBlock = {
consoleBox.reparent(splitPane)
popButton.label := "Pop Out"
if(currentConsole == "output") then {
outConsole.set_size_request(700, 200)
outScroll.set_size_request(700, 200)
}
if(currentConsole == "errors") then {
errorConsole.set_size_request(700, 200)
errorScroll.set_size_request(700, 200)
}
def cur_page_num = notebook.current_page
def cur_scrolled = scrolled_map.get(cur_page_num)
def cur_page = editor_map.get(cur_page_num)
cur_page.set_size_request(700, 400)
cur_scrolled.set_size_request(700, 400)
out := false
popped.visible := false
}
// This pops the console out into a separate window
method popOut {
popped := gtk.window(gtk.GTK_WINDOW_TOPLEVEL)
consoleBox.reparent(popped)
popButton.label := "Pop In"
if(currentConsole == "output") then {
outConsole.set_size_request(400, 400)
outScroll.set_size_request(400, 400)
}
if(currentConsole == "errors") then {
errorConsole.set_size_request(400, 400)
errorScroll.set_size_request(400, 400)
}
def cur_page_num = notebook.current_page
def cur_scrolled = scrolled_map.get(cur_page_num)
def cur_page = editor_map.get(cur_page_num)
cur_page.set_size_request(700, 580)
cur_scrolled.set_size_request(700, 580)
out := true
popped.visible := true
popped.connect("destroy", popInBlock)
popped.show_all
}
// Puts the console back into the main window
method popIn {
consoleBox.reparent(splitPane)
popButton.label := "Pop Out"
if(currentConsole == "output") then {
outConsole.set_size_request(700, 200)
outScroll.set_size_request(700, 200)
}
if(currentConsole == "errors") then {
errorConsole.set_size_request(700, 200)
errorScroll.set_size_request(700, 200)
}
def cur_page_num = notebook.current_page
def cur_scrolled = scrolled_map.get(cur_page_num)
def cur_page = editor_map.get(cur_page_num)
cur_page.set_size_request(700, 400)
cur_scrolled.set_size_request(700, 400)
out := false
popped.visible := false
}
clearConsoles()
// -------------
// Patch everything together
var hSeparator1 := gtk.separator(gtk.GTK_ORIENTATION_HORIZONTAL)
var hSeparator2 := gtk.separator(gtk.GTK_ORIENTATION_HORIZONTAL)
menuBox.add(newButton)
menuBox.add(openButton)
menuBox.add(saveButton)
menuBox.add(saveAsButton)
buttonBox.add(runButton)
buttonBox.add(closeButton)
consoleButtons.add(outButton)
consoleButtons.add(errorButton)
consoleButtons.add(clearButton)
consoleButtons.add(popButton)
consoleBox.add(hSeparator1)
consoleBox.add(consoleButtons)
consoleBox.add(outScroll)
editorBox.add(hSeparator2)
notebook.add(scrolled_main)
notebook.set_tab_label_text(scrolled_main, "Untitled.grace")
editorBox.add(notebook)
splitPane.add1(editorBox)
splitPane.add2(consoleBox)
mBox.add(menuBox)
mBox.add(buttonBox)
mBox.add(splitPane)
window.add(mBox)
def exit = {
var x := 0
while {x < notebook.n_pages} do {
deleteCompileFiles(x)
x := x + 1
}
// Delete the compile files of the IDE
io.system("rm -f Grace_IDE.gct Grace_IDE.c Grace_IDE.gcn")
io.system("rm -f scanner.gct scanner.c scanner.gcn")
io.system("rm -f syntax_highlighter.gct syntax_highlighter.c syntax_highlighter.gcn")
io.system("rm -f syntax_colors.gct syntax_colors.c syntax_colors.gcn")
io.system("rm -f button_factory.gct button_factory.c button_factory.gcn")
io.system("rm -f dialog_factory.gct dialog_factory.c dialog_factory.gcn")
io.system("rm -f auto_completer.gct auto_completer.c auto_completer.gcn")
print "Grace IDE Closed Successfully"
gtk.main_quit
}
window.connect("destroy", exit)
window.show_all
gtk.main

View File

@@ -0,0 +1,21 @@
graph
[
directed 0
node
[
id 0
label "Node 1"
value 100
]
node
[
id 1
label "Node 2"
value 200
]
edge
[
source 1
target 0
]
]

13
samples/Groff/sample.4 Normal file
View File

@@ -0,0 +1,13 @@
.TH FOO 1
.SH NAME
foo \- bar
.SH SYNOPSIS
.B foo
.I bar
.SH DESCRIPTION
Foo bar
.BR baz
quux.
.PP
.B Foo
bar baz.

View File

@@ -0,0 +1,31 @@
<!-- insert_before '[data-hook="buttons"]' -->
<% if Spree::Config[:enable_fishbowl] %>
<div class="row">
<div class="twelve columns" id="fishbowl_preferences">
<fieldset class="no-border-bottom">
<legend align="center"><%= t(:fishbowl_settings)%></legend>
<% @fishbowl_options.each do |key| %>
<div class="field">
<%= label_tag(key, t(key.to_s.gsub('fishbowl_', '').to_sym) + ': ') + tag(:br) %>
<%= text_field_tag('preferences[' + key.to_s + ']', Spree::Config[key], { :size => 10, :class => 'fullwidth' }) %>
</div>
<% end %>
<div class="field">
<%= hidden_field_tag 'preferences[fishbowl_always_fetch_current_inventory]', '0' %>
<%= check_box_tag('preferences[fishbowl_always_fetch_current_inventory]', "1", Spree::Config[:fishbowl_always_fetch_current_inventory]) %>
<%= t(:always_fetch_current_inventory) %>
</div>
<% if !@location_groups.empty? %>
<div class="field">
<%= label_tag(:fishbowl_location_group, t(:location_group) + ': ') + tag(:br) %>
<%= select('preferences', 'fishbowl_location_group', @location_groups, { :selected => Spree::Config[:fishbowl_location_group]}, { :class => ['select2', 'fullwidth'] }) %>
</div>
<% end %>
</fieldset>
</div>
</div>
<script type="text/javascript">
$('.select2').select2();
</script>
<% end %>

View File

@@ -0,0 +1,39 @@
<% provide(:title, @header) %>
<% present @users do |user_presenter| %>
<div class="row key-header">
<h1><%= @header %></h1>
</div>
<div class='row'>
<div class='small-12 columns'>
<%= will_paginate %>
</div>
</div>
<div class="row key-table">
<div class="small-12 columns">
<div class="row key-table-row">
<div class="small-2 columns">Name</div>
<div class="small-3 columns">Email</div>
<div class="small-1 columns">Chords</div>
<div class="small-1 columns">Keys</div>
<div class="small-1 columns">Tunings</div>
<div class="small-1 columns">Credits</div>
<div class="small-1 columns">Prem?</div>
<div class="small-2 columns">Since?</div>
</div>
<% if @users == [] %>
<div class="row key-table-row">
<div class="small-4 small-centered columns">No Users</div>
</div>
<% else %>
<%= render @users %>
<% end %>
</div>
</div>
<div class='row'>
<div class='small-12 columns'>
<%= will_paginate %>
</div>
</div>
<% end %>

View File

@@ -0,0 +1,29 @@
/
replace '.actions'
.pull-right
.btn-group
= link_to page.url, target: "_blank", title: t('.view_live_html'), class: "tip btn btn-xs btn-default" do
%i.icon-picture.row-black
= link_to refinery.edit_admin_page_path(page.nested_url,
switch_locale: (page.translations.first.locale unless page.translated_to_default_locale?)),
title: t('edit', :scope => 'refinery.admin.pages'),
class: "tip btn btn-xs btn-default" do
%i.icon-edit.row-blue
- if page.deletable?
= link_to refinery.admin_page_path(page.nested_url),
methode: :delete,
title: t('delete', :scope => 'refinery.admin.pages'),
class: "tip cancel confirm-delete btn btn-xs btn-default",
data: { confirm: t('message', scope: 'refinery.admin.delete', title: page_title_with_translations(page)) } do
%i.icon-trash.row-red
- else
%button.btn.btn-xs.btn-default.disabled
%i.icon-trash
.btn-group
= link_to refinery.new_admin_page_path(:parent_id => page.id), title: t('new', :scope => 'refinery.admin.pages'), class: "tip btn btn-xs btn-default" do
%i.icon-plus.row-green

View File

@@ -0,0 +1,38 @@
#pragma rtGlobals=3
Function FooBar()
return 0
End
Function FooBarSubType() : ButtonControl
return 0
End
Function/D FooBarVar()
return 0
End
static Function FooBarStatic()
return 0
End
threadsafe static Function FooBarStaticThreadsafe()
return 0
End
threadsafe Function FooBarThread()
return 0
End
Function CallOperationsAndBuiltInFuncs(string var)
string someDQString = "abcd"
Make/N=(1,2,3,4) myWave
Redimension/N=(-1,-1,-1,5) myWave
print strlen(someDQString)
return 0
End

View File

@@ -0,0 +1,21 @@
#pragma rtGlobals=3
StrConstant myConstString="abcd"
// some comment
constant myConst=123
Structure struct1
string str
variable var
EndStructure
static Structure struct2
string str
variable var
EndStructure
#include "someFile"
#ifdef NOT_DEFINED
// conditional compilation
#endif

View File

@@ -0,0 +1,46 @@
theory HelloWorld
imports Main
begin
section{*Playing around with Isabelle*}
text{* creating a lemma with the name hello_world*}
lemma hello_world: "True" by simp
(*inspecting it*)
thm hello_world
text{* defining a string constant HelloWorld *}
definition HelloWorld :: "string" where
"HelloWorld \<equiv> ''Hello World!''"
(*reversing HelloWorld twice yilds HelloWorld again*)
theorem "rev (rev HelloWorld) = HelloWorld"
by (fact List.rev_rev_ident)
text{*now we delete the already proven List.rev_rev_ident lema and show it by hand*}
declare List.rev_rev_ident[simp del]
hide_fact List.rev_rev_ident
(*It's trivial since we can just 'execute' it*)
corollary "rev (rev HelloWorld) = HelloWorld"
apply(simp add: HelloWorld_def)
done
text{*does it hold in general?*}
theorem rev_rev_ident:"rev (rev l) = l"
proof(induction l)
case Nil thus ?case by simp
next
case (Cons l ls)
assume IH: "rev (rev ls) = ls"
have "rev (l#ls) = (rev ls) @ [l]" by simp
hence "rev (rev (l#ls)) = rev ((rev ls) @ [l])" by simp
also have "\<dots> = [l] @ rev (rev ls)" by simp
finally show "rev (rev (l#ls)) = l#ls" using IH by simp
qed
corollary "\<forall>(l::string). rev (rev l) = l" by(fastforce intro: rev_rev_ident)
end

View File

@@ -0,0 +1,24 @@
/*
invoke endpoint by calling in a browser:
http://<hanaserveradress>:<xsengineport(usually 8000)>/<path>/<to>/<endpoint>/helloHanaMath.xsjslib?x=4&y=2
e.g.:
http://192.168.178.20:8000/geekflyer/linguist/helloHanaEndpoint.xsjs?x=4&y=2
*/
var hanaMath = $.import("./helloHanaMath.xsjslib");
var x = parseFloat($.request.parameters.get("x"));
var y = parseFloat($.request.parameters.get("y"));
var result = hanaMath.multiply(x, y);
var output = {
title: "Hello HANA XS - do some simple math",
input: {x: x, y: y},
result: result
};
$.response.contentType = "application/json";
$.response.statusCode = $.net.http.OK;
$.response.setBody(JSON.stringify(output));

View File

@@ -0,0 +1,9 @@
/* simple hana xs demo library, which can be used by multiple endpoints */
function multiply(x, y) {
return x * y;
}
function add(x, y) {
return x + y;
}

View File

@@ -0,0 +1,12 @@
jsb.library('mylibrary', jsb.STATIC_LIBRARY, function(libObject) {
libObject.outputName = 'mylibrary';
libObject.cflags = [ '-Wall' ];
libObject.ldflags = [ '-pthread' ];
libObject.includePaths = [ 'src/include' ];
libObject.sources = [
'src/main.cpp',
'src/app.cpp'
];
});
jsb.build();

74
samples/LSL/LSL.lsl 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,43 @@
- view: comments
fields:
- dimension: id
primary_key: true
type: int
sql: ${TABLE}.id
- dimension: body
sql: ${TABLE}.body
- dimension_group: created
type: time
timeframes: [time, date, week, month]
sql: ${TABLE}.created_at
- dimension: headline_id
type: int
hidden: true
sql: ${TABLE}.headline_id
- dimension_group: updated
type: time
timeframes: [time, date, week, month]
sql: ${TABLE}.updated_at
- dimension: user_id
type: int
hidden: true
sql: ${TABLE}.user_id
- measure: count
type: count
detail: detail*
# ----- Detail ------
sets:
detail:
- id
- headlines.id
- headlines.name
- users.id

View File

@@ -0,0 +1,232 @@
(* Content-type: application/vnd.wolfram.mathematica *)
(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)
(* CreatedBy='Mathematica 9.0' *)
(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[ 157, 7]
NotebookDataLength[ 7164, 223]
NotebookOptionsPosition[ 6163, 182]
NotebookOutlinePosition[ 6508, 197]
CellTagsIndexPosition[ 6465, 194]
WindowFrame->Normal*)
(* Beginning of Notebook Content *)
Notebook[{
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{
RowBox[{"Solve", "[",
RowBox[{
RowBox[{"y", "'"}], "\[Equal]", " ", "xy"}], "]"}],
"\[IndentingNewLine]"}]], "Input",
CellChangeTimes->{{3.6112716342092056`*^9, 3.6112716549793935`*^9}}],
Cell[BoxData[
RowBox[{"{",
RowBox[{"{",
RowBox[{"xy", "\[Rule]",
SuperscriptBox["y", "\[Prime]",
MultilineFunction->None]}], "}"}], "}"}]], "Output",
CellChangeTimes->{3.6112716579295626`*^9}]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"Log", "[",
RowBox[{"Sin", "[", "38", "]"}], "]"}]], "Input",
CellChangeTimes->{{3.611271663920905*^9, 3.6112716759275913`*^9}}],
Cell[BoxData[
RowBox[{"Log", "[",
RowBox[{"Sin", "[", "38", "]"}], "]"}]], "Output",
CellChangeTimes->{3.611271678256725*^9}]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"N", "[",
RowBox[{"Log", "[",
RowBox[{"Sin", "[", "38", "]"}], "]"}], "]"}]], "Input",
NumberMarks->False],
Cell[BoxData[
RowBox[{"-", "1.2161514009320473`"}]], "Output",
CellChangeTimes->{3.611271682061942*^9}]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"Abs", "[",
RowBox[{"-", "1.2161514009320473`"}], "]"}]], "Input",
NumberMarks->False],
Cell[BoxData["1.2161514009320473`"], "Output",
CellChangeTimes->{3.6112716842780695`*^9}]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{"RealDigits", "[", "1.2161514009320473`", "]"}]], "Input",
NumberMarks->False],
Cell[BoxData[
RowBox[{"{",
RowBox[{
RowBox[{"{",
RowBox[{
"1", ",", "2", ",", "1", ",", "6", ",", "1", ",", "5", ",", "1", ",", "4",
",", "0", ",", "0", ",", "9", ",", "3", ",", "2", ",", "0", ",", "4",
",", "7"}], "}"}], ",", "1"}], "}"}]], "Output",
CellChangeTimes->{3.611271685319129*^9}]
}, Open ]],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{
RowBox[{"Graph", "[",
RowBox[{"Log", "[", "x", "]"}], "]"}], "\[IndentingNewLine]"}]], "Input",
CellChangeTimes->{{3.611271689258354*^9, 3.611271702038085*^9}}],
Cell[BoxData[
RowBox[{"Graph", "[",
RowBox[{"Log", "[", "x", "]"}], "]"}]], "Output",
CellChangeTimes->{3.611271704295214*^9}]
}, Open ]],
Cell[BoxData[""], "Input",
CellChangeTimes->{{3.611271712769699*^9, 3.6112717423153887`*^9}}],
Cell[CellGroupData[{
Cell[BoxData[
RowBox[{
RowBox[{"Plot", "[",
RowBox[{
RowBox[{"Log", "[", "x", "]"}], ",", " ",
RowBox[{"{",
RowBox[{"x", ",", " ", "0", ",", " ", "10"}], "}"}]}], "]"}],
"\[IndentingNewLine]"}]], "Input",
CellChangeTimes->{{3.6112717573482485`*^9, 3.6112717747822456`*^9}}],
Cell[BoxData[
GraphicsBox[{{}, {},
{Hue[0.67, 0.6, 0.6], LineBox[CompressedData["
1:eJwVzXs81Pkex/GZH7XlsutSQprwqxTSZVfJGp9P6UYqlyxHUhTaLrq4JpVK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"]]}},
AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948],
Axes->True,
AxesLabel->{None, None},
AxesOrigin->{0, 0},
Method->{},
PlotRange->{{0, 10}, {-1.623796532045525, 2.3025850725858823`}},
PlotRangeClipping->True,
PlotRangePadding->{
Scaled[0.02],
Scaled[0.02]}]], "Output",
CellChangeTimes->{3.6112717778594217`*^9}]
}, Open ]]
},
WindowSize->{716, 833},
WindowMargins->{{Automatic, 214}, {Automatic, 26}},
FrontEndVersion->"9.0 for Microsoft Windows (64-bit) (January 25, 2013)",
StyleDefinitions->"Default.nb"
]
(* End of Notebook Content *)
(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[CellGroupData[{
Cell[579, 22, 224, 6, 52, "Input"],
Cell[806, 30, 211, 6, 31, "Output"]
}, Open ]],
Cell[CellGroupData[{
Cell[1054, 41, 155, 3, 31, "Input"],
Cell[1212, 46, 130, 3, 31, "Output"]
}, Open ]],
Cell[CellGroupData[{
Cell[1379, 54, 137, 4, 31, "Input"],
Cell[1519, 60, 105, 2, 31, "Output"]
}, Open ]],
Cell[CellGroupData[{
Cell[1661, 67, 113, 3, 31, "Input"],
Cell[1777, 72, 90, 1, 31, "Output"]
}, Open ]],
Cell[CellGroupData[{
Cell[1904, 78, 102, 2, 31, "Input"],
Cell[2009, 82, 321, 8, 31, "Output"]
}, Open ]],
Cell[CellGroupData[{
Cell[2367, 95, 191, 4, 52, "Input"],
Cell[2561, 101, 131, 3, 31, "Output"]
}, Open ]],
Cell[2707, 107, 94, 1, 31, "Input"],
Cell[CellGroupData[{
Cell[2826, 112, 299, 8, 52, "Input"],
Cell[3128, 122, 3019, 57, 265, "Output"]
}, Open ]]
}
]
*)
(* End of internal cache information *)

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,8 @@
(* ::Package:: *)
(* Problem12.m *)
(* Author: William Woodruff *)
(* Problem: What is the value of the first triangle number to have over five hundred divisors? *)
Do[If[Length[Divisors[Binomial[i + 1, 2]]] > 500,
Print[Binomial[i + 1, 2]]; Break[]], {i, 1000000}]

272
samples/Nit/calculator.nit Normal file
View File

@@ -0,0 +1,272 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.
import gtk
class CalculatorContext
var result : nullable Float = null
var last_op : nullable Char = null
var current : nullable Float = null
var after_point : nullable Int = null
fun push_op( op : Char )
do
apply_last_op_if_any
if op == 'C' then
self.result = 0.0
last_op = null
else
last_op = op # store for next push_op
end
# prepare next current
after_point = null
current = null
end
fun push_digit( digit : Int )
do
var current = current
if current == null then current = 0.0
var after_point = after_point
if after_point == null then
current = current * 10.0 + digit.to_f
else
current = current + digit.to_f * 10.0.pow(after_point.to_f)
self.after_point -= 1
end
self.current = current
end
fun switch_to_decimals
do
if self.current == null then current = 0.0
if after_point != null then return
after_point = -1
end
fun apply_last_op_if_any
do
var op = last_op
var result = result
if result == null then result = 0.0
var current = current
if current == null then current = 0.0
if op == null then
result = current
else if op == '+' then
result = result + current
else if op == '-' then
result = result - current
else if op == '/' then
result = result / current
else if op == '*' then
result = result * current
end
self.result = result
self.current = null
end
end
class CalculatorGui
super GtkCallable
var win : GtkWindow
var container : GtkGrid
var lbl_disp : GtkLabel
var but_eq : GtkButton
var but_dot : GtkButton
var context = new CalculatorContext
redef fun signal( sender, user_data )
do
var after_point = context.after_point
if after_point == null then
after_point = 0
else
after_point = (after_point.abs)
end
if user_data isa Char then # is an operation
var c = user_data
if c == '.' then
but_dot.sensitive= false
context.switch_to_decimals
lbl_disp.text = "{context.current.to_i}."
else
but_dot.sensitive= true
context.push_op( c )
var s = context.result.to_precision_native(6)
var index : nullable Int = null
for i in s.length.times do
var chiffre = s.chars[i]
if chiffre == '0' and index == null then
index = i
else if chiffre != '0' then
index = null
end
end
if index != null then
s = s.substring(0, index)
if s.chars[s.length-1] == ',' then s = s.substring(0, s.length-1)
end
lbl_disp.text = s
end
else if user_data isa Int then # is a number
var n = user_data
context.push_digit( n )
lbl_disp.text = context.current.to_precision_native(after_point)
end
end
init
do
init_gtk
win = new GtkWindow( 0 )
container = new GtkGrid(5,5,true)
win.add( container )
lbl_disp = new GtkLabel( "_" )
container.attach( lbl_disp, 0, 0, 5, 1 )
# digits
for n in [0..9] do
var but = new GtkButton.with_label( n.to_s )
but.request_size( 64, 64 )
but.signal_connect( "clicked", self, n )
if n == 0 then
container.attach( but, 0, 4, 1, 1 )
else container.attach( but, (n-1)%3, 3-(n-1)/3, 1, 1 )
end
# operators
var r = 1
for op in ['+', '-', '*', '/' ] do
var but = new GtkButton.with_label( op.to_s )
but.request_size( 64, 64 )
but.signal_connect( "clicked", self, op )
container.attach( but, 3, r, 1, 1 )
r+=1
end
# =
but_eq = new GtkButton.with_label( "=" )
but_eq.request_size( 64, 64 )
but_eq.signal_connect( "clicked", self, '=' )
container.attach( but_eq, 4, 3, 1, 2 )
# .
but_dot = new GtkButton.with_label( "." )
but_dot.request_size( 64, 64 )
but_dot.signal_connect( "clicked", self, '.' )
container.attach( but_dot, 1, 4, 1, 1 )
#C
var but_c = new GtkButton.with_label( "C" )
but_c.request_size( 64, 64 )
but_c.signal_connect("clicked", self, 'C')
container.attach( but_c, 2, 4, 1, 1 )
win.show_all
end
end
# context tests
var context = new CalculatorContext
context.push_digit( 1 )
context.push_digit( 2 )
context.push_op( '+' )
context.push_digit( 3 )
context.push_op( '*' )
context.push_digit( 2 )
context.push_op( '=' )
var r = context.result.to_precision( 2 )
assert r == "30.00" else print r
context = new CalculatorContext
context.push_digit( 1 )
context.push_digit( 4 )
context.switch_to_decimals
context.push_digit( 1 )
context.push_op( '*' )
context.push_digit( 3 )
context.push_op( '=' )
r = context.result.to_precision( 2 )
assert r == "42.30" else print r
context.push_op( '+' )
context.push_digit( 1 )
context.push_digit( 1 )
context.push_op( '=' )
r = context.result.to_precision( 2 )
assert r == "53.30" else print r
context = new CalculatorContext
context.push_digit( 4 )
context.push_digit( 2 )
context.switch_to_decimals
context.push_digit( 3 )
context.push_op( '/' )
context.push_digit( 3 )
context.push_op( '=' )
r = context.result.to_precision( 2 )
assert r == "14.10" else print r
#test multiple decimals
context = new CalculatorContext
context.push_digit( 5 )
context.push_digit( 0 )
context.switch_to_decimals
context.push_digit( 1 )
context.push_digit( 2 )
context.push_digit( 3 )
context.push_op( '+' )
context.push_digit( 1 )
context.push_op( '=' )
r = context.result.to_precision( 3 )
assert r == "51.123" else print r
#test 'C' button
context = new CalculatorContext
context.push_digit( 1 )
context.push_digit( 0 )
context.push_op( '+' )
context.push_digit( 1 )
context.push_digit( 0 )
context.push_op( '=' )
context.push_op( 'C' )
r = context.result.to_precision( 1 )
assert r == "0.0" else print r
# graphical application
if "NIT_TESTING".environ != "true" then
var app = new CalculatorGui
run_gtk
end

View File

@@ -0,0 +1,45 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# This sample has been implemented to show you how simple is it to play
# with native callbacks (C) through an high level with NIT program.
module callback_chimpanze
import callback_monkey
class Chimpanze
super MonkeyActionCallable
fun create
do
var monkey = new Monkey
print "Hum, I'm sleeping ..."
# Invoking method which will take some time to compute, and
# will be back in wokeUp method with information.
# - Callback method defined in MonkeyActionCallable Interface
monkey.wokeUpAction(self, "Hey, I'm awake.")
end
# Inherit callback method, defined by MonkeyActionCallable interface
# - Back of wokeUpAction method
redef fun wokeUp( sender:Monkey, message:Object )
do
print message
end
end
var m = new Chimpanze
m.create

View File

@@ -0,0 +1,92 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# This sample has been implemented to show you how simple is it to play
# with native callbacks (C) through an high level with NIT program.
module callback_monkey
in "C header" `{
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int id;
int age;
} CMonkey;
typedef struct {
MonkeyActionCallable toCall;
Object message;
} MonkeyAction;
`}
in "C body" `{
// Method which reproduce a callback answer
// Please note that a function pointer is only used to reproduce the callback
void cbMonkey(CMonkey *mkey, void callbackFunc(CMonkey*, MonkeyAction*), MonkeyAction *data)
{
sleep(2);
callbackFunc( mkey, data );
}
// Back of background treatment, will be redirected to callback function
void nit_monkey_callback_func( CMonkey *mkey, MonkeyAction *data )
{
// To call a your method, the signature must be written like this :
// <Interface Name>_<Method>...
MonkeyActionCallable_wokeUp( data->toCall, mkey, data->message );
}
`}
# Implementable interface to get callback in defined methods
interface MonkeyActionCallable
fun wokeUp( sender:Monkey, message: Object) is abstract
end
# Defining my object type Monkey, which is, in a low level, a pointer to a C struct (CMonkey)
extern class Monkey `{ CMonkey * `}
new `{
CMonkey *monkey = malloc( sizeof(CMonkey) );
monkey->age = 10;
monkey->id = 1;
return monkey;
`}
# Object method which will get a callback in wokeUp method, defined in MonkeyActionCallable interface
# Must be defined as Nit/C method because of C call inside
fun wokeUpAction( toCall: MonkeyActionCallable, message: Object ) is extern import MonkeyActionCallable.wokeUp `{
// Allocating memory to keep reference of received parameters :
// - Object receiver
// - Message
MonkeyAction *data = malloc( sizeof(MonkeyAction) );
// Incrementing reference counter to prevent from releasing
MonkeyActionCallable_incr_ref( toCall );
Object_incr_ref( message );
data->toCall = toCall;
data->message = message;
// Calling method which reproduce a callback by passing :
// - Receiver
// - Function pointer to object return method
// - Datas
cbMonkey( recv, &nit_monkey_callback_func, data );
`}
end

View File

@@ -0,0 +1,167 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.
# Implementation of circular lists
# This example shows the usage of generics and somewhat a specialisation of collections.
module circular_list
# Sequences of elements implemented with a double-linked circular list
class CircularList[E]
# Like standard Array or LinkedList, CircularList is a Sequence.
super Sequence[E]
# The first node of the list if any
# The special case of an empty list is handled by a null node
private var node: nullable CLNode[E] = null
redef fun iterator do return new CircularListIterator[E](self)
redef fun first do return self.node.item
redef fun push(e)
do
var new_node = new CLNode[E](e)
var n = self.node
if n == null then
# the first node
self.node = new_node
else
# not the first one, so attach nodes correctly.
var old_last_node = n.prev
new_node.next = n
new_node.prev = old_last_node
old_last_node.next = new_node
n.prev = new_node
end
end
redef fun pop
do
var n = self.node
assert n != null
var prev = n.prev
if prev == n then
# the only node
self.node = null
return n.item
end
# not the only one do detach nodes correctly.
var prev_prev = prev.prev
n.prev = prev_prev
prev_prev.next = n
return prev.item
end
redef fun unshift(e)
do
# Circularity has benefits.
push(e)
self.node = self.node.prev
end
redef fun shift
do
# Circularity has benefits.
self.node = self.node.next
return self.pop
end
# Move the first at the last position, the second at the first, etc.
fun rotate
do
var n = self.node
if n == null then return
self.node = n.next
end
# Sort the list using the Josephus algorithm.
fun josephus(step: Int)
do
var res = new CircularList[E]
while not self.is_empty do
# count 'step'
for i in [1..step[ do self.rotate
# kill
var x = self.shift
res.add(x)
end
self.node = res.node
end
end
# Nodes of a CircularList
private class CLNode[E]
# The current item
var item: E
# The next item in the circular list.
# Because of circularity, there is always a next;
# so by default let it be self
var next: CLNode[E] = self
# The previous item in the circular list.
# Coherence between next and previous nodes has to be maintained by the
# circular list.
var prev: CLNode[E] = self
end
# An iterator of a CircularList.
private class CircularListIterator[E]
super IndexedIterator[E]
redef var index: Int
# The current node pointed.
# Is null if the list is empty.
var node: nullable CLNode[E]
# The list iterated.
var list: CircularList[E]
redef fun is_ok
do
# Empty lists are not OK.
# Pointing again the first node is not OK.
return self.node != null and (self.index == 0 or self.node != self.list.node)
end
redef fun next
do
self.node = self.node.next
self.index += 1
end
redef fun item do return self.node.item
init(list: CircularList[E])
do
self.node = list.node
self.list = list
self.index = 0
end
end
var i = new CircularList[Int]
i.add_all([1, 2, 3, 4, 5, 6, 7])
print i.first
print i.join(":")
i.push(8)
print i.shift
print i.pop
i.unshift(0)
print i.join(":")
i.josephus(3)
print i.join(":")

78
samples/Nit/clock.nit Normal file
View File

@@ -0,0 +1,78 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.
# This module provide a simple wall clock.
# It is an example of getters and setters.
# A beefed-up module is available in clock_more
module clock
# A simple wall clock with 60 minutes and 12 hours.
class Clock
# total number of minutes from 0 to 719
var total_minutes: Int
# Note: only the read acces is public, the write access is private.
# number of minutes in the current hour (from 0 to 59)
fun minutes: Int do return self.total_minutes % 60
# set the number of minutes in the current hour.
# if m < 0 or m >= 60, the hour will be changed accordinlgy
fun minutes=(m: Int) do self.total_minutes = self.hours * 60 + m
# number of hours (from 0 to 11)
fun hours: Int do return self.total_minutes / 60
# set the number of hours
# the minutes will not be updated
fun hours=(h: Int) do self.total_minutes = h * 60 + minutes
# the position of the hour arrow in the [0..60[ interval
fun hour_pos: Int do return total_minutes / 12
# replace the arrow of hours (from 0 to 59).
# the hours and the minutes will be updated.
fun hour_pos=(h: Int) do self.total_minutes = h * 12
redef fun to_s do return "{hours}:{minutes}"
fun reset(hours, minutes: Int) do self.total_minutes = hours*60 + minutes
init(hours, minutes: Int) do self.reset(hours, minutes)
redef fun ==(o)
do
# Note: o is a nullable Object, a type test is required
# Thanks to adaptive typing, there is no downcast
# i.e. the code is safe!
return o isa Clock and self.total_minutes == o.total_minutes
end
end
var c = new Clock(10,50)
print "It's {c} o'clock."
c.minutes += 22
print "Now it's {c} o'clock."
print "The short arrow in on the {c.hour_pos/5} and the long arrow in on the {c.minutes/5}."
c.hours -= 2
print "Now it's {c} o'clock."
var c2 = new Clock(9, 11)
print "It's {c2} on the second clock."
print "The two clocks are synchronized: {c == c2}."
c2.minutes += 1
print "It's now {c2} on the second clock."
print "The two clocks are synchronized: {c == c2}."

View File

@@ -0,0 +1,60 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.
# This module beef up the clock module by allowing a clock to be comparable.
# It show the usage of class refinement
module clock_more
import clock
redef class Clock
# Clock are now comparable
super Comparable
# Comparaison of a clock make only sense with an other clock
redef type OTHER: Clock
redef fun <(o)
do
# Note: < is the only abstract method of Comparable.
# All other operators and methods rely on < and ==.
return self.total_minutes < o.total_minutes
end
end
var c1 = new Clock(8, 12)
var c2 = new Clock(8, 13)
var c3 = new Clock(9, 13)
print "{c1}<{c2}? {c1<c2}"
print "{c1}<={c2}? {c1<=c2}"
print "{c1}>{c2}? {c1>c2}"
print "{c1}>={c2}? {c1>=c2}"
print "{c1}<=>{c2}? {c1<=>c2}"
print "{c1},{c2}? max={c1.max(c2)} min={c1.min(c2)}"
print "{c1}.is_between({c2}, {c3})? {c1.is_between(c2, c3)}"
print "{c2}.is_between({c1}, {c3})? {c2.is_between(c1, c3)}"
print "-"
c1.minutes += 1
print "{c1}<{c2}? {c1<c2}"
print "{c1}<={c2}? {c1<=c2}"
print "{c1}>{c2}? {c1>c2}"
print "{c1}>={c2}? {c1>=c2}"
print "{c1}<=>{c2}? {c1<=>c2}"
print "{c1},{c2}? max={c1.max(c2)} min={c1.min(c2)}"
print "{c1}.is_between({c2}, {c3})? {c1.is_between(c2, c3)}"
print "{c2}.is_between({c1}, {c3})? {c2.is_between(c1, c3)}"

113
samples/Nit/curl_http.nit Normal file
View File

@@ -0,0 +1,113 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# Sample of the Curl module.
module curl_http
import curl
# Small class to represent an Http Fetcher
class MyHttpFetcher
super CurlCallbacks
var curl: Curl
var our_body: String = ""
init(curl: Curl) do self.curl = curl
# Release curl object
fun destroy do self.curl.destroy
# Header callback
redef fun header_callback(line: String) do
# We keep this callback silent for testing purposes
#if not line.has_prefix("Date:") then print "Header_callback : {line}"
end
# Body callback
redef fun body_callback(line: String) do self.our_body = "{self.our_body}{line}"
# Stream callback - Cf : No one is registered
redef fun stream_callback(buffer: String, size: Int, count: Int) do print "Stream_callback : {buffer} - {size} - {count}"
end
# Program
if args.length < 2 then
print "Usage: curl_http <method wished [POST, GET, GET_FILE]> <target url>"
else
var curl = new Curl
var url = args[1]
var request = new CurlHTTPRequest(url, curl)
# HTTP Get Request
if args[0] == "GET" then
request.verbose = false
var getResponse = request.execute
if getResponse isa CurlResponseSuccess then
print "Status code : {getResponse.status_code}"
print "Body : {getResponse.body_str}"
else if getResponse isa CurlResponseFailed then
print "Error code : {getResponse.error_code}"
print "Error msg : {getResponse.error_msg}"
end
# HTTP Post Request
else if args[0] == "POST" then
var myHttpFetcher = new MyHttpFetcher(curl)
request.delegate = myHttpFetcher
var postDatas = new HeaderMap
postDatas["Bugs Bunny"] = "Daffy Duck"
postDatas["Batman"] = "Robin likes special characters @#ùà!è§'(\"é&://,;<>∞~*"
postDatas["Batman"] = "Yes you can set multiple identical keys, but APACHE will consider only once, the last one"
request.datas = postDatas
request.verbose = false
var postResponse = request.execute
print "Our body from the callback : {myHttpFetcher.our_body}"
if postResponse isa CurlResponseSuccess then
print "*** Answer ***"
print "Status code : {postResponse.status_code}"
print "Body should be empty, because we decided to manage callbacks : {postResponse.body_str.length}"
else if postResponse isa CurlResponseFailed then
print "Error code : {postResponse.error_code}"
print "Error msg : {postResponse.error_msg}"
end
# HTTP Get to file Request
else if args[0] == "GET_FILE" then
var headers = new HeaderMap
headers["Accept"] = "Moo"
request.headers = headers
request.verbose = false
var downloadResponse = request.download_to_file(null)
if downloadResponse isa CurlFileResponseSuccess then
print "*** Answer ***"
print "Status code : {downloadResponse.status_code}"
print "Size downloaded : {downloadResponse.size_download}"
else if downloadResponse isa CurlResponseFailed then
print "Error code : {downloadResponse.error_code}"
print "Error msg : {downloadResponse.error_msg}"
end
# Program logic
else
print "Usage : Method[POST, GET, GET_FILE]"
end
end

59
samples/Nit/curl_mail.nit Normal file
View File

@@ -0,0 +1,59 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# Mail sender sample using the Curl module
module curl_mail
import curl
var curl = new Curl
var mail_request = new CurlMailRequest(curl)
# Networks
var response = mail_request.set_outgoing_server("smtps://smtp.example.org:465", "user@example.org", "mypassword")
if response isa CurlResponseFailed then
print "Error code : {response.error_code}"
print "Error msg : {response.error_msg}"
end
# Headers
mail_request.from = "Billy Bob"
mail_request.to = ["user@example.org"]
mail_request.cc = ["bob@example.org"]
mail_request.bcc = null
var headers_body = new HeaderMap
headers_body["Content-Type:"] = "text/html; charset=\"UTF-8\""
headers_body["Content-Transfer-Encoding:"] = "quoted-printable"
mail_request.headers_body = headers_body
# Content
mail_request.body = "<h1>Here you can write HTML stuff.</h1>"
mail_request.subject = "Hello From My Nit Program"
# Others
mail_request.verbose = false
# Send mail
response = mail_request.execute
if response isa CurlResponseFailed then
print "Error code : {response.error_code}"
print "Error msg : {response.error_msg}"
else if response isa CurlMailResponseSuccess then
print "Mail Sent"
else
print "Unknown Curl Response type"
end

View File

@@ -0,0 +1,243 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2012-2013 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.
# Draws an arithmetic operation to the terminal
module draw_operation
redef enum Int
fun n_chars: Int `{
int c;
if ( abs(recv) >= 10 )
c = 1+(int)log10f( (float)abs(recv) );
else
c = 1;
if ( recv < 0 ) c ++;
return c;
`}
end
redef enum Char
fun as_operator(a, b: Int): Int
do
if self == '+' then return a + b
if self == '-' then return a - b
if self == '*' then return a * b
if self == '/' then return a / b
if self == '%' then return a % b
abort
end
fun override_dispc: Bool
do
return self == '+' or self == '-' or self == '*' or self == '/' or self == '%'
end
fun lines(s: Int): Array[Line]
do
if self == '+' then
return [new Line(new P(0,s/2),1,0,s), new Line(new P(s/2,1),0,1,s-2)]
else if self == '-' then
return [new Line(new P(0,s/2),1,0,s)]
else if self == '*' then
var lines = new Array[Line]
for y in [1..s-1[ do
lines.add( new Line(new P(1,y), 1,0,s-2) )
end
return lines
else if self == '/' then
return [new Line(new P(s-1,0), -1,1, s )]
else if self == '%' then
var q4 = s/4
var lines = [new Line(new P(s-1,0),-1,1,s)]
for l in [0..q4[ do
lines.append([ new Line( new P(0,l), 1,0,q4), new Line( new P(s-1,s-1-l), -1,0,q4) ])
end
return lines
else if self == '1' then
return [new Line(new P(s/2,0), 0,1,s),new Line(new P(0,s-1),1,0,s),
new Line( new P(s/2,0),-1,1,s/2)]
else if self == '2' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,0),0,1,s/2),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,s/2), 0,1,s/2),
new Line( new P(0,s/2), 1,0,s)]
else if self == '3' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,0),0,1,s),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,s/2), 1,0,s)]
else if self == '4' then
return [new Line(new P(s-1,0),0,1,s), new Line( new P(0,0), 0,1,s/2),
new Line( new P(0,s/2), 1,0,s)]
else if self == '5' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,s/2),0,1,s/2),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,0), 0,1,s/2),
new Line( new P(0,s/2), 1,0,s)]
else if self == '6' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,s/2),0,1,s/2),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,0), 0,1,s),
new Line( new P(0,s/2), 1,0,s)]
else if self == '7' then
var tl = new P(0,0)
var tr = new P(s-1,0)
return [new Line(tl, 1,0,s), new Line(tr,-1,1,s)]
else if self == '8' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,0),0,1,s),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,0), 0,1,s),
new Line( new P(0,s/2), 1,0,s)]
else if self == '9' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,0),0,1,s),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,0), 0,1,s/2),
new Line( new P(0,s/2), 1,0,s)]
else if self == '0' then
return [new Line(new P(0,0), 1,0,s),new Line(new P(s-1,0),0,1,s),
new Line( new P(0,s-1),1,0,s), new Line( new P(0,0), 0,1,s)]
end
return new Array[Line]
end
end
class P
var x : Int
var y : Int
end
redef class String
# hack is to support a bug in the evaluation software
fun draw(dispc: Char, size, gap: Int, hack: Bool)
do
var w = size * length +(length-1)*gap
var h = size
var map = new Array[Array[Char]]
for x in [0..w[ do
map[x] = new Array[Char].filled_with( ' ', h )
end
var ci = 0
for c in self.chars do
var local_dispc
if c.override_dispc then
local_dispc = c
else
local_dispc = dispc
end
var lines = c.lines( size )
for line in lines do
var x = line.o.x+ci*size
x += ci*gap
var y = line.o.y
for s in [0..line.len[ do
assert map.length > x and map[x].length > y else print "setting {x},{y} as {local_dispc}"
map[x][y] = local_dispc
x += line.step_x
y += line.step_y
end
end
ci += 1
end
if hack then
for c in [0..size[ do
map[c][0] = map[map.length-size+c][0]
map[map.length-size+c][0] = ' '
end
end
for y in [0..h[ do
for x in [0..w[ do
printn map[x][y]
end
print ""
end
end
end
class Line
var o : P
var step_x : Int
var step_y : Int
var len : Int
end
var a
var b
var op_char
var disp_char
var disp_size
var disp_gap
if "NIT_TESTING".environ == "true" then
a = 567
b = 13
op_char = '*'
disp_char = 'O'
disp_size = 8
disp_gap = 1
else
printn "Left operand: "
a = gets.to_i
printn "Right operand: "
b = gets.to_i
printn "Operator (+, -, *, /, %): "
op_char = gets.chars[0]
printn "Char to display: "
disp_char = gets.chars[0]
printn "Size of text: "
disp_size = gets.to_i
printn "Space between digits: "
disp_gap = gets.to_i
end
var result = op_char.as_operator( a, b )
var len_a = a.n_chars
var len_b = b.n_chars
var len_res = result.n_chars
var max_len = len_a.max( len_b.max( len_res ) ) + 1
# draw first line
var d = max_len - len_a
var line_a = ""
for i in [0..d[ do line_a += " "
line_a += a.to_s
line_a.draw( disp_char, disp_size, disp_gap, false )
print ""
# draw second line
d = max_len - len_b-1
var line_b = op_char.to_s
for i in [0..d[ do line_b += " "
line_b += b.to_s
line_b.draw( disp_char, disp_size, disp_gap, false )
# draw -----
print ""
for i in [0..disp_size*max_len+(max_len-1)*disp_gap] do
printn "_"
end
print ""
print ""
# draw result
d = max_len - len_res
var line_res = ""
for i in [0..d[ do line_res += " "
line_res += result.to_s
line_res.draw( disp_char, disp_size, disp_gap, false )

View File

@@ -0,0 +1,46 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.
# Example using the privileges module to drop privileges from root
module drop_privileges
import privileges
# basic command line options
var opts = new OptionContext
var opt_ug = new OptionUserAndGroup.for_dropping_privileges
opt_ug.mandatory = true
opts.add_option(opt_ug)
# parse and check command line options
opts.parse(args)
if not opts.errors.is_empty then
print opts.errors
print "Usage: drop_privileges [options]"
opts.usage
exit 1
end
# original user
print "before {sys.uid}:{sys.gid}"
# make the switch
var user_group = opt_ug.value
assert user_group != null
user_group.drop_privileges
# final user
print "after {sys.uid}:{sys.egid}"

View File

@@ -0,0 +1,69 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2012-2013 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.
# This module illustrates some uses of the FFI, specifically
# how to use extern methods. Which means to implement a Nit method in C.
module extern_methods
redef enum Int
# Returns self'th fibonnaci number
# implemented here in C for optimization purposes
fun fib : Int import fib `{
if ( recv < 2 )
return recv;
else
return Int_fib( recv-1 ) + Int_fib( recv-2 );
`}
# System call to sleep for "self" seconds
fun sleep `{
sleep( recv );
`}
# Return atan2l( self, x ) from libmath
fun atan_with( x : Int ) : Float `{
return atan2( recv, x );
`}
# This method callback to Nit methods from C code
# It will use from C code:
# * the local fib method
# * the + operator, a method of Int
# * to_s, a method of all objects
# * String.to_cstring, a method of String to return an equivalent char*
fun foo import fib, +, to_s, String.to_cstring `{
long recv_fib = Int_fib( recv );
long recv_plus_fib = Int__plus( recv, recv_fib );
String nit_string = Int_to_s( recv_plus_fib );
char *c_string = String_to_cstring( nit_string );
printf( "from C: self + fib(self) = %s\n", c_string );
`}
# Equivalent to foo but written in pure Nit
fun bar do print "from Nit: self + fib(self) = {self+self.fib}"
end
print 12.fib
print "sleeping 1 second..."
1.sleep
print 100.atan_with( 200 )
8.foo
8.bar

43
samples/Nit/fibonacci.nit Normal file
View File

@@ -0,0 +1,43 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2004-2008 Jean Privat <jean@pryen.org>
#
# 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.
# A simple exemple of refinement where a method is added to the integer class.
module fibonacci
redef class Int
# Calculate the self-th element of the fibonacci sequence.
fun fibonacci: Int
do
if self < 2 then
return 1
else
return (self-2).fibonacci + (self-1).fibonacci
end
end
end
# Print usage and exit.
fun usage
do
print "Usage: fibonnaci <integer>"
exit 0
end
# Main part
if args.length != 1 then
usage
end
print args.first.to_i.fibonacci

View File

@@ -0,0 +1 @@
print "hello world"

105
samples/Nit/html_page.nit Normal file
View File

@@ -0,0 +1,105 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.
import html
class NitHomepage
super HTMLPage
redef fun head do
add("meta").attr("charset", "utf-8")
add("title").text("Nit")
add("link").attr("rel", "icon").attr("href", "http://nitlanguage.org/favicon.ico").attr("type", "image/x-icon")
add("link").attr("rel", "stylesheet").attr("href", "http://nitlanguage.org/style.css").attr("type", "text/css")
add("link").attr("rel", "stylesheet").attr("href", "http://nitlanguage.org/local.css").attr("type", "text/css")
end
redef fun body do
open("article").add_class("page")
open("section").add_class("pageheader")
add_html("<a id='toptitle_first' class='toptitle'>the</a><a id='toptitle_second' class='toptitle' href=''>Nit</a><a id='toptitle_third' class='toptitle' href=''>Programming Language</a>")
open("header").add_class("header")
open("div").add_class("topsubtitle")
add("p").text("A Fun Language for Serious Programming")
close("div")
close("header")
close("section")
open("div").attr("id", "pagebody")
open("section").attr("id", "content")
add("h1").text("# What is Nit?")
add("p").text("Nit is an object-oriented programming language. The goal of Nit is to propose a robust statically typed programming language where structure is not a pain.")
add("p").text("So, what does the famous hello world program look like, in Nit?")
add_html("<pre><tt><span class='normal'>print </span><span class='string'>'Hello, World!'</span></tt></pre>")
add("h1").text("# Feature Highlights")
add("h2").text("Usability")
add("p").text("Nit's goal is to be usable by real programmers for real projects")
open("ul")
open("li")
add("a").attr("href", "http://en.wikipedia.org/wiki/KISS_principle").text("KISS principle")
close("li")
add("li").text("Script-like language without verbosity nor cryptic statements")
add("li").text("Painless static types: static typing should help programmers")
add("li").text("Efficient development, efficient execution, efficient evolution.")
close("ul")
add("h2").text("Robustness")
add("p").text("Nit will help you to write bug-free programs")
open("ul")
add("li").text("Strong static typing")
add("li").text("No more NullPointerException")
close("ul")
add("h2").text("Object-Oriented")
add("p").text("Nit's guideline is to follow the most powerful OO principles")
open("ul")
open("li")
add("a").attr("href", "./everything_is_an_object/").text("Everything is an object")
close("li")
open("li")
add("a").attr("href", "./multiple_inheritance/").text("Multiple inheritance")
close("li")
open("li")
add("a").attr("href", "./refinement/").text("Open classes")
close("li")
open("li")
add("a").attr("href", "./virtual_types/").text("Virtual types")
close("li")
close("ul")
add("h1").text("# Getting Started")
add("p").text("Get Nit from its Git repository:")
add_html("<pre><code>$ git clone http://nitlanguage.org/nit.git</code></pre>")
add("p").text("Build the compiler (may be long):")
add_html("<pre><code>$ cd nit\n")
add_html("$ make</code></pre>")
add("p").text("Compile a program:")
add_html("<pre><code>$ bin/nitc examples/hello_world.nit</code></pre>")
add("p").text("Execute the program:")
add_html("<pre><code>$ ./hello_world</code></pre>")
close("section")
close("div")
close("article")
end
end
var page = new NitHomepage
page.write_to stdout
page.write_to_file("nit.html")

100
samples/Nit/int_stack.nit Normal file
View File

@@ -0,0 +1,100 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# 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.
# An example that defines and uses stacks of integers.
# The implementation is done with a simple linked list.
# It features: free constructors, nullable types and some adaptive typing.
module int_stack
# A stack of integer implemented by a simple linked list.
# Note that this is only a toy class since a real linked list will gain to use
# generics and extends interfaces, like Collection, from the standard library.
class IntStack
# The head node of the list.
# Null means that the stack is empty.
private var head: nullable ISNode = null
# Add a new integer in the stack.
fun push(val: Int)
do
self.head = new ISNode(val, self.head)
end
# Remove and return the last pushed integer.
# Return null if the stack is empty.
fun pop: nullable Int
do
var head = self.head
if head == null then return null
# Note: the followings are statically safe because of the
# previous 'if'.
var val = head.val
self.head = head.next
return val
end
# Return the sum of all integers of the stack.
# Return 0 if the stack is empty.
fun sumall: Int
do
var sum = 0
var cur = self.head
while cur != null do
# Note: the followings are statically safe because of
# the condition of the 'while'.
sum += cur.val
cur = cur.next
end
return sum
end
# Note: Because all attributes have a default value, a free constructor
# "init()" is implicitly defined.
end
# A node of a IntStack
private class ISNode
# The integer value stored in the node.
var val: Int
# The next node, if any.
var next: nullable ISNode
# Note: A free constructor "init(val: Int, next: nullable ISNode)" is
# implicitly defined.
end
var l = new IntStack
l.push(1)
l.push(2)
l.push(3)
print l.sumall
# Note: the 'for' control structure cannot be used on IntStack in its current state.
# It requires a more advanced topic.
# However, why not using the 'loop' control structure?
loop
var i = l.pop
if i == null then break
# The following is statically safe because of the previous 'if'.
print i * 10
end
# Note: 'or else' is used to give an alternative of a null expression.
l.push(5)
print l.pop or else 0 # l.pop gives 5, so print 5
print l.pop or else 0 # l.pop gives null, so print the alternative: 0

View File

@@ -0,0 +1,193 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
#
# 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.
# Basic example of OpenGL ES 2.0 usage from the book OpenGL ES 2.0 Programming Guide.
#
# Code reference:
# https://code.google.com/p/opengles-book-samples/source/browse/trunk/LinuxX11/Chapter_2/Hello_Triangle/Hello_Triangle.c
module opengles2_hello_triangle
import glesv2
import egl
import mnit_linux # for sdl
import x11
if "NIT_TESTING".environ == "true" then exit(0)
var window_width = 800
var window_height = 600
#
## SDL
#
var sdl_display = new SDLDisplay(window_width, window_height)
var sdl_wm_info = new SDLSystemWindowManagerInfo
var x11_window_handle = sdl_wm_info.x11_window_handle
#
## X11
#
var x_display = x_open_default_display
assert x_display != 0 else print "x11 fail"
#
## EGL
#
var egl_display = new EGLDisplay(x_display)
assert egl_display.is_valid else print "EGL display is not valid"
egl_display.initialize
print "EGL version: {egl_display.version}"
print "EGL vendor: {egl_display.vendor}"
print "EGL extensions: {egl_display.extensions.join(", ")}"
print "EGL client APIs: {egl_display.client_apis.join(", ")}"
assert egl_display.is_valid else print egl_display.error
var config_chooser = new EGLConfigChooser
#config_chooser.surface_type_egl
config_chooser.blue_size = 8
config_chooser.green_size = 8
config_chooser.red_size = 8
#config_chooser.alpha_size = 8
#config_chooser.depth_size = 8
#config_chooser.stencil_size = 8
#config_chooser.sample_buffers = 1
config_chooser.close
var configs = config_chooser.choose(egl_display)
assert configs != null else print "choosing config failed: {egl_display.error}"
assert not configs.is_empty else print "no EGL config"
print "{configs.length} EGL configs available"
for config in configs do
var attribs = config.attribs(egl_display)
print "* caveats: {attribs.caveat}"
print " conformant to: {attribs.conformant}"
print " size of RGBA: {attribs.red_size} {attribs.green_size} {attribs.blue_size} {attribs.alpha_size}"
print " buffer, depth, stencil: {attribs.buffer_size} {attribs.depth_size} {attribs.stencil_size}"
end
var config = configs.first
var format = config.attribs(egl_display).native_visual_id
# TODO android part
# Opengles1Display_midway_init(recv, format);
var surface = egl_display.create_window_surface(config, x11_window_handle, [0])
assert surface.is_ok else print egl_display.error
var context = egl_display.create_context(config)
assert context.is_ok else print egl_display.error
var make_current_res = egl_display.make_current(surface, surface, context)
assert make_current_res
var width = surface.attribs(egl_display).width
var height = surface.attribs(egl_display).height
print "Width: {width}"
print "Height: {height}"
assert egl_bind_opengl_es_api else print "eglBingAPI failed: {egl_display.error}"
#
## GLESv2
#
print "Can compile shaders? {gl_shader_compiler}"
assert_no_gl_error
assert gl_shader_compiler else print "Cannot compile shaders"
# gl program
print gl_error.to_s
var program = new GLProgram
if not program.is_ok then
print "Program is not ok: {gl_error.to_s}\nLog:"
print program.info_log
abort
end
assert_no_gl_error
# vertex shader
var vertex_shader = new GLVertexShader
assert vertex_shader.is_ok else print "Vertex shader is not ok: {gl_error}"
vertex_shader.source = """
attribute vec4 vPosition;
void main()
{
gl_Position = vPosition;
} """
vertex_shader.compile
assert vertex_shader.is_compiled else print "Vertex shader compilation failed with: {vertex_shader.info_log} {program.info_log}"
assert_no_gl_error
# fragment shader
var fragment_shader = new GLFragmentShader
assert fragment_shader.is_ok else print "Fragment shader is not ok: {gl_error}"
fragment_shader.source = """
precision mediump float;
void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
"""
fragment_shader.compile
assert fragment_shader.is_compiled else print "Fragment shader compilation failed with: {fragment_shader.info_log}"
assert_no_gl_error
program.attach_shader vertex_shader
program.attach_shader fragment_shader
program.bind_attrib_location(0, "vPosition")
program.link
assert program.is_linked else print "Linking failed: {program.info_log}"
assert_no_gl_error
# draw!
var vertices = [0.0, 0.5, 0.0, -0.5, -0.5, 0.0, 0.5, -0.5, 0.0]
var vertex_array = new VertexArray(0, 3, vertices)
vertex_array.attrib_pointer
gl_clear_color(0.5, 0.0, 0.5, 1.0)
for i in [0..10000[ do
printn "."
assert_no_gl_error
gl_viewport(0, 0, width, height)
gl_clear_color_buffer
program.use
vertex_array.enable
vertex_array.draw_arrays_triangles
egl_display.swap_buffers(surface)
end
# delete
program.delete
vertex_shader.delete
fragment_shader.delete
#
## EGL
#
# close
egl_display.make_current(new EGLSurface.none, new EGLSurface.none, new EGLContext.none)
egl_display.destroy_context(context)
egl_display.destroy_surface(surface)
#
## SDL
#
# close
sdl_display.destroy

View File

@@ -0,0 +1,22 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2004-2008 Jean Privat <jean@pryen.org>
#
# 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.
# How to print arguments of the command line.
module print_arguments
for a in args do
print a
end

View File

@@ -0,0 +1,48 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2004-2008 Jean Privat <jean@pryen.org>
#
# 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.
# A procedural program (without explicit class definition).
# This program manipulates arrays of integers.
module procedural_array
# The sum of the elements of `a'.
# Uses a 'for' control structure.
fun array_sum(a: Array[Int]): Int
do
var sum = 0
for i in a do
sum = sum + i
end
return sum
end
# The sum of the elements of `a' (alternative version).
# Uses a 'while' control structure.
fun array_sum_alt(a: Array[Int]): Int
do
var sum = 0
var i = 0
while i < a.length do
sum = sum + a[i]
i = i + 1
end
return sum
end
# The main part of the program.
var a = [10, 5, 8, 9]
print(array_sum(a))
print(array_sum_alt(a))

View File

@@ -0,0 +1,38 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# Client sample using the Socket module which connect to the server sample.
module socket_client
import socket
if args.length < 2 then
print "Usage : socket_client <host> <port>"
return
end
var s = new Socket.client(args[0], args[1].to_i)
print "[HOST ADDRESS] : {s.address}"
print "[HOST] : {s.host}"
print "[PORT] : {s.port}"
print "Connecting ... {s.connected}"
if s.connected then
print "Writing ... Hello server !"
s.write("Hello server !")
print "[Response from server] : {s.read(100)}"
print "Closing ..."
s.close
end

View File

@@ -0,0 +1,52 @@
# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2013 Matthieu Lucas <lucasmatthieu@gmail.com>
#
# 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.
# Server sample using the Socket module which allow client to connect
module socket_server
import socket
if args.is_empty then
print "Usage : socket_server <port>"
return
end
var socket = new Socket.server(args[0].to_i, 1)
print "[PORT] : {socket.port.to_s}"
var clients = new Array[Socket]
var max = socket
loop
var fs = new SocketObserver(true, true, true)
fs.readset.set(socket)
for c in clients do fs.readset.set(c)
if fs.select(max, 4, 0) == 0 then
print "Error occured in select {sys.errno.strerror}"
break
end
if fs.readset.is_set(socket) then
var ns = socket.accept
print "Accepting {ns.address} ... "
print "[Message from {ns.address}] : {ns.read(100)}"
ns.write("Goodbye client.")
print "Closing {ns.address} ..."
ns.close
end
end

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