mirror of
https://github.com/KevinMidboe/linguist.git
synced 2026-03-11 08:26:13 +00:00
Merge branch 'master' into dcl
This commit is contained in:
Arfon Smith
25
samples/AMPL/toy.ampl
Normal file
25
samples/AMPL/toy.ampl
Normal file
@@ -0,0 +1,25 @@
|
||||
# A toy knapsack problem from the LocalSolver docs written in AMPL.
|
||||
|
||||
set I;
|
||||
param Value{I};
|
||||
param Weight{I};
|
||||
param KnapsackBound;
|
||||
var Take{I} binary;
|
||||
|
||||
maximize TotalValue: sum{i in I} Take[i] * Value[i];
|
||||
s.t. WeightLimit: sum{i in I} Take[i] * Weight[i] <= KnapsackBound;
|
||||
|
||||
data;
|
||||
|
||||
param:
|
||||
I: Weight Value :=
|
||||
0 10 1
|
||||
1 60 10
|
||||
2 30 15
|
||||
3 40 40
|
||||
4 30 60
|
||||
5 20 90
|
||||
6 20 100
|
||||
7 2 15;
|
||||
|
||||
param KnapsackBound := 102;
|
||||
367
samples/APL/UT.dyalog
Normal file
367
samples/APL/UT.dyalog
Normal file
@@ -0,0 +1,367 @@
|
||||
:NameSpace UT
|
||||
|
||||
sac ← 0
|
||||
expect_orig ← expect ← ⎕NS⍬
|
||||
exception ← ⍬
|
||||
nexpect_orig ← nexpect ← ⎕NS⍬
|
||||
|
||||
∇ {Z}←{Conf}run Argument;PRE_test;POST_test;TEST_step;COVER_step;FromSpace
|
||||
|
||||
load_display_if_not_already_loaded
|
||||
load_salt_scripts_into_current_namespace_if_configured
|
||||
|
||||
FromSpace←1⊃⎕RSI
|
||||
|
||||
PRE_test←{}
|
||||
POST_test←{}
|
||||
COVER_step←{}
|
||||
:If 0≠⎕NC'Conf'
|
||||
:If Conf has'cover_target'
|
||||
PRE_test←{{}⎕PROFILE'start'}
|
||||
POST_test←{{}⎕PROFILE'stop'}
|
||||
:EndIf
|
||||
:EndIf
|
||||
|
||||
:If is_function Argument
|
||||
TEST_step←single_function_test_function
|
||||
COVER_file←Argument,'_coverage.html'
|
||||
|
||||
:ElseIf is_list_of_functions Argument
|
||||
TEST_step←list_of_functions_test_function
|
||||
COVER_file←'list_coverage.html'
|
||||
|
||||
:ElseIf is_file Argument
|
||||
TEST_step←file_test_function
|
||||
COVER_file←(get_file_name Argument),'_coverage.html'
|
||||
|
||||
:ElseIf is_dir Argument
|
||||
test_files←test_files_in_dir Argument
|
||||
TEST_step←test_dir_function
|
||||
Argument←test_files
|
||||
:EndIf
|
||||
|
||||
:If 0≠⎕NC'Conf'
|
||||
:If Conf has'cover_target'
|
||||
COVER_step←{Conf,←⊂('cover_file'COVER_file)
|
||||
generate_coverage_page Conf}
|
||||
:EndIf
|
||||
:EndIf
|
||||
|
||||
PRE_test ⍬
|
||||
Z←FromSpace TEST_step Argument
|
||||
POST_test ⍬
|
||||
COVER_step ⍬
|
||||
∇
|
||||
|
||||
∇ load_display_if_not_already_loaded
|
||||
:If 0=⎕NC'#.DISPLAY'
|
||||
'DISPLAY'#.⎕CY'display'
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ load_salt_scripts_into_current_namespace_if_configured
|
||||
:If 0≠⎕NC'#.UT.appdir'
|
||||
:If ⍬≢#.UT.appdir
|
||||
⎕SE.SALT.Load #.UT.appdir,'src/*.dyalog -target=#'
|
||||
⎕SE.SALT.Load #.UT.appdir,'test/*.dyalog -target=#'
|
||||
:EndIf
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ Z←FromSpace single_function_test_function TestName
|
||||
Z←run_ut FromSpace TestName
|
||||
∇
|
||||
|
||||
∇ Z←FromSpace list_of_functions_test_function ListOfNames;t
|
||||
t←⎕TS
|
||||
Z←run_ut¨{FromSpace ⍵}¨ListOfNames
|
||||
t←⎕TS-t
|
||||
('Test execution report')print_passed_crashed_failed Z t
|
||||
∇
|
||||
|
||||
∇ Z←FromSpace file_test_function FilePath;FileNS;Functions;TestFunctions;t
|
||||
FileNS←⎕SE.SALT.Load FilePath,' -target=#'
|
||||
Functions←↓FileNS.⎕NL 3
|
||||
TestFunctions←(is_test¨Functions)/Functions
|
||||
:If (0/⍬,⊂0/'')≡TestFunctions
|
||||
⎕←'No test functions found'
|
||||
Z←⍬
|
||||
:Else
|
||||
t←⎕TS
|
||||
Z←run_ut¨{FileNS ⍵}¨TestFunctions
|
||||
t←⎕TS-t
|
||||
(FilePath,' tests')print_passed_crashed_failed Z t
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ Z←FromSpace test_dir_function Test_files
|
||||
:If Test_files≡⍬/⍬,⊂''
|
||||
⎕←'No test files found'
|
||||
Z←⍬
|
||||
:Else
|
||||
Z←#.UT.run¨Test_files
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ Z←get_file_name Argument;separator
|
||||
separator←⊃⌽(Argument∊'/\')/⍳⍴Argument
|
||||
Z←¯7↓separator↓Argument
|
||||
∇
|
||||
|
||||
∇ generate_coverage_page Conf;ProfileData;CoverResults;HTML
|
||||
ProfileData←⎕PROFILE'data'
|
||||
ToCover←retrieve_coverables¨(⊃'cover_target'in Conf)
|
||||
:If (⍴ToCover)≡(⍴⊂1)
|
||||
ToCover←⊃ToCover
|
||||
:EndIf
|
||||
Representations←get_representation¨ToCover
|
||||
CoverResults←ProfileData∘generate_cover_result¨↓ToCover,[1.5]Representations
|
||||
HTML←generate_html CoverResults
|
||||
Conf write_html_to_page HTML
|
||||
⎕PROFILE'clear'
|
||||
∇
|
||||
|
||||
∇ Z←retrieve_coverables Something;nc;functions
|
||||
nc←⎕NC Something
|
||||
:If nc=3
|
||||
Z←Something
|
||||
:ElseIf nc=9
|
||||
functions←strip¨↓⍎Something,'.⎕NL 3'
|
||||
Z←{(Something,'.',⍵)}¨functions
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ Z←strip input
|
||||
Z←(input≠' ')/input
|
||||
∇
|
||||
|
||||
∇ Z←get_representation Function;nc;rep
|
||||
nc←⎕NC⊂Function
|
||||
:If nc=3.1
|
||||
rep←↓⎕CR Function
|
||||
rep[1]←⊂'∇',⊃rep[1]
|
||||
rep,←⊂'∇'
|
||||
rep←↑rep
|
||||
:Else
|
||||
rep←⎕CR Function
|
||||
:EndIf
|
||||
Z←rep
|
||||
∇
|
||||
|
||||
∇ Z←ProfileData generate_cover_result(name representation);Indices;lines;functionlines;covered_lines
|
||||
Indices←({name≡⍵}¨ProfileData[;1])/⍳⍴ProfileData[;1]
|
||||
lines←ProfileData[Indices;2]
|
||||
nc←⎕NC⊂name
|
||||
:If 3.1=nc
|
||||
functionlines←¯2+⍴↓representation
|
||||
:Else
|
||||
functionlines←⊃⍴↓representation
|
||||
:EndIf
|
||||
covered_lines←(⍬∘≢¨lines)/lines
|
||||
Z←(nc lines functionlines covered_lines representation)
|
||||
∇
|
||||
|
||||
∇ Z←generate_html CoverResults;Covered;Total;Percentage;CoverageText;ColorizedCode;Timestamp;Page
|
||||
Covered←⊃⊃+/{⍴4⊃⍵}¨CoverResults
|
||||
Total←⊃⊃+/{3⊃⍵}¨CoverResults
|
||||
Percentage←100×Covered÷Total
|
||||
CoverageText←'Coverage: ',Percentage,'% (',Covered,'/',Total,')'
|
||||
ColorizedCode←⊃,/{colorize_code_by_coverage ⍵}¨CoverResults
|
||||
Timestamp←generate_timestamp_text
|
||||
Page←⍬
|
||||
Page,←⊂⍬,'<html>'
|
||||
Page,←⊂⍬,'<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>'
|
||||
Page,←⊂⍬,'<style>pre cov {line-height:80%;}'
|
||||
Page,←⊂⍬,'pre cov {color: green;}'
|
||||
Page,←⊂⍬,'pre uncov {line-height:80%;}'
|
||||
Page,←⊂⍬,'pre uncov {color:red;}</style>'
|
||||
Page,←⊂⍬,CoverageText
|
||||
Page,←⊂⍬,'<pre>'
|
||||
Page,←ColorizedCode
|
||||
Page,←⊂⍬,'</pre>'
|
||||
Page,←Timestamp
|
||||
Page,←⊂⍬,'</html>'
|
||||
Z←Page
|
||||
∇
|
||||
|
||||
∇ Z←colorize_code_by_coverage CoverResult;Colors;Ends;Code
|
||||
:If 3.1=⊃CoverResult
|
||||
Colors←(2+3⊃CoverResult)⍴⊂'<uncov>'
|
||||
Colors[1]←⊂''
|
||||
Colors[⍴Colors]←⊂''
|
||||
Ends←(2+3⊃CoverResult)⍴⊂'</uncov>'
|
||||
Ends[1]←⊂''
|
||||
Ends[⍴Ends]←⊂''
|
||||
:Else
|
||||
Colors←(3⊃CoverResult)⍴⊂'<uncov>'
|
||||
Ends←(3⊃CoverResult)⍴⊂'</uncov>'
|
||||
:EndIf
|
||||
Colors[1+4⊃CoverResult]←⊂'<cov>'
|
||||
Ends[1+4⊃CoverResult]←⊂'</cov>'
|
||||
Code←↓5⊃CoverResult
|
||||
Z←Colors,[1.5]Code
|
||||
Z←{⍺,(⎕UCS 13),⍵}/Z,Ends
|
||||
∇
|
||||
|
||||
∇ Z←generate_timestamp_text;TS;YYMMDD;HHMMSS
|
||||
TS←⎕TS
|
||||
YYMMDD←⊃{⍺,'-',⍵}/3↑TS
|
||||
HHMMSS←⊃{⍺,':',⍵}/3↑3↓TS
|
||||
Z←'Page generated: ',YYMMDD,'|',HHMMSS
|
||||
∇
|
||||
|
||||
∇ Conf write_html_to_page Page;tie;filename
|
||||
filename←(⊃'cover_out'in Conf),(⊃'cover_file'in Conf)
|
||||
:Trap 22
|
||||
tie←filename ⎕NTIE 0
|
||||
filename ⎕NERASE tie
|
||||
filename ⎕NCREATE tie
|
||||
:Else
|
||||
tie←filename ⎕NCREATE 0
|
||||
:EndTrap
|
||||
Simple_array←⍕⊃,/Page
|
||||
(⎕UCS'UTF-8'⎕UCS Simple_array)⎕NAPPEND tie
|
||||
∇
|
||||
|
||||
∇ Z←is_function Argument
|
||||
Z←'_TEST'≡¯5↑Argument
|
||||
∇
|
||||
|
||||
∇ Z←is_list_of_functions Argument
|
||||
Z←2=≡Argument
|
||||
∇
|
||||
|
||||
∇ Z←is_file Argument
|
||||
Z←'.dyalog'≡¯7↑Argument
|
||||
∇
|
||||
|
||||
∇ Z←is_dir Argument;attr
|
||||
:If 'Linux'≡5↑⊃'.'⎕WG'APLVersion'
|
||||
Z←'yes'≡⊃⎕CMD'test -d ',Argument,' && echo yes || echo no'
|
||||
:Else
|
||||
'gfa'⎕NA'I kernel32|GetFileAttributes* <0t'
|
||||
:If Z←¯1≠attr←gfa⊂Argument ⍝ If file exists
|
||||
Z←⊃2 16⊤attr ⍝ Return bit 4
|
||||
:EndIf
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
|
||||
∇ Z←test_files_in_dir Argument
|
||||
:If 'Linux'≡5↑⊃'.'⎕WG'APLVersion'
|
||||
Z←⎕SH'find ',Argument,' -name \*_tests.dyalog'
|
||||
:Else
|
||||
#.⎕CY'files'
|
||||
Z←#.Files.Dir Argument,'\*_tests.dyalog'
|
||||
Z←(Argument,'\')∘,¨Z
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ Z←run_ut ut_data;returned;crashed;pass;crash;fail;message
|
||||
(returned crashed time)←execute_function ut_data
|
||||
(pass crash fail)←determine_pass_crash_or_fail returned crashed
|
||||
message←determine_message pass fail crashed(2⊃ut_data)returned time
|
||||
print_message_to_screen message
|
||||
Z←(pass crash fail)
|
||||
∇
|
||||
|
||||
∇ Z←execute_function ut_data;function;t
|
||||
reset_UT_globals
|
||||
function←(⍕(⊃ut_data[1])),'.',⊃ut_data[2]
|
||||
:Trap sac
|
||||
:If 3.2≡⎕NC⊂function
|
||||
t←⎕TS
|
||||
Z←(⍎function,' ⍬')0
|
||||
t←⎕TS-t
|
||||
:Else
|
||||
t←⎕TS
|
||||
Z←(⍎function)0
|
||||
t←⎕TS-t
|
||||
:EndIf
|
||||
|
||||
:Else
|
||||
Z←(↑⎕DM)1
|
||||
:If exception≢⍬
|
||||
expect←exception
|
||||
Z[2]←0
|
||||
t←⎕TS-t
|
||||
:EndIf
|
||||
:EndTrap
|
||||
Z,←⊂t
|
||||
∇
|
||||
|
||||
∇ reset_UT_globals
|
||||
expect_orig ← expect← ⎕NS⍬
|
||||
exception←⍬
|
||||
nexpect_orig ← nexpect← ⎕NS⍬
|
||||
∇
|
||||
|
||||
∇ Z←is_test FunctionName;wsIndex
|
||||
wsIndex←FunctionName⍳' '
|
||||
FunctionName←(wsIndex-1)↑FunctionName
|
||||
Z←'_TEST'≡¯5↑FunctionName
|
||||
∇
|
||||
|
||||
∇ Heading print_passed_crashed_failed(ArrayRes time)
|
||||
⎕←'-----------------------------------------'
|
||||
⎕←Heading
|
||||
⎕←' ⍋ Passed: ',+/{1⊃⍵}¨ArrayRes
|
||||
⎕←' ⍟ Crashed: ',+/{2⊃⍵}¨ArrayRes
|
||||
⎕←' ⍒ Failed: ',+/{3⊃⍵}¨ArrayRes
|
||||
⎕←' ○ Runtime: ',time[5],'m',time[6],'s',time[7],'ms'
|
||||
∇
|
||||
|
||||
determine_pass_crash_or_fail←{
|
||||
r c←⍵ ⋄ 0≠c:0 1 0 ⋄ z←(0 0 1)(1 0 0)
|
||||
expect_orig≢expect:(⎕IO+expect≡r)⊃z ⋄ (⎕IO+nexpect≢r)⊃z
|
||||
}
|
||||
|
||||
∇ Z←determine_message(pass fail crashed name returned time)
|
||||
:If crashed
|
||||
Z←'CRASHED: 'failure_message name returned
|
||||
:ElseIf pass
|
||||
Z←'Passed ',time[5],'m',time[6],'s',time[7],'ms'
|
||||
:Else
|
||||
Z←'FAILED: 'failure_message name returned
|
||||
:EndIf
|
||||
∇
|
||||
|
||||
∇ print_message_to_screen message
|
||||
⎕←message
|
||||
∇
|
||||
|
||||
∇ Z←term_to_text Term;Text;Rows
|
||||
Text←#.DISPLAY Term
|
||||
Rows←1⊃⍴Text
|
||||
Z←(Rows 4⍴''),Text
|
||||
∇
|
||||
|
||||
∇ Z←Cause failure_message(name returned);hdr;exp;expterm;got;gotterm
|
||||
hdr←Cause,name
|
||||
exp←'Expected'
|
||||
expterm←term_to_text #.UT.expect
|
||||
got←'Got'
|
||||
gotterm←term_to_text returned
|
||||
Z←align_and_join_message_parts hdr exp expterm got gotterm
|
||||
∇
|
||||
|
||||
∇ Z←align_and_join_message_parts Parts;hdr;exp;expterm;got;gotterm;R1;C1;R2;C2;W
|
||||
(hdr exp expterm got gotterm)←Parts
|
||||
(R1 C1)←⍴expterm
|
||||
(R2 C2)←⍴gotterm
|
||||
W←⊃⊃⌈/C1 C2(⍴hdr)(⍴exp)(⍴got)
|
||||
Z←(W↑hdr),[0.5](W↑exp)
|
||||
Z←Z⍪(R1 W↑expterm)
|
||||
Z←Z⍪(W↑got)
|
||||
Z←Z⍪(R2 W↑gotterm)
|
||||
∇
|
||||
|
||||
∇ Z←confparam in config
|
||||
Z←1↓⊃({confparam≡⊃⍵}¨config)/config
|
||||
∇
|
||||
|
||||
∇ Z←config has confparam
|
||||
Z←∨/{confparam≡⊃⍵}¨config
|
||||
∇
|
||||
|
||||
:EndNameSpace
|
||||
@@ -1,215 +0,0 @@
|
||||
%{
|
||||
#include "./../ATEXT/atextfun.hats"
|
||||
%}
|
||||
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
|
||||
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
|
||||
<head>
|
||||
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
|
||||
<title>EFFECTIVATS-DiningPhil2</title>
|
||||
#patscode_style()
|
||||
</head>
|
||||
|
||||
<body>
|
||||
|
||||
<h1>
|
||||
Effective ATS: Dining Philosophers
|
||||
</h1>
|
||||
|
||||
In this article, I present an implementation of a slight variant of the
|
||||
famous problem of 5-Dining-Philosophers by Dijkstra that makes simple but
|
||||
convincing use of linear types.
|
||||
|
||||
<h2>
|
||||
The Original Problem
|
||||
</h2>
|
||||
|
||||
There are five philosophers sitting around a table and there are also 5
|
||||
forks placed on the table such that each fork is located between the left
|
||||
hand of a philosopher and the right hand of another philosopher. Each
|
||||
philosopher does the following routine repeatedly: thinking and dining. In
|
||||
order to dine, a philosopher needs to first acquire two forks: one located
|
||||
on his left-hand side and the other on his right-hand side. After
|
||||
finishing dining, a philosopher puts the two acquired forks onto the table:
|
||||
one on his left-hand side and the other on his right-hand side.
|
||||
|
||||
<h2>
|
||||
A Variant of the Original Problem
|
||||
</h2>
|
||||
|
||||
The following twist is added to the original version:
|
||||
|
||||
<p>
|
||||
|
||||
After a fork is used, it becomes a "dirty" fork and needs to be put in a
|
||||
tray for dirty forks. There is a cleaner who cleans dirty forks and then
|
||||
puts them back on the table.
|
||||
|
||||
<h2>
|
||||
Channels for Communication
|
||||
</h2>
|
||||
|
||||
A channel is just a shared queue of fixed capacity. The following two
|
||||
functions are for inserting an element into and taking an element out of a
|
||||
given channel:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_sats("\
|
||||
fun{a:vt0p} channel_insert (channel (a), a): void
|
||||
fun{a:vt0p} channel_takeout (chan: channel (a)): (a)
|
||||
")</pre>
|
||||
|
||||
If [channel_insert] is called on a channel that is full, then the caller is
|
||||
blocked until an element is taken out of the channel. If [channel_takeout]
|
||||
is called on a channel that is empty, then the caller is blocked until an
|
||||
element is inserted into the channel.
|
||||
|
||||
<h2>
|
||||
A Channel for Each Fork
|
||||
</h2>
|
||||
|
||||
Forks are resources given a linear type. Each fork is initially stored in a
|
||||
channel, which can be obtained by calling the following function:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_sats("\
|
||||
fun fork_changet (n: nphil): channel(fork)
|
||||
")</pre>
|
||||
|
||||
where the type [nphil] is defined to be [natLt(5)] (for natural numbers
|
||||
less than 5). The channels for storing forks are chosen to be of capacity
|
||||
2. The reason that channels of capacity 2 are chosen to store at most one
|
||||
element (in each of them) is to guarantee that these channels can never be
|
||||
full (so that there is no attempt made to send signals to awake callers
|
||||
supposedly being blocked due to channels being full).
|
||||
|
||||
|
||||
<h2>
|
||||
A Channel for the Fork Tray
|
||||
</h2>
|
||||
|
||||
A tray for storing "dirty" forks is also a channel, which can be obtained
|
||||
by calling the following function:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_sats("\
|
||||
fun forktray_changet ((*void*)): channel(fork)
|
||||
")</pre>
|
||||
|
||||
The capacity chosen for the channel is 6 (instead of 5) so that it can
|
||||
never become full (as there are only 5 forks in total).
|
||||
|
||||
<h2>
|
||||
Philosopher Loop
|
||||
</h2>
|
||||
|
||||
Each philosopher is implemented as a loop:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_dats('\
|
||||
implement
|
||||
phil_loop (n) = let
|
||||
//
|
||||
val () = phil_think (n)
|
||||
//
|
||||
val nl = phil_left (n) // = n
|
||||
val nr = phil_right (n) // = (n+1) % 5
|
||||
//
|
||||
val ch_lfork = fork_changet (nl)
|
||||
val ch_rfork = fork_changet (nr)
|
||||
//
|
||||
val lf = channel_takeout (ch_lfork)
|
||||
val () = println! ("phil_loop(", n, ") picks left fork")
|
||||
//
|
||||
val () = randsleep (2) // sleep up to 2 seconds
|
||||
//
|
||||
val rf = channel_takeout (ch_rfork)
|
||||
val () = println! ("phil_loop(", n, ") picks right fork")
|
||||
//
|
||||
val () = phil_dine (n, lf, rf)
|
||||
//
|
||||
val ch_forktray = forktray_changet ()
|
||||
val () = channel_insert (ch_forktray, lf) // left fork to dirty tray
|
||||
val () = channel_insert (ch_forktray, rf) // right fork to dirty tray
|
||||
//
|
||||
in
|
||||
phil_loop (n)
|
||||
end // end of [phil_loop]
|
||||
')</pre>
|
||||
|
||||
It should be straighforward to follow the code for [phil_loop].
|
||||
|
||||
<h2>
|
||||
Fork Cleaner Loop
|
||||
</h2>
|
||||
|
||||
A cleaner is implemented as a loop:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_dats('\
|
||||
implement
|
||||
cleaner_loop () = let
|
||||
//
|
||||
val ch = forktray_changet ()
|
||||
val f0 = channel_takeout (ch) // [f0] is dirty
|
||||
//
|
||||
val () = cleaner_wash (f0) // washes dirty [f0]
|
||||
val () = cleaner_return (f0) // puts back cleaned [f0]
|
||||
//
|
||||
in
|
||||
cleaner_loop ()
|
||||
end // end of [cleaner_loop]
|
||||
')</pre>
|
||||
|
||||
The function [cleaner_return] first finds out the number of a given fork
|
||||
and then uses the number to locate the channel for storing the fork. Its
|
||||
actual implementation is given as follows:
|
||||
|
||||
<pre
|
||||
class="patsyntax">
|
||||
#pats2xhtml_dats('\
|
||||
implement
|
||||
cleaner_return (f) =
|
||||
{
|
||||
val n = fork_get_num (f)
|
||||
val ch = fork_changet (n)
|
||||
val () = channel_insert (ch, f)
|
||||
}
|
||||
')</pre>
|
||||
|
||||
It should now be straighforward to follow the code for [cleaner_loop].
|
||||
|
||||
<h2>
|
||||
Testing
|
||||
</h2>
|
||||
|
||||
The entire code of this implementation is stored in the following files:
|
||||
|
||||
<pre>
|
||||
DiningPhil2.sats
|
||||
DiningPhil2.dats
|
||||
DiningPhil2_fork.dats
|
||||
DiningPhil2_thread.dats
|
||||
</pre>
|
||||
|
||||
There is also a Makefile available for compiling the ATS source code into
|
||||
an excutable for testing. One should be able to encounter a deadlock after
|
||||
running the simulation for a while.
|
||||
|
||||
<hr size="2">
|
||||
|
||||
This article is written by <a href="http://www.cs.bu.edu/~hwxi/">Hongwei Xi</a>.
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
%{
|
||||
implement main () = fprint_filsub (stdout_ref, "main_atxt.txt")
|
||||
%}
|
||||
110
samples/Ant Build System/filenames/ant.xml
Normal file
110
samples/Ant Build System/filenames/ant.xml
Normal file
@@ -0,0 +1,110 @@
|
||||
<?xml version="1.0" encoding="iso-8859-1"?>
|
||||
<project name="WebBuild">
|
||||
|
||||
<!-- generate timestamps -->
|
||||
<tstamp />
|
||||
|
||||
<!-- Debugging Macro -->
|
||||
<import file="echopath.xml" />
|
||||
|
||||
<!-- JS build files macro -->
|
||||
<import file="rhinoscript.xml" />
|
||||
|
||||
<!-- Component Build Files -->
|
||||
<import file="setup.xml" />
|
||||
<import file="clean.xml" />
|
||||
<import file="copy.xml" />
|
||||
<import file="file.transform.xml" />
|
||||
<import file="external.tools.xml" />
|
||||
<import file="rename.xml" />
|
||||
<import file="js.xml" />
|
||||
<import file="css.xml" />
|
||||
<import file="img.xml" />
|
||||
<import file="png8.xml" />
|
||||
<import file="yui.xml" />
|
||||
<import file="cdn.xml" />
|
||||
<import file="datauri.xml" />
|
||||
<import file="devlive.xml" />
|
||||
|
||||
<!-- This dirname is the only complete path we know for sure, everything builds off of it -->
|
||||
<dirname property="dir.build" file="${ant.file.WebBuild}" />
|
||||
|
||||
<!-- get name for newly built folder -->
|
||||
<basename property="app.name" file="${basedir}" />
|
||||
|
||||
<!-- read global properties file -->
|
||||
<property file="${dir.build}\build.properties" />
|
||||
|
||||
<!-- Build Directories -->
|
||||
<property name="dir.build.js" location="${dir.build}/js" />
|
||||
|
||||
<!-- App Directories -->
|
||||
<property name="dir.app" location="${dir.result}/${app.name}" />
|
||||
<property name="dir.app.temp" location="${dir.temp}/${app.name}" />
|
||||
<property name="dir.app.files" location="${dir.app.temp}/${dir.files}" />
|
||||
|
||||
<!-- Files -->
|
||||
<property name="mapping.js" location="${dir.app.temp}/${mapping.file.js}" />
|
||||
<property name="mapping.css" location="${dir.app.temp}/${mapping.file.css}" />
|
||||
<property name="mapping.img" location="${dir.app.temp}/${mapping.file.img}" />
|
||||
<property name="mapping.swf" location="${dir.app.temp}/${mapping.file.swf}" />
|
||||
<property name="mapping.fonts" location="${dir.app.temp}/${mapping.file.fonts}" />
|
||||
|
||||
<!-- Tool Directories -->
|
||||
<property name="dir.bin" location="${dir.build}/Bin" />
|
||||
<property name="dir.jar" location="${dir.bin}/jar" />
|
||||
|
||||
<!-- Tool Files -->
|
||||
<property name="tools.compressor" location="${dir.jar}/${tools.file.compressor}" />
|
||||
<property name="tools.cssembed" location="${dir.jar}/${tools.file.cssembed}" />
|
||||
<property name="tools.filetransform" location="${dir.jar}/${tools.file.filetransform}" />
|
||||
<property name="tools.optipng" location="${dir.bin}/${tools.file.optipng}" />
|
||||
<property name="tools.jpegtran" location="${dir.bin}/${tools.file.jpegtran}" />
|
||||
|
||||
|
||||
<!-- BUILD TARGETS -->
|
||||
|
||||
<!-- low level utility build targets -->
|
||||
|
||||
<!-- Build the tools -->
|
||||
<target name="-setup.build.tools"
|
||||
depends="-define.filetransform, -define.cssembed, -define.yuicompressor, -define.jsclasspath"
|
||||
/>
|
||||
|
||||
<!-- set up filesystem properties -->
|
||||
<target
|
||||
name="-setup"
|
||||
depends="-setup.mode, -setup.conditions, -setup.js, -setup.css, -setup.swf, -setup.img, -setup.fonts, -setup.yui"
|
||||
/>
|
||||
|
||||
<!-- utility-ish targets -->
|
||||
<target name="copy" depends="clean, tools, -copy" />
|
||||
<target name="tools" depends="-setup.build.tools" />
|
||||
<target name="finalize" depends="copy, -finalize" />
|
||||
<target name="-prepare" depends="copy, -setup" />
|
||||
|
||||
<!-- individual component build targets (empty descriptions are to make sure they show in "ant -p") -->
|
||||
<target name="devlive" depends="-prepare, -devlive" description="" />
|
||||
<target name="js" depends="-prepare, -js" description="" />
|
||||
<target name="css" depends="-prepare, -css" description="" />
|
||||
<target name="rename" depends="-prepare, -rename" description="" />
|
||||
<target name="yui" depends="-prepare, rename, -yui" description="" />
|
||||
<target name="cdn" depends="-prepare, -cdn" description="" />
|
||||
|
||||
<!-- high level build targets (Excluding of images is on purpose here, it's slow) -->
|
||||
<target name="core"
|
||||
depends="devlive, js, css, cdn, rename, yui, -js.inline"
|
||||
description="Core build work"
|
||||
/>
|
||||
|
||||
<target name="prod"
|
||||
depends="core, finalize"
|
||||
description="Full Production Build"
|
||||
/>
|
||||
|
||||
<!-- debug target -->
|
||||
<target name="debug" depends="-setup">
|
||||
<echoproperties/>
|
||||
</target>
|
||||
|
||||
</project>
|
||||
1
samples/Ant Build System/filenames/build.xml
Symbolic link
1
samples/Ant Build System/filenames/build.xml
Symbolic link
@@ -0,0 +1 @@
|
||||
ant.xml
|
||||
66
samples/Assembly/External Interrupt.a51
Normal file
66
samples/Assembly/External Interrupt.a51
Normal file
@@ -0,0 +1,66 @@
|
||||
ORG 0000h
|
||||
SJMP START
|
||||
ORG 0003h
|
||||
LCALL INT0_ISR
|
||||
RETI
|
||||
ORG 000Bh
|
||||
LCALL T0_ISR
|
||||
RETI
|
||||
ORG 0013h
|
||||
LCALL INT1_ISR
|
||||
RETI
|
||||
ORG 001Bh
|
||||
LCALL T1_ISR
|
||||
RETI
|
||||
ORG 0023h
|
||||
LCALL UART_ISR
|
||||
RETI
|
||||
ORG 0030h
|
||||
START:
|
||||
MOV A,#11111110b
|
||||
SETB IT0 ; Set External Interrupt 0 to be falling edge triggered
|
||||
SETB EX0 ; Enable External Interrut 0
|
||||
SETB EA ; Enable Interrupt
|
||||
LEFT:
|
||||
CJNE A,#01111111b,LOOP1
|
||||
JMP RIGHT
|
||||
LOOP1:
|
||||
MOV P1,A
|
||||
RL A
|
||||
LCALL DELAY
|
||||
SJMP LEFT
|
||||
RIGHT:
|
||||
CJNE A,#11111110b,LOOP2
|
||||
JMP LEFT
|
||||
LOOP2:
|
||||
MOV P1,A
|
||||
RR A
|
||||
LCALL DELAY
|
||||
SJMP RIGHT
|
||||
|
||||
INT0_ISR:
|
||||
MOV R1,#3
|
||||
FLASH:
|
||||
MOV P1,#00h
|
||||
LCALL DELAY
|
||||
MOV P1,#0FFh
|
||||
LCALL DELAY
|
||||
DJNZ R1,FLASH
|
||||
RET
|
||||
T0_ISR:
|
||||
RET
|
||||
INT1_ISR:
|
||||
RET
|
||||
T1_ISR:
|
||||
RET
|
||||
UART_ISR:
|
||||
RET
|
||||
|
||||
DELAY: MOV R5,#20 ;R5*20 mS
|
||||
D1: MOV R6,#40
|
||||
D2: MOV R7,#249
|
||||
DJNZ R7,$
|
||||
DJNZ R6,D2
|
||||
DJNZ R5,D1
|
||||
RET
|
||||
END
|
||||
2841
samples/Assembly/forth.nasm
Normal file
2841
samples/Assembly/forth.nasm
Normal file
File diff suppressed because it is too large
Load Diff
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 5.4 KiB |
Binary file not shown.
Binary file not shown.
@@ -1,21 +0,0 @@
|
||||
# SOME DESCRIPTIVE TITLE.
|
||||
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
|
||||
# This file is distributed under the same license as the PACKAGE package.
|
||||
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
|
||||
#
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: x\n"
|
||||
"POT-Creation-Date: 2009-02-15 09:22+0100\n"
|
||||
"PO-Revision-Date: 2009-02-15 09:22+0100\n"
|
||||
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
||||
"Language-Team: LANGUAGE <LL@li.org>\n"
|
||||
"MIME-Version: 1.0\n"
|
||||
"Content-Type: text/plain; charset=UTF-8\n"
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n"
|
||||
|
||||
#: tools/files/simple_translation.rb:1
|
||||
msgid "a translation"
|
||||
msgstr ""
|
||||
Binary file not shown.
Binary file not shown.
File diff suppressed because one or more lines are too long
Binary file not shown.
|
Before Width: | Height: | Size: 5.4 KiB |
Binary file not shown.
Binary file not shown.
25
samples/BitBake/gstreamer-libav.bb
Normal file
25
samples/BitBake/gstreamer-libav.bb
Normal file
@@ -0,0 +1,25 @@
|
||||
include gstreamer1.0-libav.inc
|
||||
|
||||
LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
|
||||
file://COPYING.LIB;md5=6762ed442b3822387a51c92d928ead0d \
|
||||
file://ext/libav/gstav.h;beginline=1;endline=18;md5=a752c35267d8276fd9ca3db6994fca9c \
|
||||
file://gst-libs/ext/libav/LICENSE;md5=23a54f59b82572c203a559346e89ed57 \
|
||||
file://gst-libs/ext/libav/COPYING.GPLv2;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
|
||||
file://gst-libs/ext/libav/COPYING.GPLv3;md5=d32239bcb673463ab874e80d47fae504 \
|
||||
file://gst-libs/ext/libav/COPYING.LGPLv2.1;md5=bd7a443320af8c812e4c18d1b79df004 \
|
||||
file://gst-libs/ext/libav/COPYING.LGPLv3;md5=e6a600fd5e1d9cbde2d983680233ad02"
|
||||
|
||||
SRC_URI = " \
|
||||
http://gstreamer.freedesktop.org/src/gst-libav/gst-libav-${PV}.tar.xz \
|
||||
file://0001-Disable-yasm-for-libav-when-disable-yasm.patch \
|
||||
"
|
||||
SRC_URI[md5sum] = "86540dee14d31daf976eb2713f2294f3"
|
||||
SRC_URI[sha256sum] = "585eb7971006100ad771a852e07bd2f3e23bcc6eb0b1253a40b5a0e40e4e7418"
|
||||
|
||||
LIBAV_EXTRA_CONFIGURE_COMMON_ARG = "--target-os=linux \
|
||||
--cc='${CC}' --as='${CC}' --ld='${CC}' --nm='${NM}' --ar='${AR}' \
|
||||
--ranlib='${RANLIB}' \
|
||||
${GSTREAMER_1_0_DEBUG}"
|
||||
|
||||
S = "${WORKDIR}/gst-libav-${PV}"
|
||||
|
||||
13
samples/BitBake/qtbase-native.bb
Normal file
13
samples/BitBake/qtbase-native.bb
Normal file
@@ -0,0 +1,13 @@
|
||||
require qt5-git.inc
|
||||
require ${PN}.inc
|
||||
|
||||
do_install_append() {
|
||||
# for modules which are still using syncqt and call qtPrepareTool(QMAKE_SYNCQT, syncqt)
|
||||
# e.g. qt3d, qtwayland
|
||||
ln -sf syncqt.pl ${D}${OE_QMAKE_PATH_QT_BINS}/syncqt
|
||||
}
|
||||
|
||||
QT_MODULE_BRANCH = "release"
|
||||
# v5.2.1 + 168 commits
|
||||
SRCREV = "08cbbde61778276ccdda73d89fd64d02c623779f"
|
||||
|
||||
195
samples/Brainfuck/factor.b
Normal file
195
samples/Brainfuck/factor.b
Normal file
@@ -0,0 +1,195 @@
|
||||
* factor an arbitrarily large positive integer
|
||||
*
|
||||
* Copyright (C) 1999 by Brian Raiter
|
||||
* under the GNU General Public License
|
||||
|
||||
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>-
|
||||
|
||||
*
|
||||
* read in the number
|
||||
*
|
||||
|
||||
<<<<<<<<<+
|
||||
[-[>>>>>>>>>>][-]<<<<<<<<<<[[->>>>>>>>>>+<<<<<<<<<<]<<<<<<<<<<]
|
||||
>>>>>>>>>>,----------]
|
||||
>>>>>>>>>>[------------------------------------->>>>>>>>>->]
|
||||
<[+>[>>>>>>>>>+>]<-<<<<<<<<<<]-
|
||||
|
||||
*
|
||||
* display the number and initialize the loop variable to two
|
||||
*
|
||||
|
||||
[>++++++++++++++++++++++++++++++++++++++++++++++++.
|
||||
------------------------------------------------<<<<<<<<<<<]
|
||||
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
|
||||
--------------------------.[-]
|
||||
>>>>>>>>>>>>++<<<<+
|
||||
|
||||
*
|
||||
* the main loop
|
||||
*
|
||||
|
||||
[ [-]>>
|
||||
|
||||
*
|
||||
* make copies of the number and the loop variable
|
||||
*
|
||||
|
||||
[>>>>[-]>[-]>[-]>[-]
|
||||
>[-]>[-]
|
||||
<<<<<<<[->>>+>+<<<<]>>>>>>>>]
|
||||
<<<<<<<<<<[>>>>>>[-<<<<+>>>>]<<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>[->>>+>>+<<<<<]>>>>>>>>>]
|
||||
<<<<<<<<<<[>>>>>>[-<<<<<+>>>>>]<<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
|
||||
*
|
||||
* divide the number by the loop variable
|
||||
*
|
||||
|
||||
[>>>[-]>>>[-]>[-]>>>] initialize
|
||||
<<<<<<<<<<[<<<<<<<<<<]
|
||||
>>>>>>>>>[-]>>>>>>>+<<<<<<<<[+]+
|
||||
[ ->> double divisor until above dividend
|
||||
[>>>>>>[->++<]>>>>]<<<<<<<<<<
|
||||
[>>>>>>>>[-]>[-]
|
||||
<<<<[->>>++<<<]<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>>[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
|
||||
[->--------->>>>>>>>>+<<<<<<<<<<[->+<]]]]]]]]]]]>>]
|
||||
<<<<<<<<<<[>>>>>>>>>[-<+<<<+>>>>]<<<<<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
|
||||
[-<--------->>>>>>>>>>>+<<<<<<<<<<[-<+>]]]]]]]]]]]>>>]
|
||||
<<<<<<<<<<
|
||||
[>>>>[->>>+>>+<<<<<]<<<<<<<<<<<<<<]
|
||||
>>>>>>>>>>[>>>>>>>[-<<<+>>>]>>>]<<<<<<<<<<
|
||||
[>>>>>>>>[->-<]>
|
||||
[<<<<<<<<<[<[-]>>>>>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]<<<<<<<<<<<<<<<<<<<]
|
||||
>>>>>>>>>>>>>>>>>>>]
|
||||
<<<<<<<<<<<<<<<<<<<]
|
||||
>>>>>>>>>[+[+[+[+[+[+[+[+[+[+[[-]<+>]]]]]]]]]]]<
|
||||
]
|
||||
>>>>>>>>
|
||||
[ subtract divisor from dividend
|
||||
<<<<<<
|
||||
[>>>>>>>>[-]>[-]<<<<<[->>>+>+<<<<]>>>>>>]<<<<<<<<<<
|
||||
[>>>>>>>>[-<<<<+>>>>]<<<[->>>+>+<<<<]<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>>>[-<<<<+>>>>]>]<<<<<<<<<<
|
||||
[>>>>>>>>[-<->]<<<<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
|
||||
[++++++++++[+>-<]>>>>>>>>>>-<<<<<<<<<<]]]]]]]]]]]>>>]
|
||||
>>>>>>>+
|
||||
[ if difference is nonnegative then
|
||||
[-]<<<<<<<<<<<<<<<<< replace dividend and increment quotient
|
||||
[>>>>[-]>>>>[-<<<<+>>>>]<<[->>+<<]<<<<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>>[->+<<<+>>]>>]<<<<<<<<<<
|
||||
[>>>[->>>>>>+<<<<<<]<<<<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>>>[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
|
||||
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
|
||||
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
|
||||
[-<<<<<<+>>>>>>[-<<<<<<+>>>>>>
|
||||
[-<<<<<<+>>>>>>[-<<<<<<--------->>>>>>>>>>>>>>>>+<<<<<<<<<<
|
||||
[-<<<<<<+>>>>>>]]]]]]]]]]]>]
|
||||
>>>>>>>
|
||||
] halve divisor and loop until zero
|
||||
<<<<<<<<<<<<<<<<<[<<<<<<<<<<]>>>>>>>>>>
|
||||
[>>>>>>>>[-]<<[->+<]<[->>>+<<<]>>>>>]<<<<<<<<<<
|
||||
[+>>>>>>>[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
|
||||
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
|
||||
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
|
||||
[-<<<<<<<+>>>>>>>[-<<<<<<<->>>>>>+>
|
||||
[-<<<<<<<+>>>>>>>]]]]]]]]]<<<<<<<
|
||||
[->>>>>>>+<<<<<<<]-<<<<<<<<<<]
|
||||
>>>>>>>
|
||||
[-<<<<<<<<<<<+>>>>>>>>>>>]
|
||||
>>>[>>>>>>>[-<<<<<<<<<<<+++++>>>>>>>>>>>]>>>]<<<<<<<<<<
|
||||
[+>>>>>>>>[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
|
||||
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
|
||||
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
|
||||
[-<<<<<<<<+>>>>>>>>[-<<<<<<<<->>>>>+>>>
|
||||
[-<<<<<<<<+>>>>>>>>]]]]]]]]]<<<<<<<<
|
||||
[->>>>>>>>+<<<<<<<<]-<<<<<<<<<<]
|
||||
>>>>>>>>[-<<<<<<<<<<<<<+>>>>>>>>>>>>>]>>
|
||||
[>>>>>>>>[-<<<<<<<<<<<<<+++++>>>>>>>>>>>>>]>>]<<<<<<<<<<
|
||||
[<<<<<<<<<<]>>>>>>>>>>
|
||||
>>>>>>
|
||||
]
|
||||
<<<<<<
|
||||
|
||||
*
|
||||
* make copies of the loop variable and the quotient
|
||||
*
|
||||
|
||||
[>>>[->>>>+>+<<<<<]>>>>>>>]
|
||||
<<<<<<<<<<
|
||||
[>>>>>>>[-<<<<+>>>>]<<<<<[->>>>>+>>+<<<<<<<]<<<<<<<<<<<<]
|
||||
>>>>>>>>>>[>>>>>>>[-<<<<<+>>>>>]>>>]<<<<<<<<<<
|
||||
|
||||
*
|
||||
* break out of the loop if the quotient is larger than the loop variable
|
||||
*
|
||||
|
||||
[>>>>>>>>>[-<->]<
|
||||
[<<<<<<<<
|
||||
[<<[-]>>>>>>>>>>[-<<<<<<<<<<+>>>>>>>>>>]<<<<<<<<<<<<<<<<<<]
|
||||
>>>>>>>>>>>>>>>>>>]<<<<<<<<<<<<<<<<<<]
|
||||
>>>>>>>>[>-<[+[+[+[+[+[+[+[+[+[[-]>+<]]]]]]]]]]]>+
|
||||
|
||||
[ [-]
|
||||
|
||||
*
|
||||
* partially increment the loop variable
|
||||
*
|
||||
|
||||
<[-]+>>>>+>>>>>>>>[>>>>>>>>>>]<<<<<<<<<<
|
||||
|
||||
*
|
||||
* examine the remainder for nonzero digits
|
||||
*
|
||||
|
||||
[<<<<<<[<<<<[<<<<<<<<<<]>>>>+<<<<<<<<<<]<<<<]
|
||||
>>>>>>>>>>>>>>>>>>>>[>>>>>>>>>>]<<<<<<<<<<[<<<<<<<<<<]
|
||||
>>>>-
|
||||
|
||||
[ [+]
|
||||
|
||||
*
|
||||
* decrement the loop variable and replace the number with the quotient
|
||||
*
|
||||
|
||||
>>>>>>>>-<<[>[-]>>[-<<+>>]>>>>>>>]<<<<<<<<<<
|
||||
|
||||
*
|
||||
* display the loop variable
|
||||
*
|
||||
|
||||
[+>>[>>>>>>>>+>>]<<-<<<<<<<<<<]-
|
||||
[>>++++++++++++++++++++++++++++++++++++++++++++++++.
|
||||
------------------------------------------------<<<<<<<<<<<<]
|
||||
++++++++++++++++++++++++++++++++.[-]>>>>
|
||||
|
||||
]
|
||||
|
||||
*
|
||||
* normalize the loop variable
|
||||
*
|
||||
|
||||
>>>>>>
|
||||
[>>[->>>>>+<<<<<[->>>>>+<<<<<
|
||||
[->>>>>+<<<<<[->>>>>+<<<<<
|
||||
[->>>>>+<<<<<[->>>>>+<<<<<
|
||||
[->>>>>+<<<<<[->>>>>+<<<<<
|
||||
[->>>>>+<<<<<[->>>>>--------->>>>>+<<<<<<<<<<
|
||||
[->>>>>+<<<<<]]]]]]]]]]]>>>>>>>>]
|
||||
<<<<<<<<<<[>>>>>>>[-<<<<<+>>>>>]<<<<<<<<<<<<<<<<<]
|
||||
>>>>>>>>>
|
||||
|
||||
]<
|
||||
|
||||
]>>
|
||||
|
||||
*
|
||||
* display the number and end
|
||||
*
|
||||
|
||||
[>>>>>>>>>>]<<<<<<<<<<[+>[>>>>>>>>>+>]<-<<<<<<<<<<]-
|
||||
[>++++++++++++++++++++++++++++++++++++++++++++++++.<<<<<<<<<<<]
|
||||
++++++++++.
|
||||
13
samples/Brainfuck/fib100.bf
Normal file
13
samples/Brainfuck/fib100.bf
Normal file
@@ -0,0 +1,13 @@
|
||||
# Calculate and output all fibonacci numbers under 100
|
||||
|
||||
+++++++++++
|
||||
>+>>>>++++++++++++++++++++++++++++++++++++++++++++
|
||||
>++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>
|
||||
+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-
|
||||
<-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<
|
||||
-]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]
|
||||
>[<<+>>[-]]<<<<<<<]>>>>>[+++++++++++++++++++++++++
|
||||
+++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++
|
||||
++++++++++++++++++++++++++++++++++++++++++++.[-]<<
|
||||
<<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<
|
||||
[-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]
|
||||
4
samples/Brainfuck/hello.bf
Normal file
4
samples/Brainfuck/hello.bf
Normal file
@@ -0,0 +1,4 @@
|
||||
// More complex version of hello world
|
||||
|
||||
>++++++++[<+++++++++>-]<.>>+>+>++>[-]+<[>[->+<<++++>]<<]>.+++++++..+++.>
|
||||
>+++++++.<<<[[-]<[-]>]<+++++++++++++++.>>.+++.------.--------.>>+.>++++.
|
||||
3
samples/Brainfuck/helloworld.bf
Normal file
3
samples/Brainfuck/helloworld.bf
Normal file
@@ -0,0 +1,3 @@
|
||||
// Hello World
|
||||
|
||||
++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
|
||||
30
samples/Brainfuck/rot13.bf
Normal file
30
samples/Brainfuck/rot13.bf
Normal file
@@ -0,0 +1,30 @@
|
||||
# ROT13 cipher
|
||||
|
||||
-,+[ Read first character and start outer character reading loop
|
||||
-[ Skip forward if character is 0
|
||||
>>++++[>++++++++<-] Set up divisor (32) for division loop
|
||||
(MEMORY LAYOUT: dividend copy remainder divisor quotient zero zero)
|
||||
<+<-[ Set up dividend (x minus 1) and enter division loop
|
||||
>+>+>-[>>>] Increase copy and remainder / reduce divisor / Normal case: skip forward
|
||||
<[[>+<-]>>+>] Special case: move remainder back to divisor and increase quotient
|
||||
<<<<<- Decrement dividend
|
||||
] End division loop
|
||||
]>>>[-]+ End skip loop; zero former divisor and reuse space for a flag
|
||||
>--[-[<->+++[-]]]<[ Zero that flag unless quotient was 2 or 3; zero quotient; check flag
|
||||
++++++++++++<[ If flag then set up divisor (13) for second division loop
|
||||
(MEMORY LAYOUT: zero copy dividend divisor remainder quotient zero zero)
|
||||
>-[>+>>] Reduce divisor; Normal case: increase remainder
|
||||
>[+[<+>-]>+>>] Special case: increase remainder / move it back to divisor / increase quotient
|
||||
<<<<<- Decrease dividend
|
||||
] End division loop
|
||||
>>[<+>-] Add remainder back to divisor to get a useful 13
|
||||
>[ Skip forward if quotient was 0
|
||||
-[ Decrement quotient and skip forward if quotient was 1
|
||||
-<<[-]>> Zero quotient and divisor if quotient was 2
|
||||
]<<[<<->>-]>> Zero divisor and subtract 13 from copy if quotient was 1
|
||||
]<<[<<+>>-] Zero divisor and add 13 to copy if quotient was 0
|
||||
] End outer skip loop (jump to here if ((character minus 1)/32) was not 2 or 3)
|
||||
<[-] Clear remainder from first division if second division was skipped
|
||||
<.[-] Output ROT13ed character from copy and clear it
|
||||
<-,+ Read next character
|
||||
] End character reading loop
|
||||
26
samples/C#/AssemblyInfo.cs
Normal file
26
samples/C#/AssemblyInfo.cs
Normal file
@@ -0,0 +1,26 @@
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
// Information about this assembly is defined by the following attributes.
|
||||
// Change them to the values specific to your project.
|
||||
|
||||
[assembly: AssemblyTitle("Simple")]
|
||||
[assembly: AssemblyDescription("")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("")]
|
||||
[assembly: AssemblyProduct("")]
|
||||
[assembly: AssemblyCopyright("")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
|
||||
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
|
||||
// The form "{Major}.{Minor}.*" will automatically update the build and revision,
|
||||
// and "{Major}.{Minor}.{Build}.*" will update just the revision.
|
||||
|
||||
[assembly: AssemblyVersion("1.0.*")]
|
||||
|
||||
// The following attributes are used to specify the signing key for the assembly,
|
||||
// if desired. See the Mono documentation for more information about signing.
|
||||
|
||||
//[assembly: AssemblyDelaySign(false)]
|
||||
//[assembly: AssemblyKeyFile("")]
|
||||
20
samples/C#/BsonPropertyValue.cs
Normal file
20
samples/C#/BsonPropertyValue.cs
Normal file
@@ -0,0 +1,20 @@
|
||||
using System;
|
||||
|
||||
namespace MongoDB.Serialization.Descriptors
|
||||
{
|
||||
internal class BsonPropertyValue
|
||||
{
|
||||
public bool IsDictionary { get; private set; }
|
||||
|
||||
public Type Type { get; private set; }
|
||||
|
||||
public object Value { get; private set; }
|
||||
|
||||
public BsonPropertyValue(Type type, object value, bool isDictionary)
|
||||
{
|
||||
Type = type;
|
||||
Value = value;
|
||||
IsDictionary = isDictionary;
|
||||
}
|
||||
}
|
||||
}
|
||||
153
samples/C#/MongoExpressionVisitor.cs
Normal file
153
samples/C#/MongoExpressionVisitor.cs
Normal file
@@ -0,0 +1,153 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
|
||||
namespace MongoDB.Linq.Expressions
|
||||
{
|
||||
internal class MongoExpressionVisitor : ExpressionVisitor
|
||||
{
|
||||
protected override Expression Visit(Expression exp)
|
||||
{
|
||||
if (exp == null)
|
||||
return null;
|
||||
switch ((MongoExpressionType)exp.NodeType)
|
||||
{
|
||||
case MongoExpressionType.Collection:
|
||||
return VisitCollection((CollectionExpression)exp);
|
||||
case MongoExpressionType.Field:
|
||||
return VisitField((FieldExpression)exp);
|
||||
case MongoExpressionType.Projection:
|
||||
return VisitProjection((ProjectionExpression)exp);
|
||||
case MongoExpressionType.Select:
|
||||
return VisitSelect((SelectExpression)exp);
|
||||
case MongoExpressionType.Aggregate:
|
||||
return VisitAggregate((AggregateExpression)exp);
|
||||
case MongoExpressionType.AggregateSubquery:
|
||||
return VisitAggregateSubquery((AggregateSubqueryExpression)exp);
|
||||
case MongoExpressionType.Scalar:
|
||||
return VisitScalar((ScalarExpression)exp);
|
||||
default:
|
||||
return base.Visit(exp);
|
||||
}
|
||||
}
|
||||
|
||||
protected virtual Expression VisitAggregate(AggregateExpression aggregate)
|
||||
{
|
||||
var exp = Visit(aggregate.Argument);
|
||||
if (exp != aggregate.Argument)
|
||||
return new AggregateExpression(aggregate.Type, aggregate.AggregateType, exp, aggregate.Distinct);
|
||||
|
||||
return aggregate;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitAggregateSubquery(AggregateSubqueryExpression aggregateSubquery)
|
||||
{
|
||||
Expression e = Visit(aggregateSubquery.AggregateAsSubquery);
|
||||
ScalarExpression subquery = (ScalarExpression)e;
|
||||
if (subquery != aggregateSubquery.AggregateAsSubquery)
|
||||
return new AggregateSubqueryExpression(aggregateSubquery.GroupByAlias, aggregateSubquery.AggregateInGroupSelect, subquery);
|
||||
return aggregateSubquery;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitCollection(CollectionExpression collection)
|
||||
{
|
||||
return collection;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitField(FieldExpression field)
|
||||
{
|
||||
var e = Visit(field.Expression);
|
||||
if (field.Expression != e)
|
||||
field = new FieldExpression(e, field.Alias, field.Name);
|
||||
|
||||
return field;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitProjection(ProjectionExpression projection)
|
||||
{
|
||||
var source = (SelectExpression)Visit(projection.Source);
|
||||
var projector = Visit(projection.Projector);
|
||||
if (source != projection.Source || projector != projection.Projector)
|
||||
return new ProjectionExpression(source, projector, projection.Aggregator);
|
||||
return projection;
|
||||
}
|
||||
|
||||
protected ReadOnlyCollection<OrderExpression> VisitOrderBy(ReadOnlyCollection<OrderExpression> orderBys)
|
||||
{
|
||||
if (orderBys != null)
|
||||
{
|
||||
List<OrderExpression> alternate = null;
|
||||
for (int i = 0, n = orderBys.Count; i < n; i++)
|
||||
{
|
||||
OrderExpression expr = orderBys[i];
|
||||
Expression e = this.Visit(expr.Expression);
|
||||
if (alternate == null && e != expr.Expression)
|
||||
alternate = orderBys.Take(i).ToList();
|
||||
if (alternate != null)
|
||||
alternate.Add(new OrderExpression(expr.OrderType, e));
|
||||
}
|
||||
if (alternate != null)
|
||||
return alternate.AsReadOnly();
|
||||
}
|
||||
return orderBys;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitScalar(ScalarExpression scalar)
|
||||
{
|
||||
SelectExpression select = (SelectExpression)Visit(scalar.Select);
|
||||
if (select != scalar.Select)
|
||||
return new ScalarExpression(scalar.Type, select);
|
||||
return scalar;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitSelect(SelectExpression select)
|
||||
{
|
||||
var from = VisitSource(select.From);
|
||||
var where = Visit(select.Where);
|
||||
var groupBy = Visit(select.GroupBy);
|
||||
var orderBy = VisitOrderBy(select.OrderBy);
|
||||
var skip = Visit(select.Skip);
|
||||
var take = Visit(select.Take);
|
||||
var fields = VisitFieldDeclarationList(select.Fields);
|
||||
if (from != select.From || where != select.Where || orderBy != select.OrderBy || groupBy != select.GroupBy || skip != select.Skip || take != select.Take || fields != select.Fields)
|
||||
return new SelectExpression(select.Alias, fields, from, where, orderBy, groupBy, select.IsDistinct, skip, take);
|
||||
return select;
|
||||
}
|
||||
|
||||
protected virtual Expression VisitSource(Expression source)
|
||||
{
|
||||
return Visit(source);
|
||||
}
|
||||
|
||||
protected virtual Expression VisitSubquery(SubqueryExpression subquery)
|
||||
{
|
||||
switch ((MongoExpressionType)subquery.NodeType)
|
||||
{
|
||||
case MongoExpressionType.Scalar:
|
||||
return VisitScalar((ScalarExpression)subquery);
|
||||
}
|
||||
return subquery;
|
||||
}
|
||||
|
||||
protected virtual ReadOnlyCollection<FieldDeclaration> VisitFieldDeclarationList(ReadOnlyCollection<FieldDeclaration> fields)
|
||||
{
|
||||
if (fields == null)
|
||||
return fields;
|
||||
|
||||
List<FieldDeclaration> alternate = null;
|
||||
for (int i = 0, n = fields.Count; i < n; i++)
|
||||
{
|
||||
var f = fields[i];
|
||||
var e = Visit(f.Expression);
|
||||
if (f.Expression != e && alternate == null)
|
||||
alternate = fields.Take(i).ToList();
|
||||
if (alternate != null)
|
||||
alternate.Add(new FieldDeclaration(f.Name, e));
|
||||
}
|
||||
if (alternate != null)
|
||||
return alternate.AsReadOnly();
|
||||
return fields;
|
||||
}
|
||||
}
|
||||
}
|
||||
86
samples/C++/16F88.h
Normal file
86
samples/C++/16F88.h
Normal file
@@ -0,0 +1,86 @@
|
||||
/*
|
||||
* This file is part of PIC
|
||||
* Copyright © 2012 Rachel Mant (dx-mon@users.sourceforge.net)
|
||||
*
|
||||
* PIC is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* PIC is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
enum PIC16F88Instruction
|
||||
{
|
||||
ADDWF,
|
||||
ANDWF,
|
||||
CLRF,
|
||||
CLRW,
|
||||
COMF,
|
||||
DECF,
|
||||
DECFSZ,
|
||||
INCF,
|
||||
INCFSZ,
|
||||
IORWF,
|
||||
MOVF,
|
||||
MOVWF,
|
||||
NOP,
|
||||
RLF,
|
||||
RRF,
|
||||
SUBWF,
|
||||
SWAPF,
|
||||
XORWF,
|
||||
BCF,
|
||||
BSF,
|
||||
BTFSC,
|
||||
BTFSS,
|
||||
ADDLW,
|
||||
ANDLW,
|
||||
CALL,
|
||||
CLRWDT,
|
||||
GOTO,
|
||||
IORLW,
|
||||
MOVLW,
|
||||
RETFIE,
|
||||
RETLW,
|
||||
RETURN,
|
||||
SLEEP,
|
||||
SUBLW,
|
||||
XORLW
|
||||
};
|
||||
|
||||
class PIC16F88
|
||||
{
|
||||
public:
|
||||
PIC16F88(ROM *ProgramMemory);
|
||||
void Step();
|
||||
|
||||
private:
|
||||
uint8_t q;
|
||||
bool nextIsNop, trapped;
|
||||
Memory *memory;
|
||||
ROM *program;
|
||||
Stack<uint16_t, 8> *CallStack;
|
||||
Register<uint16_t> *PC;
|
||||
Register<> *WREG, *PCL, *STATUS, *PCLATCH;
|
||||
PIC16F88Instruction inst;
|
||||
uint16_t instrWord;
|
||||
|
||||
private:
|
||||
void DecodeInstruction();
|
||||
void ProcessInstruction();
|
||||
|
||||
uint8_t GetBank();
|
||||
uint8_t GetMemoryContents(uint8_t partialAddress);
|
||||
void SetMemoryContents(uint8_t partialAddress, uint8_t newVal);
|
||||
void CheckZero(uint8_t value);
|
||||
void StoreValue(uint8_t value, bool updateZero);
|
||||
uint8_t SetCarry(bool val);
|
||||
uint16_t GetPCHFinalBits();
|
||||
};
|
||||
98
samples/C++/Entity.h
Normal file
98
samples/C++/Entity.h
Normal file
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* @file Entity.h
|
||||
* @page EntityPage Entity
|
||||
* @brief represent an entity in the game
|
||||
* @author vinz243
|
||||
* @version 0.1.0
|
||||
* This file represents an Entity in the game system
|
||||
* This parent type is a static entity which is shown and loaded into the Physics engine but never updated
|
||||
*/
|
||||
|
||||
#ifndef ENTITY_H
|
||||
#define ENTITY_H
|
||||
|
||||
#include "base.h"
|
||||
/// @namespace Whitedrop
|
||||
namespace Whitedrop {
|
||||
/** @class Entity
|
||||
* This parent type is a static entity which is shown and loaded into the Physics engine but never updated
|
||||
*/
|
||||
class Entity {
|
||||
public:
|
||||
/**
|
||||
* @brief Create static entity
|
||||
* @details creates a static entity instance according to the mesh and the id, the position
|
||||
* This needs to be attached to a World after!
|
||||
* The material name is not the file name but the material name!
|
||||
* @ref WorldPage
|
||||
* @param mesh the name of the mesh for the object, file must be in media/meshes
|
||||
* @param id an unique identifier for the object, shortest as possible
|
||||
* @param dimensions an Ogre::Vector3 which contains the dimensions in meter
|
||||
* @param position the Vector3 which contains it position
|
||||
* @param material the material name
|
||||
*/
|
||||
Entity(std::string mesh, std::string id, Ogre::Vector3 dimensions, Ogre::Vector3 position, std::string material);
|
||||
/**
|
||||
* @brief The copy constructor
|
||||
* @details A copy constr
|
||||
*
|
||||
* @param ref the Entity to be copied from
|
||||
*/
|
||||
Entity(const Entity &ref);
|
||||
|
||||
/**
|
||||
* @brief The assignement operator
|
||||
* @details
|
||||
*
|
||||
* @param ent the entity to be copied
|
||||
*/
|
||||
Entity& operator=(const Entity ent);
|
||||
|
||||
/**
|
||||
* @brief destrctor
|
||||
* @details
|
||||
*/
|
||||
virtual ~Entity(void);
|
||||
|
||||
/**
|
||||
* @brief a constance type of the entity
|
||||
* @details depends of the class.
|
||||
* May contain STATIC, DYNAMIC or ETHERAL
|
||||
*/
|
||||
const std::string type = "STATIC";
|
||||
|
||||
/**
|
||||
* @brief Attach the entity to specified sceneManager
|
||||
* @details This creates the OgreEntity using sceneMgr,
|
||||
* set material, create a Node with name as `<id>_n`,
|
||||
* scale it to match dimensions and translate the node to pos
|
||||
* @param sceneMgr the scene manager to use
|
||||
*/
|
||||
virtual void setup(Ogre::SceneManager* sceneMgr);
|
||||
|
||||
/**
|
||||
* @brief the update method
|
||||
* @details this method should be called on each world update.
|
||||
* Even though the method is necessary declared, the main impl of
|
||||
* a static entity should be empty since it is not updated by physics
|
||||
* However, a Dynamic entity should implement this function in order to:
|
||||
* 1) Get from the physics engine the actor position in the physic world
|
||||
* 2) Update the OgreEntity position and rotation from the previous actor
|
||||
* @return whether it was successful or not, if falsey engine should stop
|
||||
*/
|
||||
virtual bool update(void);
|
||||
|
||||
protected:
|
||||
std::string mMesh = "cube.mesh";
|
||||
std::string mId;
|
||||
std::string mMaterial;
|
||||
Ogre::Vector3 mDimensions;
|
||||
Ogre::Vector3 mPosition;
|
||||
Ogre::Entity* mEntity;
|
||||
Ogre::SceneNode* mNode;
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
32
samples/C++/Memory16F88.h
Normal file
32
samples/C++/Memory16F88.h
Normal file
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* This file is part of PIC
|
||||
* Copyright © 2012 Rachel Mant (dx-mon@users.sourceforge.net)
|
||||
*
|
||||
* PIC is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* PIC is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "Memory.h"
|
||||
|
||||
class Memory16F88 : public Memory
|
||||
{
|
||||
private:
|
||||
uint8_t memory[512];
|
||||
std::map<uint32_t, MemoryLocation *> memoryMap;
|
||||
|
||||
public:
|
||||
Memory16F88();
|
||||
uint8_t Dereference(uint8_t bank, uint8_t partialAddress);
|
||||
uint8_t *Reference(uint8_t bank, uint8_t partialAddress);
|
||||
uint8_t *operator [](uint32_t ref);
|
||||
};
|
||||
76
samples/C++/ThreadedQueue.h
Normal file
76
samples/C++/ThreadedQueue.h
Normal file
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* This file is part of IRCBot
|
||||
* Copyright © 2014 Rachel Mant (dx-mon@users.sourceforge.net)
|
||||
*
|
||||
* IRCBot is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* IRCBot is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __THREADED_QUEUE_H__
|
||||
#define __THREADED_QUEUE_H__
|
||||
|
||||
#include <pthread.h>
|
||||
#include <queue>
|
||||
|
||||
template<class T>
|
||||
class ThreadedQueue : public std::queue<T>
|
||||
{
|
||||
private:
|
||||
pthread_mutex_t queueMutex;
|
||||
pthread_cond_t queueCond;
|
||||
|
||||
public:
|
||||
ThreadedQueue()
|
||||
{
|
||||
pthread_mutexattr_t mutexAttrs;
|
||||
pthread_condattr_t condAttrs;
|
||||
|
||||
pthread_mutexattr_init(&mutexAttrs);
|
||||
pthread_mutexattr_settype(&mutexAttrs, PTHREAD_MUTEX_ERRORCHECK);
|
||||
pthread_mutex_init(&queueMutex, &mutexAttrs);
|
||||
pthread_mutexattr_destroy(&mutexAttrs);
|
||||
|
||||
pthread_condattr_init(&condAttrs);
|
||||
pthread_condattr_setpshared(&condAttrs, PTHREAD_PROCESS_PRIVATE);
|
||||
pthread_cond_init(&queueCond, &condAttrs);
|
||||
pthread_condattr_destroy(&condAttrs);
|
||||
}
|
||||
|
||||
~ThreadedQueue()
|
||||
{
|
||||
pthread_cond_destroy(&queueCond);
|
||||
pthread_mutex_destroy(&queueMutex);
|
||||
}
|
||||
|
||||
void waitItems()
|
||||
{
|
||||
pthread_mutex_lock(&queueMutex);
|
||||
pthread_cond_wait(&queueCond, &queueMutex);
|
||||
pthread_mutex_unlock(&queueMutex);
|
||||
}
|
||||
|
||||
void signalItems()
|
||||
{
|
||||
pthread_mutex_lock(&queueMutex);
|
||||
pthread_cond_broadcast(&queueCond);
|
||||
pthread_mutex_unlock(&queueMutex);
|
||||
}
|
||||
|
||||
void push(T item)
|
||||
{
|
||||
std::queue<T>::push(item);
|
||||
signalItems();
|
||||
}
|
||||
};
|
||||
|
||||
#endif /*__THREADED_QUEUE_H__*/
|
||||
10
samples/C++/bar.hh
Normal file
10
samples/C++/bar.hh
Normal file
@@ -0,0 +1,10 @@
|
||||
class Bar
|
||||
{
|
||||
protected:
|
||||
|
||||
char *name;
|
||||
|
||||
public:
|
||||
|
||||
void hello();
|
||||
}
|
||||
116
samples/C++/qsciprinter.cp
Normal file
116
samples/C++/qsciprinter.cp
Normal file
@@ -0,0 +1,116 @@
|
||||
// This module defines interface to the QsciPrinter class.
|
||||
//
|
||||
// Copyright (c) 2011 Riverbank Computing Limited <info@riverbankcomputing.com>
|
||||
//
|
||||
// This file is part of QScintilla.
|
||||
//
|
||||
// This file may be used under the terms of the GNU General Public
|
||||
// License versions 2.0 or 3.0 as published by the Free Software
|
||||
// Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
|
||||
// included in the packaging of this file. Alternatively you may (at
|
||||
// your option) use any later version of the GNU General Public
|
||||
// License if such license has been publicly approved by Riverbank
|
||||
// Computing Limited (or its successors, if any) and the KDE Free Qt
|
||||
// Foundation. In addition, as a special exception, Riverbank gives you
|
||||
// certain additional rights. These rights are described in the Riverbank
|
||||
// GPL Exception version 1.1, which can be found in the file
|
||||
// GPL_EXCEPTION.txt in this package.
|
||||
//
|
||||
// If you are unsure which license is appropriate for your use, please
|
||||
// contact the sales department at sales@riverbankcomputing.com.
|
||||
//
|
||||
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
||||
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
|
||||
#ifndef QSCIPRINTER_H
|
||||
#define QSCIPRINTER_H
|
||||
|
||||
#ifdef __APPLE__
|
||||
extern "C++" {
|
||||
#endif
|
||||
|
||||
#include <qprinter.h>
|
||||
|
||||
#include <Qsci/qsciglobal.h>
|
||||
#include <Qsci/qsciscintilla.h>
|
||||
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
class QRect;
|
||||
class QPainter;
|
||||
QT_END_NAMESPACE
|
||||
|
||||
class QsciScintillaBase;
|
||||
|
||||
|
||||
//! \brief The QsciPrinter class is a sub-class of the Qt QPrinter class that
|
||||
//! is able to print the text of a Scintilla document.
|
||||
//!
|
||||
//! The class can be further sub-classed to alter to layout of the text, adding
|
||||
//! headers and footers for example.
|
||||
class QSCINTILLA_EXPORT QsciPrinter : public QPrinter
|
||||
{
|
||||
public:
|
||||
//! Constructs a printer paint device with mode \a mode.
|
||||
QsciPrinter(PrinterMode mode = ScreenResolution);
|
||||
|
||||
//! Destroys the QsciPrinter instance.
|
||||
virtual ~QsciPrinter();
|
||||
|
||||
//! Format a page, by adding headers and footers for example, before the
|
||||
//! document text is drawn on it. \a painter is the painter to be used to
|
||||
//! add customised text and graphics. \a drawing is true if the page is
|
||||
//! actually being drawn rather than being sized. \a painter drawing
|
||||
//! methods must only be called when \a drawing is true. \a area is the
|
||||
//! area of the page that will be used to draw the text. This should be
|
||||
//! modified if it is necessary to reserve space for any customised text or
|
||||
//! graphics. By default the area is relative to the printable area of the
|
||||
//! page. Use QPrinter::setFullPage() because calling printRange() if you
|
||||
//! want to try and print over the whole page. \a pagenr is the number of
|
||||
//! the page. The first page is numbered 1.
|
||||
virtual void formatPage(QPainter &painter, bool drawing, QRect &area,
|
||||
int pagenr);
|
||||
|
||||
//! Return the number of points to add to each font when printing.
|
||||
//!
|
||||
//! \sa setMagnification()
|
||||
int magnification() const {return mag;}
|
||||
|
||||
//! Sets the number of points to add to each font when printing to \a
|
||||
//! magnification.
|
||||
//!
|
||||
//! \sa magnification()
|
||||
virtual void setMagnification(int magnification);
|
||||
|
||||
//! Print a range of lines from the Scintilla instance \a qsb. \a from is
|
||||
//! the first line to print and a negative value signifies the first line
|
||||
//! of text. \a to is the last line to print and a negative value
|
||||
//! signifies the last line of text. true is returned if there was no
|
||||
//! error.
|
||||
virtual int printRange(QsciScintillaBase *qsb, int from = -1, int to = -1);
|
||||
|
||||
//! Return the line wrap mode used when printing. The default is
|
||||
//! QsciScintilla::WrapWord.
|
||||
//!
|
||||
//! \sa setWrapMode()
|
||||
QsciScintilla::WrapMode wrapMode() const {return wrap;}
|
||||
|
||||
//! Sets the line wrap mode used when printing to \a wmode.
|
||||
//!
|
||||
//! \sa wrapMode()
|
||||
virtual void setWrapMode(QsciScintilla::WrapMode wmode);
|
||||
|
||||
private:
|
||||
int mag;
|
||||
QsciScintilla::WrapMode wrap;
|
||||
|
||||
QsciPrinter(const QsciPrinter &);
|
||||
QsciPrinter &operator=(const QsciPrinter &);
|
||||
};
|
||||
|
||||
#ifdef __APPLE__
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
145
samples/C/2D.C
Normal file
145
samples/C/2D.C
Normal file
@@ -0,0 +1,145 @@
|
||||
#include "2D.h"
|
||||
#include <math.h>
|
||||
|
||||
void set_vgabasemem(void)
|
||||
{
|
||||
ULONG vgabase;
|
||||
SELECTOR tmp;
|
||||
asm mov [tmp], ds
|
||||
dpmi_get_sel_base(&vgabase, tmp);
|
||||
vgabasemem = (char *)(-vgabase + 0xa0000);
|
||||
}
|
||||
|
||||
void drw_chdis(int mode) // change the display!
|
||||
{
|
||||
regs.b.ah = 0x00; // seet theh display moode
|
||||
regs.b.al = mode; // change it to the mode like innit
|
||||
regs.h.flags = 0x72;// Set the dingoes kidneys out of FLAGS eh?
|
||||
regs.h.ss = 0; // Like, totally set the stack segment
|
||||
regs.h.sp = 0; // Set tha stack pointaaaaahhhhh!!!
|
||||
dpmi_simulate_real_interrupt(0x10, ®s);
|
||||
}
|
||||
|
||||
void drw_pix(int x, int y, enum COLORS col)
|
||||
{
|
||||
*VGAPIX(x, y) = col;
|
||||
}
|
||||
|
||||
void drw_line(int x0, int y0, int x1, int y1, enum COLORS col)
|
||||
{
|
||||
// Going for the optimized version of bresenham's line algo.
|
||||
int stp = (abs(y0 - y1) > abs(x0 - x1));
|
||||
int tmp, dx, dy, err, yi, i, j; // yi = y excrement
|
||||
if (stp) {
|
||||
// swappity swap
|
||||
tmp = y0;
|
||||
y0 = x0;
|
||||
x0 = tmp;
|
||||
|
||||
tmp = y1;
|
||||
y1 = x1;
|
||||
x1 = tmp;
|
||||
}
|
||||
// AAAAND NOW WE MUST DO ZEES AGAIN :(
|
||||
// I'm sure there was a func somewhere that does this? :P
|
||||
if (x0 > x1) {
|
||||
tmp = x0;
|
||||
x0 = x1;
|
||||
x1 = tmp;
|
||||
|
||||
tmp = y0;
|
||||
y0 = y1;
|
||||
y1 = tmp;
|
||||
}
|
||||
dx = (x1 - x0);
|
||||
dy = (abs(y1 - y0));
|
||||
err = (dx / 2);
|
||||
|
||||
if (y0 < y1)
|
||||
yi = 1;
|
||||
else
|
||||
yi = -1;
|
||||
j = y0;
|
||||
for (i = x0; i < x1; i++)
|
||||
{
|
||||
if (stp)
|
||||
*VGAPIX(j, i) = col;
|
||||
else
|
||||
*VGAPIX(i, j) = col;
|
||||
|
||||
err -= dy;
|
||||
if (err < 0) {
|
||||
j += yi;
|
||||
err += dx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void drw_rectl(int x, int y, int w, int h, enum COLORS col)
|
||||
{
|
||||
drw_line(x, y, x+w, y, col);
|
||||
drw_line(x+w, y, x+w, y+h, col);
|
||||
|
||||
drw_line(x, y, x, y+h, col);
|
||||
drw_line(x, y+h, x+w+1, y+h, col);
|
||||
}
|
||||
|
||||
void drw_rectf(int x, int y, int w, int h, enum COLORS col)
|
||||
{
|
||||
int i, j;
|
||||
for (j = y; j < x+h; j++) {
|
||||
for (i = x; i < y+w; i++) {
|
||||
*VGAPIX(i, j) = col;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void drw_circl(int x, int y, int rad, enum COLORS col)
|
||||
{
|
||||
int mang, i; // max angle, haha
|
||||
int px, py;
|
||||
mang = 360; // Yeah yeah I'll switch to rad later
|
||||
for (i = 0; i <= mang; i++)
|
||||
{
|
||||
px = cos(i)*rad + x; // + px; // causes some really cools effects! :D
|
||||
py = sin(i)*rad + y; // + py;
|
||||
*VGAPIX(px, py) = col;
|
||||
}
|
||||
}
|
||||
|
||||
void drw_tex(int x, int y, int w, int h, enum COLORS tex[])
|
||||
{ // i*w+j
|
||||
int i, j;
|
||||
for (i = 0; i < w; i++)
|
||||
{
|
||||
for (j = 0; j < h; j++)
|
||||
{
|
||||
*VGAPIX(x+i, y+j) = tex[j*w+i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void 2D_init(void)
|
||||
{
|
||||
set_vgabasemem();
|
||||
drw_chdis(0x13);
|
||||
}
|
||||
|
||||
void 2D_exit(void)
|
||||
{
|
||||
drw_chdis(3);
|
||||
}
|
||||
/*
|
||||
int main()
|
||||
{
|
||||
set_vgabasemem();
|
||||
drw_chdis(0x13);
|
||||
|
||||
while(!kbhit()) {
|
||||
if ((getch()) == 0x1b) // escape
|
||||
break;
|
||||
}
|
||||
drw_chdis(3);
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
29
samples/C/2D.H
Normal file
29
samples/C/2D.H
Normal file
@@ -0,0 +1,29 @@
|
||||
#ifndef __2DGFX
|
||||
#define __2DGFX
|
||||
// Includes
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include <conio.h>
|
||||
#include <dpmi.h>
|
||||
|
||||
// Defines
|
||||
#define VGAPIX(x,y) (vgabasemem + (x) + (y) * 320)
|
||||
|
||||
// Variables
|
||||
char * vgabasemem;
|
||||
DPMI_REGS regs;
|
||||
|
||||
// Drawing functions:
|
||||
//void setvgabasemem(void);
|
||||
void drw_chdis(int mode); // draw_func_change_display
|
||||
void drw_pix(int x, int y, enum COLORS col);
|
||||
void drw_line(int x0, int y0, int x1, int y1, enum COLORS col);
|
||||
void drw_rectl(int x, int y, int w, int h, enum COLORS col);
|
||||
void drw_rectf(int x, int y, int w, int h, enum COLORS col);
|
||||
void drw_cirl(int x, int y, int rad, enum COLORS col);
|
||||
void drw_tex(int x, int y, int w, int h, enum COLORS tex[]);
|
||||
void 2D_init(void);
|
||||
void 2D_exit(void);
|
||||
|
||||
|
||||
#endif
|
||||
93
samples/C/ArrowLeft.h
Normal file
93
samples/C/ArrowLeft.h
Normal file
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
* This file is part of GTK++ (libGTK++)
|
||||
* Copyright © 2012 Rachel Mant (dx-mon@users.sourceforge.net)
|
||||
*
|
||||
* GTK++ is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* GTK++ is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* GdkPixbuf RGBA C-Source image dump */
|
||||
|
||||
#ifdef __SUNPRO_C
|
||||
#pragma align 4 (ArrowLeft)
|
||||
#endif
|
||||
#ifdef __GNUC__
|
||||
static const uint8_t ArrowLeft[] __attribute__ ((__aligned__ (4))) =
|
||||
#else
|
||||
static const uint8_t ArrowLeft[] =
|
||||
#endif
|
||||
{ ""
|
||||
/* Pixbuf magic (0x47646b50) */
|
||||
"GdkP"
|
||||
/* length: header (24) + pixel_data (1600) */
|
||||
"\0\0\6X"
|
||||
/* pixdata_type (0x1010002) */
|
||||
"\1\1\0\2"
|
||||
/* rowstride (80) */
|
||||
"\0\0\0P"
|
||||
/* width (20) */
|
||||
"\0\0\0\24"
|
||||
/* height (20) */
|
||||
"\0\0\0\24"
|
||||
/* pixel_data: */
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\377\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\377\0\0\0\377"
|
||||
"\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377"
|
||||
"\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\377\0\0\0\377\0"
|
||||
"\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\377\0\0\0\377\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\0\0\0\377\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\377\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
||||
"\0\0"};
|
||||
|
||||
|
||||
903
samples/C/GLKMatrix4.h
Normal file
903
samples/C/GLKMatrix4.h
Normal file
@@ -0,0 +1,903 @@
|
||||
//
|
||||
// GLKMatrix4.h
|
||||
// GLKit
|
||||
//
|
||||
// Copyright (c) 2011, Apple Inc. All rights reserved.
|
||||
//
|
||||
|
||||
#ifndef __GLK_MATRIX_4_H
|
||||
#define __GLK_MATRIX_4_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
#include <math.h>
|
||||
|
||||
#if defined(__ARM_NEON__)
|
||||
#include <arm_neon.h>
|
||||
#endif
|
||||
|
||||
#include <GLKit/GLKMathTypes.h>
|
||||
#include <GLKit/GLKVector3.h>
|
||||
#include <GLKit/GLKVector4.h>
|
||||
#include <GLKit/GLKQuaternion.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#pragma mark -
|
||||
#pragma mark Prototypes
|
||||
#pragma mark -
|
||||
|
||||
extern const GLKMatrix4 GLKMatrix4Identity;
|
||||
|
||||
/*
|
||||
m30, m31, and m32 correspond to the translation values tx, ty, tz, respectively.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Make(float m00, float m01, float m02, float m03,
|
||||
float m10, float m11, float m12, float m13,
|
||||
float m20, float m21, float m22, float m23,
|
||||
float m30, float m31, float m32, float m33);
|
||||
|
||||
/*
|
||||
m03, m13, and m23 correspond to the translation values tx, ty, tz, respectively.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeAndTranspose(float m00, float m01, float m02, float m03,
|
||||
float m10, float m11, float m12, float m13,
|
||||
float m20, float m21, float m22, float m23,
|
||||
float m30, float m31, float m32, float m33);
|
||||
|
||||
/*
|
||||
m[12], m[13], and m[14] correspond to the translation values tx, ty, and tz, respectively.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithArray(float values[16]);
|
||||
|
||||
/*
|
||||
m[3], m[7], and m[11] correspond to the translation values tx, ty, and tz, respectively.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithArrayAndTranspose(float values[16]);
|
||||
|
||||
/*
|
||||
row0, row1, and row2's last component should correspond to the translation values tx, ty, and tz, respectively.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithRows(GLKVector4 row0,
|
||||
GLKVector4 row1,
|
||||
GLKVector4 row2,
|
||||
GLKVector4 row3);
|
||||
|
||||
/*
|
||||
column3's first three components should correspond to the translation values tx, ty, and tz.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithColumns(GLKVector4 column0,
|
||||
GLKVector4 column1,
|
||||
GLKVector4 column2,
|
||||
GLKVector4 column3);
|
||||
|
||||
/*
|
||||
The quaternion will be normalized before conversion.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithQuaternion(GLKQuaternion quaternion);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeTranslation(float tx, float ty, float tz);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeScale(float sx, float sy, float sz);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeRotation(float radians, float x, float y, float z);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeXRotation(float radians);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeYRotation(float radians);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeZRotation(float radians);
|
||||
|
||||
/*
|
||||
Equivalent to gluPerspective.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakePerspective(float fovyRadians, float aspect, float nearZ, float farZ);
|
||||
|
||||
/*
|
||||
Equivalent to glFrustum.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeFrustum(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ);
|
||||
|
||||
/*
|
||||
Equivalent to glOrtho.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeOrtho(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ);
|
||||
|
||||
/*
|
||||
Equivalent to gluLookAt.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeLookAt(float eyeX, float eyeY, float eyeZ,
|
||||
float centerX, float centerY, float centerZ,
|
||||
float upX, float upY, float upZ);
|
||||
|
||||
/*
|
||||
Returns the upper left 3x3 portion of the 4x4 matrix.
|
||||
*/
|
||||
static __inline__ GLKMatrix3 GLKMatrix4GetMatrix3(GLKMatrix4 matrix);
|
||||
/*
|
||||
Returns the upper left 2x2 portion of the 4x4 matrix.
|
||||
*/
|
||||
static __inline__ GLKMatrix2 GLKMatrix4GetMatrix2(GLKMatrix4 matrix);
|
||||
|
||||
/*
|
||||
GLKMatrix4GetRow returns vectors for rows 0, 1, and 2 whose last component will be the translation value tx, ty, and tz, respectively.
|
||||
Valid row values range from 0 to 3, inclusive.
|
||||
*/
|
||||
static __inline__ GLKVector4 GLKMatrix4GetRow(GLKMatrix4 matrix, int row);
|
||||
/*
|
||||
GLKMatrix4GetColumn returns a vector for column 3 whose first three components will be the translation values tx, ty, and tz.
|
||||
Valid column values range from 0 to 3, inclusive.
|
||||
*/
|
||||
static __inline__ GLKVector4 GLKMatrix4GetColumn(GLKMatrix4 matrix, int column);
|
||||
|
||||
/*
|
||||
GLKMatrix4SetRow expects that the vector for row 0, 1, and 2 will have a translation value as its last component.
|
||||
Valid row values range from 0 to 3, inclusive.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4SetRow(GLKMatrix4 matrix, int row, GLKVector4 vector);
|
||||
/*
|
||||
GLKMatrix4SetColumn expects that the vector for column 3 will contain the translation values tx, ty, and tz as its first three components, respectively.
|
||||
Valid column values range from 0 to 3, inclusive.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4SetColumn(GLKMatrix4 matrix, int column, GLKVector4 vector);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Transpose(GLKMatrix4 matrix);
|
||||
|
||||
GLKMatrix4 GLKMatrix4Invert(GLKMatrix4 matrix, bool *isInvertible);
|
||||
GLKMatrix4 GLKMatrix4InvertAndTranspose(GLKMatrix4 matrix, bool *isInvertible);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Multiply(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Add(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Subtract(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Translate(GLKMatrix4 matrix, float tx, float ty, float tz);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4TranslateWithVector3(GLKMatrix4 matrix, GLKVector3 translationVector);
|
||||
/*
|
||||
The last component of the GLKVector4, translationVector, is ignored.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4TranslateWithVector4(GLKMatrix4 matrix, GLKVector4 translationVector);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Scale(GLKMatrix4 matrix, float sx, float sy, float sz);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4ScaleWithVector3(GLKMatrix4 matrix, GLKVector3 scaleVector);
|
||||
/*
|
||||
The last component of the GLKVector4, scaleVector, is ignored.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4ScaleWithVector4(GLKMatrix4 matrix, GLKVector4 scaleVector);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Rotate(GLKMatrix4 matrix, float radians, float x, float y, float z);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateWithVector3(GLKMatrix4 matrix, float radians, GLKVector3 axisVector);
|
||||
/*
|
||||
The last component of the GLKVector4, axisVector, is ignored.
|
||||
*/
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateWithVector4(GLKMatrix4 matrix, float radians, GLKVector4 axisVector);
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateX(GLKMatrix4 matrix, float radians);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateY(GLKMatrix4 matrix, float radians);
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateZ(GLKMatrix4 matrix, float radians);
|
||||
|
||||
/*
|
||||
Assumes 0 in the w component.
|
||||
*/
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyVector3(GLKMatrix4 matrixLeft, GLKVector3 vectorRight);
|
||||
/*
|
||||
Assumes 1 in the w component.
|
||||
*/
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyVector3WithTranslation(GLKMatrix4 matrixLeft, GLKVector3 vectorRight);
|
||||
/*
|
||||
Assumes 1 in the w component and divides the resulting vector by w before returning.
|
||||
*/
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyAndProjectVector3(GLKMatrix4 matrixLeft, GLKVector3 vectorRight);
|
||||
|
||||
/*
|
||||
Assumes 0 in the w component.
|
||||
*/
|
||||
static __inline__ void GLKMatrix4MultiplyVector3Array(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount);
|
||||
/*
|
||||
Assumes 1 in the w component.
|
||||
*/
|
||||
static __inline__ void GLKMatrix4MultiplyVector3ArrayWithTranslation(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount);
|
||||
/*
|
||||
Assumes 1 in the w component and divides the resulting vector by w before returning.
|
||||
*/
|
||||
static __inline__ void GLKMatrix4MultiplyAndProjectVector3Array(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount);
|
||||
|
||||
static __inline__ GLKVector4 GLKMatrix4MultiplyVector4(GLKMatrix4 matrixLeft, GLKVector4 vectorRight);
|
||||
|
||||
static __inline__ void GLKMatrix4MultiplyVector4Array(GLKMatrix4 matrix, GLKVector4 *vectors, size_t vectorCount);
|
||||
|
||||
#pragma mark -
|
||||
#pragma mark Implementations
|
||||
#pragma mark -
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Make(float m00, float m01, float m02, float m03,
|
||||
float m10, float m11, float m12, float m13,
|
||||
float m20, float m21, float m22, float m23,
|
||||
float m30, float m31, float m32, float m33)
|
||||
{
|
||||
GLKMatrix4 m = { m00, m01, m02, m03,
|
||||
m10, m11, m12, m13,
|
||||
m20, m21, m22, m23,
|
||||
m30, m31, m32, m33 };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeAndTranspose(float m00, float m01, float m02, float m03,
|
||||
float m10, float m11, float m12, float m13,
|
||||
float m20, float m21, float m22, float m23,
|
||||
float m30, float m31, float m32, float m33)
|
||||
{
|
||||
GLKMatrix4 m = { m00, m10, m20, m30,
|
||||
m01, m11, m21, m31,
|
||||
m02, m12, m22, m32,
|
||||
m03, m13, m23, m33 };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithArray(float values[16])
|
||||
{
|
||||
GLKMatrix4 m = { values[0], values[1], values[2], values[3],
|
||||
values[4], values[5], values[6], values[7],
|
||||
values[8], values[9], values[10], values[11],
|
||||
values[12], values[13], values[14], values[15] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithArrayAndTranspose(float values[16])
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t m = vld4q_f32(values);
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { values[0], values[4], values[8], values[12],
|
||||
values[1], values[5], values[9], values[13],
|
||||
values[2], values[6], values[10], values[14],
|
||||
values[3], values[7], values[11], values[15] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithRows(GLKVector4 row0,
|
||||
GLKVector4 row1,
|
||||
GLKVector4 row2,
|
||||
GLKVector4 row3)
|
||||
{
|
||||
GLKMatrix4 m = { row0.v[0], row1.v[0], row2.v[0], row3.v[0],
|
||||
row0.v[1], row1.v[1], row2.v[1], row3.v[1],
|
||||
row0.v[2], row1.v[2], row2.v[2], row3.v[2],
|
||||
row0.v[3], row1.v[3], row2.v[3], row3.v[3] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithColumns(GLKVector4 column0,
|
||||
GLKVector4 column1,
|
||||
GLKVector4 column2,
|
||||
GLKVector4 column3)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t m;
|
||||
m.val[0] = vld1q_f32(column0.v);
|
||||
m.val[1] = vld1q_f32(column1.v);
|
||||
m.val[2] = vld1q_f32(column2.v);
|
||||
m.val[3] = vld1q_f32(column3.v);
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { column0.v[0], column0.v[1], column0.v[2], column0.v[3],
|
||||
column1.v[0], column1.v[1], column1.v[2], column1.v[3],
|
||||
column2.v[0], column2.v[1], column2.v[2], column2.v[3],
|
||||
column3.v[0], column3.v[1], column3.v[2], column3.v[3] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeWithQuaternion(GLKQuaternion quaternion)
|
||||
{
|
||||
quaternion = GLKQuaternionNormalize(quaternion);
|
||||
|
||||
float x = quaternion.q[0];
|
||||
float y = quaternion.q[1];
|
||||
float z = quaternion.q[2];
|
||||
float w = quaternion.q[3];
|
||||
|
||||
float _2x = x + x;
|
||||
float _2y = y + y;
|
||||
float _2z = z + z;
|
||||
float _2w = w + w;
|
||||
|
||||
GLKMatrix4 m = { 1.0f - _2y * y - _2z * z,
|
||||
_2x * y + _2w * z,
|
||||
_2x * z - _2w * y,
|
||||
0.0f,
|
||||
_2x * y - _2w * z,
|
||||
1.0f - _2x * x - _2z * z,
|
||||
_2y * z + _2w * x,
|
||||
0.0f,
|
||||
_2x * z + _2w * y,
|
||||
_2y * z - _2w * x,
|
||||
1.0f - _2x * x - _2y * y,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeTranslation(float tx, float ty, float tz)
|
||||
{
|
||||
GLKMatrix4 m = GLKMatrix4Identity;
|
||||
m.m[12] = tx;
|
||||
m.m[13] = ty;
|
||||
m.m[14] = tz;
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeScale(float sx, float sy, float sz)
|
||||
{
|
||||
GLKMatrix4 m = GLKMatrix4Identity;
|
||||
m.m[0] = sx;
|
||||
m.m[5] = sy;
|
||||
m.m[10] = sz;
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeRotation(float radians, float x, float y, float z)
|
||||
{
|
||||
GLKVector3 v = GLKVector3Normalize(GLKVector3Make(x, y, z));
|
||||
float cos = cosf(radians);
|
||||
float cosp = 1.0f - cos;
|
||||
float sin = sinf(radians);
|
||||
|
||||
GLKMatrix4 m = { cos + cosp * v.v[0] * v.v[0],
|
||||
cosp * v.v[0] * v.v[1] + v.v[2] * sin,
|
||||
cosp * v.v[0] * v.v[2] - v.v[1] * sin,
|
||||
0.0f,
|
||||
cosp * v.v[0] * v.v[1] - v.v[2] * sin,
|
||||
cos + cosp * v.v[1] * v.v[1],
|
||||
cosp * v.v[1] * v.v[2] + v.v[0] * sin,
|
||||
0.0f,
|
||||
cosp * v.v[0] * v.v[2] + v.v[1] * sin,
|
||||
cosp * v.v[1] * v.v[2] - v.v[0] * sin,
|
||||
cos + cosp * v.v[2] * v.v[2],
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeXRotation(float radians)
|
||||
{
|
||||
float cos = cosf(radians);
|
||||
float sin = sinf(radians);
|
||||
|
||||
GLKMatrix4 m = { 1.0f, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, cos, sin, 0.0f,
|
||||
0.0f, -sin, cos, 0.0f,
|
||||
0.0f, 0.0f, 0.0f, 1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeYRotation(float radians)
|
||||
{
|
||||
float cos = cosf(radians);
|
||||
float sin = sinf(radians);
|
||||
|
||||
GLKMatrix4 m = { cos, 0.0f, -sin, 0.0f,
|
||||
0.0f, 1.0f, 0.0f, 0.0f,
|
||||
sin, 0.0f, cos, 0.0f,
|
||||
0.0f, 0.0f, 0.0f, 1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeZRotation(float radians)
|
||||
{
|
||||
float cos = cosf(radians);
|
||||
float sin = sinf(radians);
|
||||
|
||||
GLKMatrix4 m = { cos, sin, 0.0f, 0.0f,
|
||||
-sin, cos, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, 1.0f, 0.0f,
|
||||
0.0f, 0.0f, 0.0f, 1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakePerspective(float fovyRadians, float aspect, float nearZ, float farZ)
|
||||
{
|
||||
float cotan = 1.0f / tanf(fovyRadians / 2.0f);
|
||||
|
||||
GLKMatrix4 m = { cotan / aspect, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, cotan, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, (farZ + nearZ) / (nearZ - farZ), -1.0f,
|
||||
0.0f, 0.0f, (2.0f * farZ * nearZ) / (nearZ - farZ), 0.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeFrustum(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
{
|
||||
float ral = right + left;
|
||||
float rsl = right - left;
|
||||
float tsb = top - bottom;
|
||||
float tab = top + bottom;
|
||||
float fan = farZ + nearZ;
|
||||
float fsn = farZ - nearZ;
|
||||
|
||||
GLKMatrix4 m = { 2.0f * nearZ / rsl, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, 2.0f * nearZ / tsb, 0.0f, 0.0f,
|
||||
ral / rsl, tab / tsb, -fan / fsn, -1.0f,
|
||||
0.0f, 0.0f, (-2.0f * farZ * nearZ) / fsn, 0.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeOrtho(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
{
|
||||
float ral = right + left;
|
||||
float rsl = right - left;
|
||||
float tab = top + bottom;
|
||||
float tsb = top - bottom;
|
||||
float fan = farZ + nearZ;
|
||||
float fsn = farZ - nearZ;
|
||||
|
||||
GLKMatrix4 m = { 2.0f / rsl, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, 2.0f / tsb, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, -2.0f / fsn, 0.0f,
|
||||
-ral / rsl, -tab / tsb, -fan / fsn, 1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4MakeLookAt(float eyeX, float eyeY, float eyeZ,
|
||||
float centerX, float centerY, float centerZ,
|
||||
float upX, float upY, float upZ)
|
||||
{
|
||||
GLKVector3 ev = { eyeX, eyeY, eyeZ };
|
||||
GLKVector3 cv = { centerX, centerY, centerZ };
|
||||
GLKVector3 uv = { upX, upY, upZ };
|
||||
GLKVector3 n = GLKVector3Normalize(GLKVector3Add(ev, GLKVector3Negate(cv)));
|
||||
GLKVector3 u = GLKVector3Normalize(GLKVector3CrossProduct(uv, n));
|
||||
GLKVector3 v = GLKVector3CrossProduct(n, u);
|
||||
|
||||
GLKMatrix4 m = { u.v[0], v.v[0], n.v[0], 0.0f,
|
||||
u.v[1], v.v[1], n.v[1], 0.0f,
|
||||
u.v[2], v.v[2], n.v[2], 0.0f,
|
||||
GLKVector3DotProduct(GLKVector3Negate(u), ev),
|
||||
GLKVector3DotProduct(GLKVector3Negate(v), ev),
|
||||
GLKVector3DotProduct(GLKVector3Negate(n), ev),
|
||||
1.0f };
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix3 GLKMatrix4GetMatrix3(GLKMatrix4 matrix)
|
||||
{
|
||||
GLKMatrix3 m = { matrix.m[0], matrix.m[1], matrix.m[2],
|
||||
matrix.m[4], matrix.m[5], matrix.m[6],
|
||||
matrix.m[8], matrix.m[9], matrix.m[10] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix2 GLKMatrix4GetMatrix2(GLKMatrix4 matrix)
|
||||
{
|
||||
GLKMatrix2 m = { matrix.m[0], matrix.m[1],
|
||||
matrix.m[4], matrix.m[5] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKVector4 GLKMatrix4GetRow(GLKMatrix4 matrix, int row)
|
||||
{
|
||||
GLKVector4 v = { matrix.m[row], matrix.m[4 + row], matrix.m[8 + row], matrix.m[12 + row] };
|
||||
return v;
|
||||
}
|
||||
|
||||
static __inline__ GLKVector4 GLKMatrix4GetColumn(GLKMatrix4 matrix, int column)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4_t v = vld1q_f32(&(matrix.m[column * 4]));
|
||||
return *(GLKVector4 *)&v;
|
||||
#else
|
||||
GLKVector4 v = { matrix.m[column * 4 + 0], matrix.m[column * 4 + 1], matrix.m[column * 4 + 2], matrix.m[column * 4 + 3] };
|
||||
return v;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4SetRow(GLKMatrix4 matrix, int row, GLKVector4 vector)
|
||||
{
|
||||
matrix.m[row] = vector.v[0];
|
||||
matrix.m[row + 4] = vector.v[1];
|
||||
matrix.m[row + 8] = vector.v[2];
|
||||
matrix.m[row + 12] = vector.v[3];
|
||||
|
||||
return matrix;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4SetColumn(GLKMatrix4 matrix, int column, GLKVector4 vector)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float *dst = &(matrix.m[column * 4]);
|
||||
vst1q_f32(dst, vld1q_f32(vector.v));
|
||||
return matrix;
|
||||
#else
|
||||
matrix.m[column * 4 + 0] = vector.v[0];
|
||||
matrix.m[column * 4 + 1] = vector.v[1];
|
||||
matrix.m[column * 4 + 2] = vector.v[2];
|
||||
matrix.m[column * 4 + 3] = vector.v[3];
|
||||
|
||||
return matrix;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Transpose(GLKMatrix4 matrix)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t m = vld4q_f32(matrix.m);
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { matrix.m[0], matrix.m[4], matrix.m[8], matrix.m[12],
|
||||
matrix.m[1], matrix.m[5], matrix.m[9], matrix.m[13],
|
||||
matrix.m[2], matrix.m[6], matrix.m[10], matrix.m[14],
|
||||
matrix.m[3], matrix.m[7], matrix.m[11], matrix.m[15] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Multiply(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrixLeft = *(float32x4x4_t *)&matrixLeft;
|
||||
float32x4x4_t iMatrixRight = *(float32x4x4_t *)&matrixRight;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[0], 0));
|
||||
m.val[1] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[1], 0));
|
||||
m.val[2] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[2], 0));
|
||||
m.val[3] = vmulq_n_f32(iMatrixLeft.val[0], vgetq_lane_f32(iMatrixRight.val[3], 0));
|
||||
|
||||
m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[0], 1));
|
||||
m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[1], 1));
|
||||
m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[2], 1));
|
||||
m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[1], vgetq_lane_f32(iMatrixRight.val[3], 1));
|
||||
|
||||
m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[0], 2));
|
||||
m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[1], 2));
|
||||
m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[2], 2));
|
||||
m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[2], vgetq_lane_f32(iMatrixRight.val[3], 2));
|
||||
|
||||
m.val[0] = vmlaq_n_f32(m.val[0], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[0], 3));
|
||||
m.val[1] = vmlaq_n_f32(m.val[1], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[1], 3));
|
||||
m.val[2] = vmlaq_n_f32(m.val[2], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[2], 3));
|
||||
m.val[3] = vmlaq_n_f32(m.val[3], iMatrixLeft.val[3], vgetq_lane_f32(iMatrixRight.val[3], 3));
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m;
|
||||
|
||||
m.m[0] = matrixLeft.m[0] * matrixRight.m[0] + matrixLeft.m[4] * matrixRight.m[1] + matrixLeft.m[8] * matrixRight.m[2] + matrixLeft.m[12] * matrixRight.m[3];
|
||||
m.m[4] = matrixLeft.m[0] * matrixRight.m[4] + matrixLeft.m[4] * matrixRight.m[5] + matrixLeft.m[8] * matrixRight.m[6] + matrixLeft.m[12] * matrixRight.m[7];
|
||||
m.m[8] = matrixLeft.m[0] * matrixRight.m[8] + matrixLeft.m[4] * matrixRight.m[9] + matrixLeft.m[8] * matrixRight.m[10] + matrixLeft.m[12] * matrixRight.m[11];
|
||||
m.m[12] = matrixLeft.m[0] * matrixRight.m[12] + matrixLeft.m[4] * matrixRight.m[13] + matrixLeft.m[8] * matrixRight.m[14] + matrixLeft.m[12] * matrixRight.m[15];
|
||||
|
||||
m.m[1] = matrixLeft.m[1] * matrixRight.m[0] + matrixLeft.m[5] * matrixRight.m[1] + matrixLeft.m[9] * matrixRight.m[2] + matrixLeft.m[13] * matrixRight.m[3];
|
||||
m.m[5] = matrixLeft.m[1] * matrixRight.m[4] + matrixLeft.m[5] * matrixRight.m[5] + matrixLeft.m[9] * matrixRight.m[6] + matrixLeft.m[13] * matrixRight.m[7];
|
||||
m.m[9] = matrixLeft.m[1] * matrixRight.m[8] + matrixLeft.m[5] * matrixRight.m[9] + matrixLeft.m[9] * matrixRight.m[10] + matrixLeft.m[13] * matrixRight.m[11];
|
||||
m.m[13] = matrixLeft.m[1] * matrixRight.m[12] + matrixLeft.m[5] * matrixRight.m[13] + matrixLeft.m[9] * matrixRight.m[14] + matrixLeft.m[13] * matrixRight.m[15];
|
||||
|
||||
m.m[2] = matrixLeft.m[2] * matrixRight.m[0] + matrixLeft.m[6] * matrixRight.m[1] + matrixLeft.m[10] * matrixRight.m[2] + matrixLeft.m[14] * matrixRight.m[3];
|
||||
m.m[6] = matrixLeft.m[2] * matrixRight.m[4] + matrixLeft.m[6] * matrixRight.m[5] + matrixLeft.m[10] * matrixRight.m[6] + matrixLeft.m[14] * matrixRight.m[7];
|
||||
m.m[10] = matrixLeft.m[2] * matrixRight.m[8] + matrixLeft.m[6] * matrixRight.m[9] + matrixLeft.m[10] * matrixRight.m[10] + matrixLeft.m[14] * matrixRight.m[11];
|
||||
m.m[14] = matrixLeft.m[2] * matrixRight.m[12] + matrixLeft.m[6] * matrixRight.m[13] + matrixLeft.m[10] * matrixRight.m[14] + matrixLeft.m[14] * matrixRight.m[15];
|
||||
|
||||
m.m[3] = matrixLeft.m[3] * matrixRight.m[0] + matrixLeft.m[7] * matrixRight.m[1] + matrixLeft.m[11] * matrixRight.m[2] + matrixLeft.m[15] * matrixRight.m[3];
|
||||
m.m[7] = matrixLeft.m[3] * matrixRight.m[4] + matrixLeft.m[7] * matrixRight.m[5] + matrixLeft.m[11] * matrixRight.m[6] + matrixLeft.m[15] * matrixRight.m[7];
|
||||
m.m[11] = matrixLeft.m[3] * matrixRight.m[8] + matrixLeft.m[7] * matrixRight.m[9] + matrixLeft.m[11] * matrixRight.m[10] + matrixLeft.m[15] * matrixRight.m[11];
|
||||
m.m[15] = matrixLeft.m[3] * matrixRight.m[12] + matrixLeft.m[7] * matrixRight.m[13] + matrixLeft.m[11] * matrixRight.m[14] + matrixLeft.m[15] * matrixRight.m[15];
|
||||
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Add(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrixLeft = *(float32x4x4_t *)&matrixLeft;
|
||||
float32x4x4_t iMatrixRight = *(float32x4x4_t *)&matrixRight;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vaddq_f32(iMatrixLeft.val[0], iMatrixRight.val[0]);
|
||||
m.val[1] = vaddq_f32(iMatrixLeft.val[1], iMatrixRight.val[1]);
|
||||
m.val[2] = vaddq_f32(iMatrixLeft.val[2], iMatrixRight.val[2]);
|
||||
m.val[3] = vaddq_f32(iMatrixLeft.val[3], iMatrixRight.val[3]);
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m;
|
||||
|
||||
m.m[0] = matrixLeft.m[0] + matrixRight.m[0];
|
||||
m.m[1] = matrixLeft.m[1] + matrixRight.m[1];
|
||||
m.m[2] = matrixLeft.m[2] + matrixRight.m[2];
|
||||
m.m[3] = matrixLeft.m[3] + matrixRight.m[3];
|
||||
|
||||
m.m[4] = matrixLeft.m[4] + matrixRight.m[4];
|
||||
m.m[5] = matrixLeft.m[5] + matrixRight.m[5];
|
||||
m.m[6] = matrixLeft.m[6] + matrixRight.m[6];
|
||||
m.m[7] = matrixLeft.m[7] + matrixRight.m[7];
|
||||
|
||||
m.m[8] = matrixLeft.m[8] + matrixRight.m[8];
|
||||
m.m[9] = matrixLeft.m[9] + matrixRight.m[9];
|
||||
m.m[10] = matrixLeft.m[10] + matrixRight.m[10];
|
||||
m.m[11] = matrixLeft.m[11] + matrixRight.m[11];
|
||||
|
||||
m.m[12] = matrixLeft.m[12] + matrixRight.m[12];
|
||||
m.m[13] = matrixLeft.m[13] + matrixRight.m[13];
|
||||
m.m[14] = matrixLeft.m[14] + matrixRight.m[14];
|
||||
m.m[15] = matrixLeft.m[15] + matrixRight.m[15];
|
||||
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Subtract(GLKMatrix4 matrixLeft, GLKMatrix4 matrixRight)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrixLeft = *(float32x4x4_t *)&matrixLeft;
|
||||
float32x4x4_t iMatrixRight = *(float32x4x4_t *)&matrixRight;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vsubq_f32(iMatrixLeft.val[0], iMatrixRight.val[0]);
|
||||
m.val[1] = vsubq_f32(iMatrixLeft.val[1], iMatrixRight.val[1]);
|
||||
m.val[2] = vsubq_f32(iMatrixLeft.val[2], iMatrixRight.val[2]);
|
||||
m.val[3] = vsubq_f32(iMatrixLeft.val[3], iMatrixRight.val[3]);
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m;
|
||||
|
||||
m.m[0] = matrixLeft.m[0] - matrixRight.m[0];
|
||||
m.m[1] = matrixLeft.m[1] - matrixRight.m[1];
|
||||
m.m[2] = matrixLeft.m[2] - matrixRight.m[2];
|
||||
m.m[3] = matrixLeft.m[3] - matrixRight.m[3];
|
||||
|
||||
m.m[4] = matrixLeft.m[4] - matrixRight.m[4];
|
||||
m.m[5] = matrixLeft.m[5] - matrixRight.m[5];
|
||||
m.m[6] = matrixLeft.m[6] - matrixRight.m[6];
|
||||
m.m[7] = matrixLeft.m[7] - matrixRight.m[7];
|
||||
|
||||
m.m[8] = matrixLeft.m[8] - matrixRight.m[8];
|
||||
m.m[9] = matrixLeft.m[9] - matrixRight.m[9];
|
||||
m.m[10] = matrixLeft.m[10] - matrixRight.m[10];
|
||||
m.m[11] = matrixLeft.m[11] - matrixRight.m[11];
|
||||
|
||||
m.m[12] = matrixLeft.m[12] - matrixRight.m[12];
|
||||
m.m[13] = matrixLeft.m[13] - matrixRight.m[13];
|
||||
m.m[14] = matrixLeft.m[14] - matrixRight.m[14];
|
||||
m.m[15] = matrixLeft.m[15] - matrixRight.m[15];
|
||||
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Translate(GLKMatrix4 matrix, float tx, float ty, float tz)
|
||||
{
|
||||
GLKMatrix4 m = { matrix.m[0], matrix.m[1], matrix.m[2], matrix.m[3],
|
||||
matrix.m[4], matrix.m[5], matrix.m[6], matrix.m[7],
|
||||
matrix.m[8], matrix.m[9], matrix.m[10], matrix.m[11],
|
||||
matrix.m[0] * tx + matrix.m[4] * ty + matrix.m[8] * tz + matrix.m[12],
|
||||
matrix.m[1] * tx + matrix.m[5] * ty + matrix.m[9] * tz + matrix.m[13],
|
||||
matrix.m[2] * tx + matrix.m[6] * ty + matrix.m[10] * tz + matrix.m[14],
|
||||
matrix.m[15] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4TranslateWithVector3(GLKMatrix4 matrix, GLKVector3 translationVector)
|
||||
{
|
||||
GLKMatrix4 m = { matrix.m[0], matrix.m[1], matrix.m[2], matrix.m[3],
|
||||
matrix.m[4], matrix.m[5], matrix.m[6], matrix.m[7],
|
||||
matrix.m[8], matrix.m[9], matrix.m[10], matrix.m[11],
|
||||
matrix.m[0] * translationVector.v[0] + matrix.m[4] * translationVector.v[1] + matrix.m[8] * translationVector.v[2] + matrix.m[12],
|
||||
matrix.m[1] * translationVector.v[0] + matrix.m[5] * translationVector.v[1] + matrix.m[9] * translationVector.v[2] + matrix.m[13],
|
||||
matrix.m[2] * translationVector.v[0] + matrix.m[6] * translationVector.v[1] + matrix.m[10] * translationVector.v[2] + matrix.m[14],
|
||||
matrix.m[15] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4TranslateWithVector4(GLKMatrix4 matrix, GLKVector4 translationVector)
|
||||
{
|
||||
GLKMatrix4 m = { matrix.m[0], matrix.m[1], matrix.m[2], matrix.m[3],
|
||||
matrix.m[4], matrix.m[5], matrix.m[6], matrix.m[7],
|
||||
matrix.m[8], matrix.m[9], matrix.m[10], matrix.m[11],
|
||||
matrix.m[0] * translationVector.v[0] + matrix.m[4] * translationVector.v[1] + matrix.m[8] * translationVector.v[2] + matrix.m[12],
|
||||
matrix.m[1] * translationVector.v[0] + matrix.m[5] * translationVector.v[1] + matrix.m[9] * translationVector.v[2] + matrix.m[13],
|
||||
matrix.m[2] * translationVector.v[0] + matrix.m[6] * translationVector.v[1] + matrix.m[10] * translationVector.v[2] + matrix.m[14],
|
||||
matrix.m[15] };
|
||||
return m;
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Scale(GLKMatrix4 matrix, float sx, float sy, float sz)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrix = *(float32x4x4_t *)&matrix;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vmulq_n_f32(iMatrix.val[0], (float32_t)sx);
|
||||
m.val[1] = vmulq_n_f32(iMatrix.val[1], (float32_t)sy);
|
||||
m.val[2] = vmulq_n_f32(iMatrix.val[2], (float32_t)sz);
|
||||
m.val[3] = iMatrix.val[3];
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { matrix.m[0] * sx, matrix.m[1] * sx, matrix.m[2] * sx, matrix.m[3] * sx,
|
||||
matrix.m[4] * sy, matrix.m[5] * sy, matrix.m[6] * sy, matrix.m[7] * sy,
|
||||
matrix.m[8] * sz, matrix.m[9] * sz, matrix.m[10] * sz, matrix.m[11] * sz,
|
||||
matrix.m[12], matrix.m[13], matrix.m[14], matrix.m[15] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4ScaleWithVector3(GLKMatrix4 matrix, GLKVector3 scaleVector)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrix = *(float32x4x4_t *)&matrix;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vmulq_n_f32(iMatrix.val[0], (float32_t)scaleVector.v[0]);
|
||||
m.val[1] = vmulq_n_f32(iMatrix.val[1], (float32_t)scaleVector.v[1]);
|
||||
m.val[2] = vmulq_n_f32(iMatrix.val[2], (float32_t)scaleVector.v[2]);
|
||||
m.val[3] = iMatrix.val[3];
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { matrix.m[0] * scaleVector.v[0], matrix.m[1] * scaleVector.v[0], matrix.m[2] * scaleVector.v[0], matrix.m[3] * scaleVector.v[0],
|
||||
matrix.m[4] * scaleVector.v[1], matrix.m[5] * scaleVector.v[1], matrix.m[6] * scaleVector.v[1], matrix.m[7] * scaleVector.v[1],
|
||||
matrix.m[8] * scaleVector.v[2], matrix.m[9] * scaleVector.v[2], matrix.m[10] * scaleVector.v[2], matrix.m[11] * scaleVector.v[2],
|
||||
matrix.m[12], matrix.m[13], matrix.m[14], matrix.m[15] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4ScaleWithVector4(GLKMatrix4 matrix, GLKVector4 scaleVector)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrix = *(float32x4x4_t *)&matrix;
|
||||
float32x4x4_t m;
|
||||
|
||||
m.val[0] = vmulq_n_f32(iMatrix.val[0], (float32_t)scaleVector.v[0]);
|
||||
m.val[1] = vmulq_n_f32(iMatrix.val[1], (float32_t)scaleVector.v[1]);
|
||||
m.val[2] = vmulq_n_f32(iMatrix.val[2], (float32_t)scaleVector.v[2]);
|
||||
m.val[3] = iMatrix.val[3];
|
||||
|
||||
return *(GLKMatrix4 *)&m;
|
||||
#else
|
||||
GLKMatrix4 m = { matrix.m[0] * scaleVector.v[0], matrix.m[1] * scaleVector.v[0], matrix.m[2] * scaleVector.v[0], matrix.m[3] * scaleVector.v[0],
|
||||
matrix.m[4] * scaleVector.v[1], matrix.m[5] * scaleVector.v[1], matrix.m[6] * scaleVector.v[1], matrix.m[7] * scaleVector.v[1],
|
||||
matrix.m[8] * scaleVector.v[2], matrix.m[9] * scaleVector.v[2], matrix.m[10] * scaleVector.v[2], matrix.m[11] * scaleVector.v[2],
|
||||
matrix.m[12], matrix.m[13], matrix.m[14], matrix.m[15] };
|
||||
return m;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4Rotate(GLKMatrix4 matrix, float radians, float x, float y, float z)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeRotation(radians, x, y, z);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateWithVector3(GLKMatrix4 matrix, float radians, GLKVector3 axisVector)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeRotation(radians, axisVector.v[0], axisVector.v[1], axisVector.v[2]);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateWithVector4(GLKMatrix4 matrix, float radians, GLKVector4 axisVector)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeRotation(radians, axisVector.v[0], axisVector.v[1], axisVector.v[2]);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateX(GLKMatrix4 matrix, float radians)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeXRotation(radians);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateY(GLKMatrix4 matrix, float radians)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeYRotation(radians);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKMatrix4 GLKMatrix4RotateZ(GLKMatrix4 matrix, float radians)
|
||||
{
|
||||
GLKMatrix4 rm = GLKMatrix4MakeZRotation(radians);
|
||||
return GLKMatrix4Multiply(matrix, rm);
|
||||
}
|
||||
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyVector3(GLKMatrix4 matrixLeft, GLKVector3 vectorRight)
|
||||
{
|
||||
GLKVector4 v4 = GLKMatrix4MultiplyVector4(matrixLeft, GLKVector4Make(vectorRight.v[0], vectorRight.v[1], vectorRight.v[2], 0.0f));
|
||||
return GLKVector3Make(v4.v[0], v4.v[1], v4.v[2]);
|
||||
}
|
||||
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyVector3WithTranslation(GLKMatrix4 matrixLeft, GLKVector3 vectorRight)
|
||||
{
|
||||
GLKVector4 v4 = GLKMatrix4MultiplyVector4(matrixLeft, GLKVector4Make(vectorRight.v[0], vectorRight.v[1], vectorRight.v[2], 1.0f));
|
||||
return GLKVector3Make(v4.v[0], v4.v[1], v4.v[2]);
|
||||
}
|
||||
|
||||
static __inline__ GLKVector3 GLKMatrix4MultiplyAndProjectVector3(GLKMatrix4 matrixLeft, GLKVector3 vectorRight)
|
||||
{
|
||||
GLKVector4 v4 = GLKMatrix4MultiplyVector4(matrixLeft, GLKVector4Make(vectorRight.v[0], vectorRight.v[1], vectorRight.v[2], 1.0f));
|
||||
return GLKVector3MultiplyScalar(GLKVector3Make(v4.v[0], v4.v[1], v4.v[2]), 1.0f / v4.v[3]);
|
||||
}
|
||||
|
||||
static __inline__ void GLKMatrix4MultiplyVector3Array(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i < vectorCount; i++)
|
||||
vectors[i] = GLKMatrix4MultiplyVector3(matrix, vectors[i]);
|
||||
}
|
||||
|
||||
static __inline__ void GLKMatrix4MultiplyVector3ArrayWithTranslation(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i < vectorCount; i++)
|
||||
vectors[i] = GLKMatrix4MultiplyVector3WithTranslation(matrix, vectors[i]);
|
||||
}
|
||||
|
||||
static __inline__ void GLKMatrix4MultiplyAndProjectVector3Array(GLKMatrix4 matrix, GLKVector3 *vectors, size_t vectorCount)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i < vectorCount; i++)
|
||||
vectors[i] = GLKMatrix4MultiplyAndProjectVector3(matrix, vectors[i]);
|
||||
}
|
||||
|
||||
static __inline__ GLKVector4 GLKMatrix4MultiplyVector4(GLKMatrix4 matrixLeft, GLKVector4 vectorRight)
|
||||
{
|
||||
#if defined(__ARM_NEON__)
|
||||
float32x4x4_t iMatrix = *(float32x4x4_t *)&matrixLeft;
|
||||
float32x4_t v;
|
||||
|
||||
iMatrix.val[0] = vmulq_n_f32(iMatrix.val[0], (float32_t)vectorRight.v[0]);
|
||||
iMatrix.val[1] = vmulq_n_f32(iMatrix.val[1], (float32_t)vectorRight.v[1]);
|
||||
iMatrix.val[2] = vmulq_n_f32(iMatrix.val[2], (float32_t)vectorRight.v[2]);
|
||||
iMatrix.val[3] = vmulq_n_f32(iMatrix.val[3], (float32_t)vectorRight.v[3]);
|
||||
|
||||
iMatrix.val[0] = vaddq_f32(iMatrix.val[0], iMatrix.val[1]);
|
||||
iMatrix.val[2] = vaddq_f32(iMatrix.val[2], iMatrix.val[3]);
|
||||
|
||||
v = vaddq_f32(iMatrix.val[0], iMatrix.val[2]);
|
||||
|
||||
return *(GLKVector4 *)&v;
|
||||
#else
|
||||
GLKVector4 v = { matrixLeft.m[0] * vectorRight.v[0] + matrixLeft.m[4] * vectorRight.v[1] + matrixLeft.m[8] * vectorRight.v[2] + matrixLeft.m[12] * vectorRight.v[3],
|
||||
matrixLeft.m[1] * vectorRight.v[0] + matrixLeft.m[5] * vectorRight.v[1] + matrixLeft.m[9] * vectorRight.v[2] + matrixLeft.m[13] * vectorRight.v[3],
|
||||
matrixLeft.m[2] * vectorRight.v[0] + matrixLeft.m[6] * vectorRight.v[1] + matrixLeft.m[10] * vectorRight.v[2] + matrixLeft.m[14] * vectorRight.v[3],
|
||||
matrixLeft.m[3] * vectorRight.v[0] + matrixLeft.m[7] * vectorRight.v[1] + matrixLeft.m[11] * vectorRight.v[2] + matrixLeft.m[15] * vectorRight.v[3] };
|
||||
return v;
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ void GLKMatrix4MultiplyVector4Array(GLKMatrix4 matrix, GLKVector4 *vectors, size_t vectorCount)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i < vectorCount; i++)
|
||||
vectors[i] = GLKMatrix4MultiplyVector4(matrix, vectors[i]);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __GLK_MATRIX_4_H */
|
||||
99
samples/C/NWMan.h
Normal file
99
samples/C/NWMan.h
Normal file
@@ -0,0 +1,99 @@
|
||||
#ifndef _NME_WMAN_H
|
||||
#define _NME_WMAN_H
|
||||
|
||||
// Internal window manager API
|
||||
|
||||
#include "NCompat.h"
|
||||
|
||||
START_HEAD
|
||||
|
||||
#include "NPos.h"
|
||||
#include "NUtil.h"
|
||||
#include "NTypes.h"
|
||||
|
||||
NTS(NWMan_event);
|
||||
|
||||
NSTRUCT(NWMan, {
|
||||
// Init stuff
|
||||
bool (*init)();
|
||||
bool (*destroy)();
|
||||
|
||||
// Window stuff
|
||||
bool (*create_window)();
|
||||
bool (*destroy_window)();
|
||||
|
||||
void (*swap_buffers)();
|
||||
|
||||
// Event stuff
|
||||
bool (*next_event)(NWMan_event* event);
|
||||
|
||||
// Time stuff
|
||||
uint (*get_millis)();
|
||||
void (*sleep)(uint millis);
|
||||
|
||||
// Info
|
||||
int rshift_key;
|
||||
int lshift_key;
|
||||
int left_key;
|
||||
int right_key;
|
||||
});
|
||||
|
||||
NENUM(NWMan_event_type, {
|
||||
N_WMAN_MOUSE_MOVE = 0,
|
||||
N_WMAN_MOUSE_BUTTON = 1,
|
||||
N_WMAN_MOUSE_WHEEL = 2,
|
||||
|
||||
N_WMAN_KEYBOARD = 10,
|
||||
|
||||
N_WMAN_QUIT = 20,
|
||||
N_WMAN_RESIZE = 21,
|
||||
N_WMAN_FOCUS = 22
|
||||
});
|
||||
|
||||
#define N_WMAN_MOUSE_LEFT 0
|
||||
#define N_WMAN_MOUSE_RIGHT 1
|
||||
#define N_WMAN_MOUSE_MIDDLE 2
|
||||
|
||||
NSTRUCT(NWMan_event, {
|
||||
NWMan_event_type type;
|
||||
|
||||
union {
|
||||
// Mouse
|
||||
|
||||
NPos2i mouse_pos;
|
||||
|
||||
struct {
|
||||
short id;
|
||||
bool state;
|
||||
} mouse_button;
|
||||
|
||||
signed char mouse_wheel; // 1 if up, -1 if down
|
||||
|
||||
// Keyboard
|
||||
|
||||
struct {
|
||||
int key;
|
||||
bool state;
|
||||
} keyboard;
|
||||
|
||||
// Window
|
||||
|
||||
bool window_quit; // Will always be true if WM_QUIT
|
||||
|
||||
NPos2i window_size;
|
||||
|
||||
bool window_focus;
|
||||
};
|
||||
});
|
||||
|
||||
NWMan_event NWMan_event_new(NWMan_event_type type);
|
||||
|
||||
|
||||
bool NWMan_init();
|
||||
bool NWMan_destroy();
|
||||
|
||||
extern NWMan N_WMan;
|
||||
|
||||
END_HEAD
|
||||
|
||||
#endif
|
||||
27
samples/C/Nightmare.h
Normal file
27
samples/C/Nightmare.h
Normal file
@@ -0,0 +1,27 @@
|
||||
#ifndef _NMEX_NIGHTMARE_H
|
||||
#define _NMEX_NIGHTMARE_H
|
||||
|
||||
//#define NMEX
|
||||
|
||||
#include "../src/NCompat.h"
|
||||
|
||||
START_HEAD
|
||||
|
||||
#include "../src/NTypes.h"
|
||||
#include "../src/NUtil.h"
|
||||
#include "../src/NPorting.h"
|
||||
#include "../src/NGlobals.h"
|
||||
#include "../src/NLog.h"
|
||||
#include "../src/NWMan.h"
|
||||
#include "../src/NRsc.h"
|
||||
#include "../src/NShader.h"
|
||||
#include "../src/NSquare.h"
|
||||
#include "../src/NImage.h"
|
||||
#include "../src/NSprite.h"
|
||||
#include "../src/NSpritesheet.h"
|
||||
#include "../src/NEntity.h"
|
||||
#include "../src/Game.h"
|
||||
|
||||
END_HEAD
|
||||
|
||||
#endif
|
||||
47
samples/C/bitmap.h
Normal file
47
samples/C/bitmap.h
Normal file
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2010 Christoph Sünderhauf
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "generic.h"
|
||||
|
||||
typedef struct {
|
||||
uint32_t numbits;
|
||||
/* an array large enough for numbits to fit in. Might
|
||||
* (if numbits%8!=0) have some spare bits at the end
|
||||
*/
|
||||
uint32_t* bits;
|
||||
} bitmap_t;
|
||||
|
||||
|
||||
// creates a new bitmap.
|
||||
// CONTENT IS RANDOM! - use bitmap_clearall() to clear the bitmap.
|
||||
bitmap_t bitmap_init(uint32_t numbits);
|
||||
|
||||
// returns 1 or 0
|
||||
uint8_t bitmap_get(bitmap_t bitmap, uint32_t bitnum);
|
||||
// sets a bit (to 1)
|
||||
void bitmap_set(bitmap_t bitmap, uint32_t bitnum);
|
||||
// clears a bit (to 0)
|
||||
void bitmap_clear(bitmap_t bitmap, uint32_t bitnum);
|
||||
|
||||
// clears every bit to 0
|
||||
void bitmap_clearAll(bitmap_t bitmap);
|
||||
|
||||
// finds the first bit set to 0 returns 0 if no cleared bit found (0 is also returned if the first bit is cleared)
|
||||
uint32_t bitmap_findFirstClear(bitmap_t bitmap);
|
||||
44
samples/C/color.h
Normal file
44
samples/C/color.h
Normal file
@@ -0,0 +1,44 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
|
||||
typedef struct {
|
||||
uint32_t background;
|
||||
uint32_t foreground;
|
||||
} console_color_t;
|
||||
|
||||
#define CONSOLE_COLOR_BLACK 0x0
|
||||
#define CONSOLE_COLOR_BLUE 0x1
|
||||
#define CONSOLE_COLOR_GREEN 0x2
|
||||
#define CONSOLE_COLOR_CYAN 0x3
|
||||
#define CONSOLE_COLOR_RED 0x4
|
||||
#define CONSOLE_COLOR_MAGENTA 0x5
|
||||
#define CONSOLE_COLOR_BROWN 0x6
|
||||
#define CONSOLE_COLOR_LGREY 0x7
|
||||
#define CONSOLE_COLOR_DGREY 0x8
|
||||
#define CONSOLE_COLOR_LBLUE 0x9
|
||||
#define CONSOLE_COLOR_LGREEN 0xa
|
||||
#define CONSOLE_COLOR_LCYAN 0xb
|
||||
#define CONSOLE_COLOR_LRED 0xc
|
||||
#define CONSOLE_COLOR_LMAGENTA 0xd
|
||||
#define CONSOLE_COLOR_YELLOW 0xe
|
||||
#define CONSOLE_COLOR_WHITE 0xf
|
||||
|
||||
52
samples/C/driver.h
Normal file
52
samples/C/driver.h
Normal file
@@ -0,0 +1,52 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <console/info.h>
|
||||
|
||||
#define CONSOLE_DRV_CAP_CLEAR 0x01
|
||||
#define CONSOLE_DRV_CAP_SCROLL 0x02
|
||||
#define CONSOLE_DRV_CAP_SET_CURSOR 0x04
|
||||
|
||||
// Input modifier keys
|
||||
typedef struct {
|
||||
bool shift_left:1;
|
||||
bool shift_right:1;
|
||||
bool control_left:1;
|
||||
bool control_right:1;
|
||||
bool alt:1;
|
||||
bool super:1;
|
||||
} console_modifiers_t;
|
||||
|
||||
typedef struct {
|
||||
char character;
|
||||
console_modifiers_t* modifiers;
|
||||
} console_read_t;
|
||||
|
||||
typedef struct {
|
||||
int (*write)(console_info_t*, char);
|
||||
console_read_t* (*read)(console_info_t*);
|
||||
|
||||
int capabilities;
|
||||
|
||||
int (*_clear)(console_info_t*);
|
||||
int (*scroll)(console_info_t*, int32_t);
|
||||
void (*setCursor)(console_info_t*, uint32_t, uint32_t);
|
||||
} console_driver_t;
|
||||
70
samples/C/elf.h
Normal file
70
samples/C/elf.h
Normal file
@@ -0,0 +1,70 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <tasks/scheduler.h>
|
||||
|
||||
#define ELF_TYPE_NONE 0
|
||||
#define ELF_TYPE_REL 1
|
||||
#define ELF_TYPE_EXEC 2
|
||||
#define ELF_TYPE_DYN 3
|
||||
#define ELF_TYPE_CORE 4
|
||||
|
||||
#define ELF_ARCH_NONE 0
|
||||
#define ELF_ARCH_386 3
|
||||
|
||||
#define ELF_VERSION_CURRENT 1
|
||||
|
||||
typedef struct {
|
||||
unsigned char magic[4];
|
||||
/* Note: There _is_ other stuff in here, but we don't need it */
|
||||
unsigned char pad[12];
|
||||
} __attribute__((packed)) elf_ident_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t type;
|
||||
uint32_t offset;
|
||||
void* virtaddr;
|
||||
void* physaddr;
|
||||
uint32_t filesize;
|
||||
uint32_t memsize;
|
||||
uint32_t flags;
|
||||
uint32_t alignment;
|
||||
} __attribute__((packed)) elf_program_t;
|
||||
|
||||
typedef struct {
|
||||
elf_ident_t ident;
|
||||
uint16_t type; /* Object file type */
|
||||
uint16_t machine; /* Architecture */
|
||||
uint32_t version; /* Object file version */
|
||||
void* entry; /* Entry point virtual address */
|
||||
uint32_t phoff; /* Program header table file offset */
|
||||
uint32_t shoff; /* Section header table file offset */
|
||||
uint32_t flags; /* Processor-specific flags */
|
||||
uint16_t ehsize; /* ELF header size in bytes */
|
||||
uint16_t phentsize; /* Program header table entry size */
|
||||
uint16_t phnum; /* Program header table entry count */
|
||||
uint16_t shentsize; /* Section header table entry size */
|
||||
uint16_t shnum; /* Section header table entry count */
|
||||
uint16_t shstrndx; /* Section header string table index */
|
||||
} __attribute__((packed)) elf_t;
|
||||
|
||||
task_t* elf_load(elf_t* bin, char* name, char** environ, char** argv, int argc);
|
||||
task_t* elf_load_file(char* path, char** environ, char** argv, int argc);
|
||||
2310
samples/C/filenames/script
Executable file
2310
samples/C/filenames/script
Executable file
File diff suppressed because it is too large
Load Diff
45
samples/C/filter.h
Normal file
45
samples/C/filter.h
Normal file
@@ -0,0 +1,45 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <console/info.h>
|
||||
#include <console/driver.h>
|
||||
|
||||
struct console_filter {
|
||||
// General callback for all actions etc.
|
||||
// Preferred prototype:
|
||||
// char <name>(char c, console_info_t *info, console_driver_t *input, console_driver_t *output);
|
||||
char (*callback)(char, console_info_t*, console_driver_t*, console_driver_t*);
|
||||
|
||||
// Specific callbacks for read and write
|
||||
// Preferred prototype:
|
||||
// char <name>(char c, console_info_t *info, console_driver_t *input);
|
||||
char (*read_callback)(char, console_info_t*, console_driver_t*);
|
||||
|
||||
// Preferred prototype:
|
||||
// char <name>(char c, console_info_t *info, console_driver_t *output);
|
||||
char (*write_callback)(char, console_info_t*, console_driver_t*);
|
||||
|
||||
// The next filter in the filter chain
|
||||
struct console_filter* next;
|
||||
};
|
||||
|
||||
typedef struct console_filter console_filter_t;
|
||||
|
||||
44
samples/C/info.h
Normal file
44
samples/C/info.h
Normal file
@@ -0,0 +1,44 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <console/color.h>
|
||||
|
||||
typedef struct {
|
||||
uint32_t cursor_x;
|
||||
uint32_t cursor_y;
|
||||
|
||||
uint32_t rows;
|
||||
uint32_t columns;
|
||||
|
||||
uint32_t tabstop;
|
||||
|
||||
console_color_t default_color;
|
||||
console_color_t current_color;
|
||||
|
||||
uint8_t nonblocking;
|
||||
uint8_t reverse_video;
|
||||
uint8_t bold;
|
||||
uint8_t blink;
|
||||
uint8_t underline;
|
||||
uint8_t newline_mode;
|
||||
uint8_t auto_echo;
|
||||
uint8_t handle_backspace;
|
||||
} console_info_t;
|
||||
47
samples/C/interface.h
Normal file
47
samples/C/interface.h
Normal file
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <console/info.h>
|
||||
#include <console/filter.h>
|
||||
#include <console/driver.h>
|
||||
|
||||
typedef struct {
|
||||
console_info_t info;
|
||||
|
||||
console_filter_t* input_filter;
|
||||
console_filter_t* output_filter;
|
||||
|
||||
console_driver_t* input_driver;
|
||||
console_driver_t* output_driver;
|
||||
} console_t;
|
||||
|
||||
console_t* default_console;
|
||||
|
||||
// Generate raw console, connected to the Display, Keyboard and the
|
||||
// ECMA-48-Filter
|
||||
void console_init();
|
||||
|
||||
size_t console_write(console_t* console, const char* buffer, int32_t length);
|
||||
#define console_write2(console, buffer) console_write(console, buffer, strlen(buffer))
|
||||
size_t console_read(console_t* console, char* buffer, size_t length);
|
||||
size_t console_scroll(console_t* console, int32_t pages);
|
||||
|
||||
void console_clear(console_t* console);
|
||||
50
samples/C/ip4.h
Normal file
50
samples/C/ip4.h
Normal file
@@ -0,0 +1,50 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <net/net.h>
|
||||
|
||||
#define IP4_TOS_ICMP 0
|
||||
|
||||
typedef uint32_t ip4_addr_t;
|
||||
|
||||
typedef struct {
|
||||
unsigned int hl:4; /* both fields are 4 bits */
|
||||
unsigned int version:4;
|
||||
uint8_t tos;
|
||||
uint16_t len;
|
||||
uint16_t id;
|
||||
uint16_t off;
|
||||
uint8_t ttl;
|
||||
uint8_t p;
|
||||
uint16_t checksum;
|
||||
ip4_addr_t src;
|
||||
ip4_addr_t dst;
|
||||
} ip4_header_t;
|
||||
|
||||
typedef struct {
|
||||
uint8_t type;
|
||||
uint8_t code;
|
||||
uint16_t checksum;
|
||||
uint16_t id;
|
||||
uint16_t sequence;
|
||||
} ip4_icmp_header_t;
|
||||
|
||||
void ip4_receive(net_device_t* origin, net_l2proto_t proto, size_t size, void* raw);
|
||||
110
samples/C/multiboot.h
Normal file
110
samples/C/multiboot.h
Normal file
@@ -0,0 +1,110 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2010, 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
|
||||
#define MULTIBOOT_KERNELMAGIC 0x2BADB002
|
||||
|
||||
#define MULTIBOOT_FLAG_MEM 0x001
|
||||
#define MULTIBOOT_FLAG_DEVICE 0x002
|
||||
#define MULTIBOOT_FLAG_CMDLINE 0x004
|
||||
#define MULTIBOOT_FLAG_MODS 0x008
|
||||
#define MULTIBOOT_FLAG_AOUT 0x010
|
||||
#define MULTIBOOT_FLAG_ELF 0x020
|
||||
#define MULTIBOOT_FLAG_MMAP 0x040
|
||||
#define MULTIBOOT_FLAG_CONFIG 0x080
|
||||
#define MULTIBOOT_FLAG_LOADER 0x100
|
||||
#define MULTIBOOT_FLAG_APM 0x200
|
||||
#define MULTIBOOT_FLAG_VBE 0x400
|
||||
|
||||
// The symbol table for a.out.
|
||||
typedef struct
|
||||
{
|
||||
uint32_t tabSize;
|
||||
uint32_t strSize;
|
||||
uint32_t addr;
|
||||
uint32_t reserved;
|
||||
} __attribute__((packed)) multiboot_aoutSymbolTable_t;
|
||||
|
||||
// The section header table for ELF.
|
||||
typedef struct
|
||||
{
|
||||
uint32_t num;
|
||||
uint32_t size;
|
||||
uint32_t addr;
|
||||
uint32_t shndx;
|
||||
} __attribute__((packed)) multiboot_elfSectionHeaderTable_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint32_t size;
|
||||
uint64_t addr;
|
||||
uint64_t length;
|
||||
uint32_t type;
|
||||
} __attribute__((packed)) multiboot_memoryMap_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint32_t start;
|
||||
uint32_t end;
|
||||
char* cmdLine;
|
||||
uint32_t reserved;
|
||||
} __attribute__((packed)) multiboot_module_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint32_t flags;
|
||||
uint32_t memLower;
|
||||
uint32_t memUpper;
|
||||
uint32_t bootDevice;
|
||||
char* cmdLine;
|
||||
uint32_t modsCount;
|
||||
multiboot_module_t* modsAddr;
|
||||
|
||||
union
|
||||
{
|
||||
multiboot_aoutSymbolTable_t aoutSym;
|
||||
multiboot_elfSectionHeaderTable_t elfSec;
|
||||
} u;
|
||||
|
||||
uint32_t mmapLength;
|
||||
uint32_t mmapAddr;
|
||||
|
||||
uint32_t drivesLength;
|
||||
uint32_t drivesAddr;
|
||||
|
||||
// ROM configuration table
|
||||
uint32_t configTable;
|
||||
|
||||
char* bootLoaderName;
|
||||
uint32_t apmTable;
|
||||
|
||||
// Video
|
||||
uint32_t vbeControlInfo;
|
||||
uint32_t vbeModeInfo;
|
||||
uint16_t vbeMode;
|
||||
uint16_t vbeInterfaceSeg;
|
||||
uint16_t vbeInterfaceOff;
|
||||
uint16_t vbeInterfaceLen;
|
||||
} __attribute__((packed)) multiboot_info_t;
|
||||
|
||||
multiboot_info_t* multiboot_info;
|
||||
|
||||
void arch_multiboot_printInfo();
|
||||
89
samples/C/ntru_encrypt.h
Normal file
89
samples/C/ntru_encrypt.h
Normal file
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
* Copyright (C) 2014 FH Bielefeld
|
||||
*
|
||||
* This file is part of a FH Bielefeld project.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||||
* MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file ntru_encrypt.h
|
||||
* Header for the internal API of ntru_encrypt.c.
|
||||
* @brief header for encrypt.c
|
||||
*/
|
||||
|
||||
#ifndef PQC_ENCRYPT_H
|
||||
#define PQC_ENCRYPT_H
|
||||
|
||||
|
||||
#include "ntru_params.h"
|
||||
#include "ntru_poly.h"
|
||||
#include "ntru_string.h"
|
||||
|
||||
#include <fmpz_poly.h>
|
||||
#include <fmpz.h>
|
||||
|
||||
|
||||
/**
|
||||
* encrypt the msg, using the math:
|
||||
* e = (h ∗ r) + m (mod q)
|
||||
*
|
||||
* e = the encrypted poly
|
||||
*
|
||||
* h = the public key
|
||||
*
|
||||
* r = the random poly
|
||||
*
|
||||
* m = the message poly
|
||||
*
|
||||
* q = large mod
|
||||
*
|
||||
* @param msg_tern the message to encrypt, in ternary format
|
||||
* @param pub_key the public key
|
||||
* @param rnd the random poly (should have relatively small
|
||||
* coefficients, but not restricted to {-1, 0, 1})
|
||||
* @param out the output poly which is in the range {0, q-1}
|
||||
* (not ternary!) [out]
|
||||
* @param params ntru_params the ntru context
|
||||
*/
|
||||
void
|
||||
ntru_encrypt_poly(
|
||||
const fmpz_poly_t msg_tern,
|
||||
const fmpz_poly_t pub_key,
|
||||
const fmpz_poly_t rnd,
|
||||
fmpz_poly_t out,
|
||||
const ntru_params *params);
|
||||
|
||||
/**
|
||||
* Encrypt a message in the form of a null-terminated char array and
|
||||
* return a string.
|
||||
*
|
||||
* @param msg the message
|
||||
* @param pub_key the public key
|
||||
* @param rnd the random poly (should have relatively small
|
||||
* coefficients, but not restricted to {-1, 0, 1})
|
||||
* @param params ntru_params the ntru context
|
||||
* @return the newly allocated encrypted string
|
||||
*/
|
||||
string *
|
||||
ntru_encrypt_string(
|
||||
const string *msg,
|
||||
const fmpz_poly_t pub_key,
|
||||
const fmpz_poly_t rnd,
|
||||
const ntru_params *params);
|
||||
|
||||
|
||||
#endif /* PQC_ENCRYPT_H */
|
||||
43
samples/C/portio.h
Normal file
43
samples/C/portio.h
Normal file
@@ -0,0 +1,43 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <lib/stdint.h>
|
||||
|
||||
// Legacy
|
||||
#define outb(args...) portio_out8(args)
|
||||
#define outw(args...) portio_out16(args)
|
||||
#define outl(args...) portio_out32(args)
|
||||
#define outq(args...) portio_out64(args)
|
||||
|
||||
#define inb(args...) portio_in8(args)
|
||||
#define inw(args...) portio_in16(args)
|
||||
#define inl(args...) portio_in32(args)
|
||||
#define inq(args...) portio_in64(args)
|
||||
|
||||
void portio_out8(uint16_t port, uint8_t value);
|
||||
void portio_out16(uint16_t port, uint16_t value);
|
||||
void portio_out32(uint16_t port, uint32_t value);
|
||||
void portio_out64(uint16_t port, uint64_t value);
|
||||
|
||||
uint8_t portio_in8(uint16_t port);
|
||||
uint16_t portio_in16(uint16_t port);
|
||||
uint32_t portio_in32(uint16_t port);
|
||||
uint64_t portio_in64(uint16_t port);
|
||||
166
samples/C/pqiv.h
Normal file
166
samples/C/pqiv.h
Normal file
@@ -0,0 +1,166 @@
|
||||
/**
|
||||
* pqiv
|
||||
*
|
||||
* Copyright (c) 2013-2014, Phillip Berndt
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
// This file contains the definition of files, image types and
|
||||
// the plugin infrastructure. It should be included in file type
|
||||
// handlers.
|
||||
|
||||
#ifndef _PQIV_H_INCLUDED
|
||||
#define _PQIV_H_INCLUDED
|
||||
|
||||
#include <glib.h>
|
||||
#include <gtk/gtk.h>
|
||||
#include <gio/gio.h>
|
||||
#include "lib/bostree.h"
|
||||
|
||||
#ifndef PQIV_VERSION
|
||||
#define PQIV_VERSION "2.3"
|
||||
#endif
|
||||
|
||||
#define FILE_FLAGS_ANIMATION (guint)(1)
|
||||
#define FILE_FLAGS_MEMORY_IMAGE (guint)(1<<1)
|
||||
|
||||
// The structure for images {{{
|
||||
typedef struct file_type_handler_struct_t file_type_handler_t;
|
||||
typedef struct {
|
||||
// File type
|
||||
const file_type_handler_t *file_type;
|
||||
|
||||
// Special flags
|
||||
// FILE_FLAGS_ANIMATION -> Animation functions are invoked
|
||||
// Set by file type handlers
|
||||
// FILE_FLAGS_MEMORY_IMAGE -> File lives in memory
|
||||
guint file_flags;
|
||||
|
||||
// The file name to display and to sort by
|
||||
gchar *display_name;
|
||||
|
||||
// The URI or file name of the file
|
||||
gchar *file_name;
|
||||
|
||||
// If the file is a memory image, the actual image data
|
||||
GBytes *file_data;
|
||||
|
||||
// The file monitor structure is used for inotify-watching of
|
||||
// the files
|
||||
GFileMonitor *file_monitor;
|
||||
|
||||
// This flag stores whether this image is currently loaded
|
||||
// and valid. i.e. if it is set, you can assume that
|
||||
// private_data contains a representation of the image;
|
||||
// if not, you can NOT assume that it does not.
|
||||
gboolean is_loaded;
|
||||
|
||||
// Cached image size
|
||||
guint width;
|
||||
guint height;
|
||||
|
||||
// File-type specific data, allocated and freed by the file type handlers
|
||||
void *private;
|
||||
} file_t;
|
||||
// }}}
|
||||
// Definition of the built-in file types {{{
|
||||
|
||||
// If you want to implement your own file type, you'll have to implement the
|
||||
// following functions and a non-static initialization function named
|
||||
// file_type_NAME_initializer that fills a file_type_handler_t with pointers to
|
||||
// the functions. Store the file in backends/NAME.c and adjust the Makefile to
|
||||
// add the required libraries if your backend is listed in the $(BACKENDS)
|
||||
// variable.
|
||||
|
||||
typedef enum { PARAMETER, RECURSION, INOTIFY, BROWSE_ORIGINAL_PARAMETER, FILTER_OUTPUT } load_images_state_t;
|
||||
// Allocation function: Allocate the ->private structure within a file and add the
|
||||
// image(s) to the list of available images via load_images_handle_parameter_add_file()
|
||||
// If an image is not to be loaded for any reason, the file structure should be
|
||||
// deallocated using file_free()
|
||||
// Returns a pointer to the first added image
|
||||
// Optional, you can also set the pointer to this function to NULL.
|
||||
typedef BOSNode *(*file_type_alloc_fn_t)(load_images_state_t state, file_t *file);
|
||||
|
||||
// Deallocation, if a file is removed from the images list. Free the ->private structure.
|
||||
// Only called if ->private is non-NULL.
|
||||
typedef void (*file_type_free_fn_t)(file_t *file);
|
||||
|
||||
// Actually load a file into memory
|
||||
typedef void (*file_type_load_fn_t)(file_t *file, GInputStream *data, GError **error_pointer);
|
||||
|
||||
// Unload a file
|
||||
typedef void (*file_type_unload_fn_t)(file_t *file);
|
||||
|
||||
// Animation support: Initialize memory for animations, return ms until first frame
|
||||
// Optional, you can also set the pointer to this function to NULL.
|
||||
typedef double (*file_type_animation_initialize_fn_t)(file_t *file);
|
||||
|
||||
// Animation support: Advance to the next frame, return ms until next frame
|
||||
// Optional, you can also set the pointer to this function to NULL.
|
||||
typedef double (*file_type_animation_next_frame_fn_t)(file_t *file);
|
||||
|
||||
// Draw the current view to a cairo context
|
||||
typedef void (*file_type_draw_fn_t)(file_t *file, cairo_t *cr);
|
||||
|
||||
struct file_type_handler_struct_t {
|
||||
// All files will be filtered with this filter. If it lets it pass,
|
||||
// a handler is assigned to a file. If none do, the file is
|
||||
// discarded if it was found during directory traversal or
|
||||
// loaded using the first image backend if it was an explicit
|
||||
// parameter.
|
||||
GtkFileFilter *file_types_handled;
|
||||
|
||||
// Pointers to the functions defined above
|
||||
file_type_alloc_fn_t alloc_fn;
|
||||
file_type_free_fn_t free_fn;
|
||||
file_type_load_fn_t load_fn;
|
||||
file_type_unload_fn_t unload_fn;
|
||||
file_type_animation_initialize_fn_t animation_initialize_fn;
|
||||
file_type_animation_next_frame_fn_t animation_next_frame_fn;
|
||||
file_type_draw_fn_t draw_fn;
|
||||
};
|
||||
|
||||
// Initialization function: Tell pqiv about a backend
|
||||
typedef void (*file_type_initializer_fn_t)(file_type_handler_t *info);
|
||||
|
||||
// pqiv symbols available to plugins {{{
|
||||
|
||||
// Global cancellable that should be used for every i/o operation
|
||||
extern GCancellable *image_loader_cancellable;
|
||||
|
||||
// Current scale level. For backends that don't support cairo natively.
|
||||
extern gdouble current_scale_level;
|
||||
|
||||
// Load a file from disc/memory/network
|
||||
GInputStream *image_loader_stream_file(file_t *file, GError **error_pointer);
|
||||
|
||||
// Add a file to the list of loaded files
|
||||
// Should be called at least once in a file_type_alloc_fn_t, with the state being
|
||||
// forwarded unaltered.
|
||||
BOSNode *load_images_handle_parameter_add_file(load_images_state_t state, file_t *file);
|
||||
|
||||
// Load all data from an input stream into memory, conveinience function
|
||||
GBytes *g_input_stream_read_completely(GInputStream *input_stream, GCancellable *cancellable, GError **error_pointer);
|
||||
|
||||
// Free a file
|
||||
void file_free(file_t *file);
|
||||
|
||||
// }}}
|
||||
|
||||
// File type handlers, used in the initializer and file type guessing
|
||||
extern file_type_handler_t file_type_handlers[];
|
||||
|
||||
/* }}} */
|
||||
|
||||
#endif
|
||||
69
samples/C/scheduler.h
Normal file
69
samples/C/scheduler.h
Normal file
@@ -0,0 +1,69 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <hw/cpu.h>
|
||||
#include <memory/vmem.h>
|
||||
|
||||
#define SCHEDULER_MAXNAME 256
|
||||
#define SCHEDULER_TASK_PATH_MAX 256
|
||||
|
||||
// Single linked list
|
||||
typedef struct task {
|
||||
uint32_t pid;
|
||||
char name[SCHEDULER_MAXNAME];
|
||||
struct task *parent;
|
||||
cpu_state_t* state;
|
||||
struct task* next;
|
||||
struct task* previous;
|
||||
|
||||
void* stack;
|
||||
void* entry;
|
||||
struct vmem_context *memory_context;
|
||||
|
||||
// Current task state
|
||||
enum {
|
||||
TASK_STATE_KILLED,
|
||||
TASK_STATE_TERMINATED,
|
||||
TASK_STATE_BLOCKING,
|
||||
TASK_STATE_STOPPED,
|
||||
TASK_STATE_RUNNING
|
||||
} task_state;
|
||||
|
||||
char** environ;
|
||||
char** argv;
|
||||
int argc;
|
||||
|
||||
// TODO Is this actually the same as PATH_MAX in our toolchain?
|
||||
char cwd[SCHEDULER_TASK_PATH_MAX + 1];
|
||||
} task_t;
|
||||
|
||||
int scheduler_state;
|
||||
|
||||
task_t* scheduler_new(void* entry, task_t* parent, char name[SCHEDULER_MAXNAME],
|
||||
char** environ, char** argv, int argc, struct vmem_context* memory_context, bool map_structs);
|
||||
void scheduler_add(task_t *task);
|
||||
void scheduler_terminate_current();
|
||||
task_t* scheduler_get_current();
|
||||
task_t* scheduler_select(cpu_state_t* lastRegs);
|
||||
void scheduler_init();
|
||||
void scheduler_yield();
|
||||
void scheduler_remove(task_t *t);
|
||||
task_t* scheduler_fork(task_t* to_fork, cpu_state_t* state);
|
||||
95
samples/C/syscalls.h
Normal file
95
samples/C/syscalls.h
Normal file
@@ -0,0 +1,95 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
#include <tasks/syscall.h>
|
||||
|
||||
#include "syscalls/write.h"
|
||||
#include "syscalls/exit.h"
|
||||
#include "syscalls/getpid.h"
|
||||
#include "syscalls/getppid.h"
|
||||
#include "syscalls/read.h"
|
||||
#include "syscalls/brk.h"
|
||||
#include "syscalls/mmap.h"
|
||||
#include "syscalls/munmap.h"
|
||||
#include "syscalls/test.h"
|
||||
#include "syscalls/hostname.h"
|
||||
#include "syscalls/uname.h"
|
||||
#include "syscalls/open.h"
|
||||
#include "syscalls/execve.h"
|
||||
#include "syscalls/seek.h"
|
||||
#include "syscalls/opendir.h"
|
||||
#include "syscalls/readdir.h"
|
||||
#include "syscalls/kill.h"
|
||||
#include "syscalls/getexecdata.h"
|
||||
#include "syscalls/cwd.h"
|
||||
#include "syscalls/fork.h"
|
||||
|
||||
syscall_t syscall_table[] = {
|
||||
NULL,
|
||||
sys_exit, // 1
|
||||
sys_read, // 2
|
||||
sys_write, // 3
|
||||
sys_getpid, // 4
|
||||
sys_brk, // 5
|
||||
sys_getppid, // 6
|
||||
sys_mmap, // 7
|
||||
sys_munmap, // 8
|
||||
sys_test, // 9
|
||||
sys_get_hostname, // 10
|
||||
sys_set_hostname, // 11
|
||||
sys_uname, // 12
|
||||
sys_open, // 13
|
||||
sys_execve, // 14
|
||||
sys_seek, // 15
|
||||
sys_opendir, // 16
|
||||
sys_readdir, // 17
|
||||
sys_kill, // 18
|
||||
sys_getexecdata, // 19
|
||||
sys_chdir, // 20
|
||||
sys_getcwd, // 21
|
||||
sys_fork, // 22
|
||||
};
|
||||
|
||||
char* syscall_name_table[] = {
|
||||
NULL,
|
||||
"exit", // 1
|
||||
"read", // 2
|
||||
"write", // 3
|
||||
"getpid", // 4
|
||||
"brk", // 5
|
||||
"getppid", // 6
|
||||
"mmap", // 7
|
||||
"munmap", // 8
|
||||
"test", // 9
|
||||
"get_hostname", // 10
|
||||
"set_hostname", // 11
|
||||
"uname", // 12
|
||||
"open", // 13
|
||||
"execve", // 14
|
||||
"seek", // 15
|
||||
"opendir", // 16
|
||||
"readdir", // 17
|
||||
"kill", // 18
|
||||
"getexecdata", // 19
|
||||
"chdir", // 20
|
||||
"getcwd", // 21
|
||||
"fork", // 22
|
||||
};
|
||||
56
samples/C/vfs.h
Normal file
56
samples/C/vfs.h
Normal file
@@ -0,0 +1,56 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2010, 2011 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
|
||||
#define VFS_SEEK_SET 0
|
||||
#define VFS_SEEK_CUR 1
|
||||
#define VFS_SEEK_END 2
|
||||
|
||||
typedef struct {
|
||||
uint64_t num;
|
||||
char path[512];
|
||||
char mount_path[512];
|
||||
uint32_t offset;
|
||||
uint32_t mountpoint;
|
||||
} vfs_file_t;
|
||||
|
||||
typedef struct {
|
||||
uint64_t num;
|
||||
char path[512];
|
||||
char mount_path[512];
|
||||
uint32_t mountpoint;
|
||||
} vfs_dir_t;
|
||||
|
||||
typedef void* (*vfs_read_callback_t)(char* path, uint32_t offset, uint32_t size);
|
||||
typedef char* (*vfs_read_dir_callback_t)(char* path, uint32_t offset);
|
||||
|
||||
|
||||
// Used to always store the last read/write attempt (used for kernel panic debugging)
|
||||
char vfs_last_read_attempt[512];
|
||||
|
||||
vfs_file_t* vfs_get_from_id(uint32_t id);
|
||||
vfs_dir_t* vfs_get_dir_from_id(uint32_t id);
|
||||
void* vfs_read(vfs_file_t* fp, uint32_t size);
|
||||
char* vfs_dir_read(vfs_dir_t* dir, uint32_t offset);
|
||||
void vfs_seek(vfs_file_t* fp, uint32_t offset, int origin);
|
||||
vfs_file_t* vfs_open(char* path);
|
||||
vfs_dir_t* vfs_dir_open(char* path);
|
||||
int vfs_mount(char* path, vfs_read_callback_t read_callback, vfs_read_dir_callback_t read_dir_callback);
|
||||
94
samples/C/vmem.h
Normal file
94
samples/C/vmem.h
Normal file
@@ -0,0 +1,94 @@
|
||||
#pragma once
|
||||
|
||||
/* Copyright © 2011 Fritz Grimpen
|
||||
* Copyright © 2013 Lukas Martini
|
||||
*
|
||||
* This file is part of Xelix.
|
||||
*
|
||||
* Xelix is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* Xelix is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with Xelix. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <lib/generic.h>
|
||||
|
||||
struct vmem_context;
|
||||
|
||||
struct vmem_page
|
||||
{
|
||||
enum
|
||||
{
|
||||
VMEM_SECTION_STACK, /* Initial stack */
|
||||
VMEM_SECTION_CODE, /* Contains program code and is read-only */
|
||||
VMEM_SECTION_DATA, /* Contains static data */
|
||||
VMEM_SECTION_HEAP, /* Allocated by brk(2) at runtime */
|
||||
VMEM_SECTION_MMAP, /* Allocated by mmap(2) at runtime */
|
||||
VMEM_SECTION_KERNEL, /* Contains kernel-internal data */
|
||||
VMEM_SECTION_UNMAPPED /* Unmapped */
|
||||
} section;
|
||||
|
||||
bool readonly:1;
|
||||
bool cow:1; /* Copy-on-Write mechanism */
|
||||
bool allocated:1;
|
||||
|
||||
void *cow_src_addr;
|
||||
void *virt_addr;
|
||||
void *phys_addr;
|
||||
};
|
||||
|
||||
typedef void (*vmem_iterator_t)(struct vmem_context *, struct vmem_page *, uint32_t);
|
||||
|
||||
/* Initialize vmem_kernelContext for paging_init() */
|
||||
void vmem_init();
|
||||
struct vmem_context *vmem_kernelContext;
|
||||
struct vmem_context *vmem_currentContext;
|
||||
struct vmem_context *vmem_processContext;
|
||||
void *vmem_faultAddress;
|
||||
|
||||
/* Some callbacks for magic functions */
|
||||
void (*vmem_applyPage)(struct vmem_context *, struct vmem_page *);
|
||||
|
||||
/* Generate new page context */
|
||||
struct vmem_context *vmem_new();
|
||||
struct vmem_page *vmem_new_page();
|
||||
|
||||
int vmem_add_page(struct vmem_context *ctx, struct vmem_page *pg);
|
||||
|
||||
struct vmem_page *vmem_get_page_phys(struct vmem_context *ctx, void *phys_addr);
|
||||
struct vmem_page *vmem_get_page_virt(struct vmem_context *ctx, void *virt_addr);
|
||||
struct vmem_page *vmem_get_page(struct vmem_context *ctx, uint32_t offset);
|
||||
|
||||
/* Remove pages in a specific context by physical or virtual address */
|
||||
struct vmem_page *vmem_rm_page_phys(struct vmem_context *ctx, void *phys_addr);
|
||||
struct vmem_page *vmem_rm_page_virt(struct vmem_context *ctx, void *virt_addr);
|
||||
|
||||
/* Iterator */
|
||||
int vmem_iterate(struct vmem_context *ctx, vmem_iterator_t callback);
|
||||
|
||||
uint32_t vmem_count_pages(struct vmem_context *ctx);
|
||||
void vmem_dump_page(struct vmem_page *pg);
|
||||
void vmem_dump(struct vmem_context *ctx);
|
||||
void vmem_handle_fault(uint32_t code, void *addr, void *instruction);
|
||||
|
||||
/* Get/Set cached paging context */
|
||||
void vmem_set_cache(struct vmem_context *ctx, void *cache);
|
||||
void *vmem_get_cache(struct vmem_context *ctx);
|
||||
|
||||
#ifdef __i386__
|
||||
#define PAGE_SIZE 4096
|
||||
#define VMEM_ALIGN(x) (typeof(x))(((intptr_t)(x) & 0xFFFFF000) + 0x1000)
|
||||
#define VMEM_ALIGN_DOWN(x) (typeof(x))( \
|
||||
((intptr_t)(x) - ((intptr_t)(x) % PAGE_SIZE)))
|
||||
#else
|
||||
#define PAGE_SIZE 0
|
||||
#define VMEM_ALIGN(x) (x)
|
||||
#endif
|
||||
343
samples/CLIPS/demo.clp
Normal file
343
samples/CLIPS/demo.clp
Normal file
@@ -0,0 +1,343 @@
|
||||
;;;***************************
|
||||
;;;* DEFFACTS KNOWLEDGE BASE *
|
||||
;;;***************************
|
||||
|
||||
(deffacts MAIN::knowledge-base
|
||||
(welcome (message WelcomeMessage))
|
||||
(goal (variable type.animal))
|
||||
(legalanswers (values yes no))
|
||||
(displayanswers (values "Yes" "No"))
|
||||
(rule (if backbone is yes)
|
||||
(then superphylum is backbone))
|
||||
(rule (if backbone is no)
|
||||
(then superphylum is jellyback))
|
||||
(question (variable backbone)
|
||||
(query backbone.query))
|
||||
(rule (if superphylum is backbone and
|
||||
warm.blooded is yes)
|
||||
(then phylum is warm))
|
||||
(rule (if superphylum is backbone and
|
||||
warm.blooded is no)
|
||||
(then phylum is cold))
|
||||
(question (variable warm.blooded)
|
||||
(query warm.blooded.query))
|
||||
(rule (if superphylum is jellyback and
|
||||
live.prime.in.soil is yes)
|
||||
(then phylum is soil))
|
||||
(rule (if superphylum is jellyback and
|
||||
live.prime.in.soil is no)
|
||||
(then phylum is elsewhere))
|
||||
(question (variable live.prime.in.soil)
|
||||
(query live.prime.in.soil.query))
|
||||
(rule (if phylum is warm and
|
||||
has.breasts is yes)
|
||||
(then class is breasts))
|
||||
(rule (if phylum is warm and
|
||||
has.breasts is no)
|
||||
(then type.animal is bird))
|
||||
(question (variable has.breasts)
|
||||
(query has.breasts.query))
|
||||
(rule (if phylum is cold and
|
||||
always.in.water is yes)
|
||||
(then class is water))
|
||||
(rule (if phylum is cold and
|
||||
always.in.water is no)
|
||||
(then class is dry))
|
||||
(question (variable always.in.water)
|
||||
(query always.in.water.query))
|
||||
(rule (if phylum is soil and
|
||||
flat.bodied is yes)
|
||||
(then type.animal is flatworm))
|
||||
(rule (if phylum is soil and
|
||||
flat.bodied is no)
|
||||
(then type.animal is worm.leech))
|
||||
(question (variable flat.bodied)
|
||||
(query flat.bodied.query))
|
||||
(rule (if phylum is elsewhere and
|
||||
body.in.segments is yes)
|
||||
(then class is segments))
|
||||
(rule (if phylum is elsewhere and
|
||||
body.in.segments is no)
|
||||
(then class is unified))
|
||||
(question (variable body.in.segments)
|
||||
(query body.in.segments.query))
|
||||
(rule (if class is breasts and
|
||||
can.eat.meat is yes)
|
||||
(then order is meat))
|
||||
(rule (if class is breasts and
|
||||
can.eat.meat is no)
|
||||
(then order is vegy))
|
||||
(question (variable can.eat.meat)
|
||||
(query can.eat.meat.query))
|
||||
(rule (if class is water and
|
||||
boney is yes)
|
||||
(then type.animal is fish))
|
||||
(rule (if class is water and
|
||||
boney is no)
|
||||
(then type.animal is shark.ray))
|
||||
(question (variable boney)
|
||||
(query boney.query))
|
||||
(rule (if class is dry and
|
||||
scaly is yes)
|
||||
(then order is scales))
|
||||
(rule (if class is dry and
|
||||
scaly is no)
|
||||
(then order is soft))
|
||||
(question (variable scaly)
|
||||
(query scaly.query))
|
||||
(rule (if class is segments and
|
||||
shell is yes)
|
||||
(then order is shell))
|
||||
(rule (if class is segments and
|
||||
shell is no)
|
||||
(then type.animal is centipede.millipede.insect))
|
||||
(question (variable shell)
|
||||
(query shell.query))
|
||||
(rule (if class is unified and
|
||||
digest.cells is yes)
|
||||
(then order is cells))
|
||||
(rule (if class is unified and
|
||||
digest.cells is no)
|
||||
(then order is stomach))
|
||||
(question (variable digest.cells)
|
||||
(query digest.cells.query))
|
||||
(rule (if order is meat and
|
||||
fly is yes)
|
||||
(then type.animal is bat))
|
||||
(rule (if order is meat and
|
||||
fly is no)
|
||||
(then family is nowings))
|
||||
(question (variable fly)
|
||||
(query fly.query))
|
||||
(rule (if order is vegy and
|
||||
hooves is yes)
|
||||
(then family is hooves))
|
||||
(rule (if order is vegy and
|
||||
hooves is no)
|
||||
(then family is feet))
|
||||
(question (variable hooves)
|
||||
(query hooves.query))
|
||||
(rule (if order is scales and
|
||||
rounded.shell is yes)
|
||||
(then type.animal is turtle))
|
||||
(rule (if order is scales and
|
||||
rounded.shell is no)
|
||||
(then family is noshell))
|
||||
(question (variable rounded.shell)
|
||||
(query rounded.shell.query))
|
||||
(rule (if order is soft and
|
||||
jump is yes)
|
||||
(then type.animal is frog))
|
||||
(rule (if order is soft and
|
||||
jump is no)
|
||||
(then type.animal is salamander))
|
||||
(question (variable jump)
|
||||
(query jump.query))
|
||||
(rule (if order is shell and
|
||||
tail is yes)
|
||||
(then type.animal is lobster))
|
||||
(rule (if order is shell and
|
||||
tail is no)
|
||||
(then type.animal is crab))
|
||||
(question (variable tail)
|
||||
(query tail.query))
|
||||
(rule (if order is cells and
|
||||
stationary is yes)
|
||||
(then family is stationary))
|
||||
(rule (if order is cells and
|
||||
stationary is no)
|
||||
(then type.animal is jellyfish))
|
||||
(question (variable stationary)
|
||||
(query stationary.query))
|
||||
(rule (if order is stomach and
|
||||
multicelled is yes)
|
||||
(then family is multicelled))
|
||||
(rule (if order is stomach and
|
||||
multicelled is no)
|
||||
(then type.animal is protozoa))
|
||||
(question (variable multicelled)
|
||||
(query multicelled.query))
|
||||
(rule (if family is nowings and
|
||||
opposing.thumb is yes)
|
||||
(then genus is thumb))
|
||||
(rule (if family is nowings and
|
||||
opposing.thumb is no)
|
||||
(then genus is nothumb))
|
||||
(question (variable opposing.thumb)
|
||||
(query opposing.thumb.query))
|
||||
(rule (if family is hooves and
|
||||
two.toes is yes)
|
||||
(then genus is twotoes))
|
||||
(rule (if family is hooves and
|
||||
two.toes is no)
|
||||
(then genus is onetoe))
|
||||
(question (variable two.toes)
|
||||
(query two.toes.query))
|
||||
(rule (if family is feet and
|
||||
live.in.water is yes)
|
||||
(then genus is water))
|
||||
(rule (if family is feet and
|
||||
live.in.water is no)
|
||||
(then genus is dry))
|
||||
(question (variable live.in.water)
|
||||
(query live.in.water.query))
|
||||
(rule (if family is noshell and
|
||||
limbs is yes)
|
||||
(then type.animal is crocodile.alligator))
|
||||
(rule (if family is noshell and
|
||||
limbs is no)
|
||||
(then type.animal is snake))
|
||||
(question (variable limbs)
|
||||
(query limbs.query))
|
||||
(rule (if family is stationary and
|
||||
spikes is yes)
|
||||
(then type.animal is sea.anemone))
|
||||
(rule (if family is stationary and
|
||||
spikes is no)
|
||||
(then type.animal is coral.sponge))
|
||||
(question (variable spikes)
|
||||
(query spikes.query))
|
||||
(rule (if family is multicelled and
|
||||
spiral.shell is yes)
|
||||
(then type.animal is snail))
|
||||
(rule (if family is multicelled and
|
||||
spiral.shell is no)
|
||||
(then genus is noshell))
|
||||
(question (variable spiral.shell)
|
||||
(query spiral.shell.query))
|
||||
(rule (if genus is thumb and
|
||||
prehensile.tail is yes)
|
||||
(then type.animal is monkey))
|
||||
(rule (if genus is thumb and
|
||||
prehensile.tail is no)
|
||||
(then species is notail))
|
||||
(question (variable prehensile.tail)
|
||||
(query prehensile.tail.query))
|
||||
(rule (if genus is nothumb and
|
||||
over.400 is yes)
|
||||
(then species is 400))
|
||||
(rule (if genus is nothumb and
|
||||
over.400 is no)
|
||||
(then species is under400))
|
||||
(question (variable over.400)
|
||||
(query over.400.query))
|
||||
(rule (if genus is twotoes and
|
||||
horns is yes)
|
||||
(then species is horns))
|
||||
(rule (if genus is twotoes and
|
||||
horns is no)
|
||||
(then species is nohorns))
|
||||
(question (variable horns)
|
||||
(query horns.query))
|
||||
(rule (if genus is onetoe and
|
||||
plating is yes)
|
||||
(then type.animal is rhinoceros))
|
||||
(rule (if genus is onetoe and
|
||||
plating is no)
|
||||
(then type.animal is horse.zebra))
|
||||
(question (variable plating)
|
||||
(query plating.query))
|
||||
(rule (if genus is water and
|
||||
hunted is yes)
|
||||
(then type.animal is whale))
|
||||
(rule (if genus is water and
|
||||
hunted is no)
|
||||
(then type.animal is dolphin.porpoise))
|
||||
(question (variable hunted)
|
||||
(query hunted.query))
|
||||
(rule (if genus is dry and
|
||||
front.teeth is yes)
|
||||
(then species is teeth))
|
||||
(rule (if genus is dry and
|
||||
front.teeth is no)
|
||||
(then species is noteeth))
|
||||
(question (variable front.teeth)
|
||||
(query front.teeth.query))
|
||||
(rule (if genus is noshell and
|
||||
bivalve is yes)
|
||||
(then type.animal is clam.oyster))
|
||||
(rule (if genus is noshell and
|
||||
bivalve is no)
|
||||
(then type.animal is squid.octopus))
|
||||
(question (variable bivalve)
|
||||
(query bivalve.query))
|
||||
(rule (if species is notail and
|
||||
nearly.hairless is yes)
|
||||
(then type.animal is man))
|
||||
(rule (if species is notail and
|
||||
nearly.hairless is no)
|
||||
(then subspecies is hair))
|
||||
(question (variable nearly.hairless)
|
||||
(query nearly.hairless.query))
|
||||
(rule (if species is 400 and
|
||||
land.based is yes)
|
||||
(then type.animal is bear.tiger.lion))
|
||||
(rule (if species is 400 and
|
||||
land.based is no)
|
||||
(then type.animal is walrus))
|
||||
(question (variable land.based)
|
||||
(query land.based.query))
|
||||
(rule (if species is under400 and
|
||||
thintail is yes)
|
||||
(then type.animal is cat))
|
||||
(rule (if species is under400 and
|
||||
thintail is no)
|
||||
(then type.animal is coyote.wolf.fox.dog))
|
||||
(question (variable thintail)
|
||||
(query thintail.query))
|
||||
(rule (if species is nohorns and
|
||||
lives.in.desert is yes)
|
||||
(then type.animal is camel))
|
||||
(rule (if species is nohorns and
|
||||
lives.in.desert is no and
|
||||
semi.aquatic is no)
|
||||
(then type.animal is giraffe))
|
||||
(rule (if species is nohorns and
|
||||
lives.in.desert is no and
|
||||
semi.aquatic is yes)
|
||||
(then type.animal is hippopotamus))
|
||||
(question (variable lives.in.desert)
|
||||
(query lives.in.desert.query))
|
||||
(question (variable semi.aquatic)
|
||||
(query semi.aquatic.query))
|
||||
(rule (if species is teeth and
|
||||
large.ears is yes)
|
||||
(then type.animal is rabbit))
|
||||
(rule (if species is teeth and
|
||||
large.ears is no)
|
||||
(then type.animal is rat.mouse.squirrel.beaver.porcupine))
|
||||
(question (variable large.ears)
|
||||
(query large.ears.query))
|
||||
(rule (if species is noteeth and
|
||||
pouch is yes)
|
||||
(then type.animal is kangaroo.koala.bear))
|
||||
(rule (if species is noteeth and
|
||||
pouch is no)
|
||||
(then type.animal is mole.shrew.elephant))
|
||||
(question (variable pouch)
|
||||
(query pouch.query))
|
||||
(rule (if subspecies is hair and
|
||||
long.powerful.arms is yes)
|
||||
(then type.animal is orangutan.gorilla.chimpanzee))
|
||||
(rule (if subspecies is hair and
|
||||
long.powerful.arms is no)
|
||||
(then type.animal is baboon))
|
||||
(question (variable long.powerful.arms)
|
||||
(query long.powerful.arms.query))
|
||||
(rule (if species is horns and
|
||||
fleece is yes)
|
||||
(then type.animal is sheep.goat))
|
||||
(rule (if species is horns and
|
||||
fleece is no)
|
||||
(then subsubspecies is nofleece))
|
||||
(question (variable fleece)
|
||||
(query fleece.query))
|
||||
(rule (if subsubspecies is nofleece and
|
||||
domesticated is yes)
|
||||
(then type.animal is cow))
|
||||
(rule (if subsubspecies is nofleece and
|
||||
domesticated is no)
|
||||
(then type.animal is deer.moose.antelope))
|
||||
(question (variable domesticated)
|
||||
(query domesticated.query))
|
||||
(answer (prefix "I think your animal is a ") (variable type.animal) (postfix ".")))
|
||||
281
samples/CLIPS/sudoku.clp
Normal file
281
samples/CLIPS/sudoku.clp
Normal file
@@ -0,0 +1,281 @@
|
||||
;;; http://www.angusj.com/sudoku/hints
|
||||
;;; http://www.scanraid.com/BasicStrategies.htm
|
||||
;;; http://www.sudokuoftheday.com/pages/techniques-overview
|
||||
;;; http://www.sudokuonline.us/sudoku_solving_techniques
|
||||
;;; http://www.sadmansoftware.com/sudoku/techniques.htm
|
||||
;;; http://www.krazydad.com/blog/2005/09/29/an-index-of-sudoku-strategies/
|
||||
|
||||
;;; #######################
|
||||
;;; DEFTEMPLATES & DEFFACTS
|
||||
;;; #######################
|
||||
|
||||
(deftemplate possible
|
||||
(slot row)
|
||||
(slot column)
|
||||
(slot value)
|
||||
(slot group)
|
||||
(slot id))
|
||||
|
||||
(deftemplate impossible
|
||||
(slot id)
|
||||
(slot value)
|
||||
(slot priority)
|
||||
(slot reason))
|
||||
|
||||
(deftemplate technique-employed
|
||||
(slot reason)
|
||||
(slot priority))
|
||||
|
||||
(deftemplate technique
|
||||
(slot name)
|
||||
(slot priority))
|
||||
|
||||
(deffacts startup
|
||||
(phase grid-values))
|
||||
|
||||
(deftemplate size-value
|
||||
(slot size)
|
||||
(slot value))
|
||||
|
||||
(deffacts values
|
||||
(size-value (size 1) (value 1))
|
||||
(size-value (size 2) (value 2))
|
||||
(size-value (size 2) (value 3))
|
||||
(size-value (size 2) (value 4))
|
||||
(size-value (size 3) (value 5))
|
||||
(size-value (size 3) (value 6))
|
||||
(size-value (size 3) (value 7))
|
||||
(size-value (size 3) (value 8))
|
||||
(size-value (size 3) (value 9))
|
||||
(size-value (size 4) (value 10))
|
||||
(size-value (size 4) (value 11))
|
||||
(size-value (size 4) (value 12))
|
||||
(size-value (size 4) (value 13))
|
||||
(size-value (size 4) (value 14))
|
||||
(size-value (size 4) (value 15))
|
||||
(size-value (size 4) (value 16))
|
||||
(size-value (size 5) (value 17))
|
||||
(size-value (size 5) (value 18))
|
||||
(size-value (size 5) (value 19))
|
||||
(size-value (size 5) (value 20))
|
||||
(size-value (size 5) (value 21))
|
||||
(size-value (size 5) (value 22))
|
||||
(size-value (size 5) (value 23))
|
||||
(size-value (size 5) (value 24))
|
||||
(size-value (size 5) (value 25)))
|
||||
|
||||
;;; ###########
|
||||
;;; SETUP RULES
|
||||
;;; ###########
|
||||
|
||||
;;; ***********
|
||||
;;; stress-test
|
||||
;;; ***********
|
||||
|
||||
(defrule stress-test
|
||||
|
||||
(declare (salience 10))
|
||||
|
||||
(phase match)
|
||||
|
||||
(stress-test)
|
||||
|
||||
(priority ?last)
|
||||
|
||||
(not (priority ?p&:(> ?p ?last)))
|
||||
|
||||
(technique (priority ?next&:(> ?next ?last)))
|
||||
|
||||
(not (technique (priority ?p&:(> ?p ?last)&:(< ?p ?next))))
|
||||
|
||||
=>
|
||||
|
||||
(assert (priority ?next)))
|
||||
|
||||
;;; *****************
|
||||
;;; enable-techniques
|
||||
;;; *****************
|
||||
|
||||
(defrule enable-techniques
|
||||
|
||||
(declare (salience 10))
|
||||
|
||||
(phase match)
|
||||
|
||||
(size ?)
|
||||
|
||||
(not (possible (value any)))
|
||||
|
||||
=>
|
||||
|
||||
(assert (priority 1)))
|
||||
|
||||
;;; **********
|
||||
;;; expand-any
|
||||
;;; **********
|
||||
|
||||
(defrule expand-any
|
||||
|
||||
(declare (salience 10))
|
||||
|
||||
(phase expand-any)
|
||||
|
||||
?f <- (possible (row ?r) (column ?c) (value any) (group ?g) (id ?id))
|
||||
|
||||
(not (possible (value any) (id ?id2&:(< ?id2 ?id))))
|
||||
|
||||
(size ?s)
|
||||
|
||||
(size-value (size ?as&:(<= ?as ?s)) (value ?v))
|
||||
|
||||
(not (possible (row ?r) (column ?c) (value ?v)))
|
||||
|
||||
(not (and (size-value (value ?v2&:(< ?v2 ?v)))
|
||||
|
||||
(not (possible (row ?r) (column ?c) (value ?v2)))))
|
||||
|
||||
=>
|
||||
|
||||
(assert (possible (row ?r) (column ?c) (value ?v) (group ?g) (id ?id))))
|
||||
|
||||
;;; *****************
|
||||
;;; position-expanded
|
||||
;;; *****************
|
||||
|
||||
(defrule position-expanded
|
||||
|
||||
(declare (salience 10))
|
||||
|
||||
(phase expand-any)
|
||||
|
||||
?f <- (possible (row ?r) (column ?c) (value any) (group ?g) (id ?id))
|
||||
|
||||
(size ?s)
|
||||
|
||||
(not (and (size-value (size ?as&:(<= ?as ?s)) (value ?v))
|
||||
|
||||
(not (possible (row ?r) (column ?c) (value ?v)))))
|
||||
|
||||
=>
|
||||
|
||||
(retract ?f))
|
||||
|
||||
;;; ###########
|
||||
;;; PHASE RULES
|
||||
;;; ###########
|
||||
|
||||
;;; ***************
|
||||
;;; expand-any-done
|
||||
;;; ***************
|
||||
|
||||
(defrule expand-any-done
|
||||
|
||||
(declare (salience 10))
|
||||
|
||||
?f <- (phase expand-any)
|
||||
|
||||
(not (possible (value any)))
|
||||
|
||||
=>
|
||||
|
||||
(retract ?f)
|
||||
|
||||
(assert (phase initial-output))
|
||||
(assert (print-position 1 1)))
|
||||
|
||||
;;; ***********
|
||||
;;; begin-match
|
||||
;;; ***********
|
||||
|
||||
(defrule begin-match
|
||||
|
||||
(declare (salience -20))
|
||||
|
||||
?f <- (phase initial-output)
|
||||
|
||||
=>
|
||||
|
||||
(retract ?f)
|
||||
|
||||
(assert (phase match)))
|
||||
|
||||
;;; *****************
|
||||
;;; begin-elimination
|
||||
;;; *****************
|
||||
|
||||
(defrule begin-elimination
|
||||
|
||||
(declare (salience -20))
|
||||
|
||||
?f <- (phase match)
|
||||
|
||||
(not (not (impossible)))
|
||||
|
||||
=>
|
||||
|
||||
(retract ?f)
|
||||
|
||||
(assert (phase elimination)))
|
||||
|
||||
;;; *************
|
||||
;;; next-priority
|
||||
;;; *************
|
||||
|
||||
(defrule next-priority
|
||||
|
||||
(declare (salience -20))
|
||||
|
||||
(phase match)
|
||||
|
||||
(not (impossible))
|
||||
|
||||
(priority ?last)
|
||||
|
||||
(not (priority ?p&:(> ?p ?last)))
|
||||
|
||||
(technique (priority ?next&:(> ?next ?last)))
|
||||
|
||||
(not (technique (priority ?p&:(> ?p ?last)&:(< ?p ?next))))
|
||||
|
||||
=>
|
||||
|
||||
(assert (priority ?next)))
|
||||
|
||||
;;; ************
|
||||
;;; begin-output
|
||||
;;; ************
|
||||
|
||||
(defrule begin-output
|
||||
|
||||
(declare (salience -20))
|
||||
|
||||
?f <- (phase match)
|
||||
|
||||
(not (impossible))
|
||||
|
||||
(priority ?last)
|
||||
|
||||
(not (priority ?p&:(> ?p ?last)))
|
||||
|
||||
(not (technique (priority ?next&:(> ?next ?last))))
|
||||
|
||||
=>
|
||||
|
||||
(retract ?f)
|
||||
|
||||
(assert (phase final-output))
|
||||
(assert (print-position 1 1)))
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
12
samples/CMake/filenames/CMakeLists.txt
Normal file
12
samples/CMake/filenames/CMakeLists.txt
Normal file
@@ -0,0 +1,12 @@
|
||||
cmake_minimum_required(VERSION 2.8)
|
||||
|
||||
project(Foo)
|
||||
|
||||
set(CMAKE_SKIP_RPATH TRUE)
|
||||
set(CMAKE_INSTALL_PREFIX "/usr/local")
|
||||
|
||||
add_subdirectory(bar)
|
||||
|
||||
add_executable(foo foo.c)
|
||||
target_link_libraries(foo pthread)
|
||||
install(TARGETS foo DESTINATION bin)
|
||||
15
samples/CMake/sample1.cmake
Normal file
15
samples/CMake/sample1.cmake
Normal file
@@ -0,0 +1,15 @@
|
||||
cmake_minimum_required(VERSION 2.6)
|
||||
|
||||
enable_testing()
|
||||
|
||||
set(CMAKE_BUILD_TYPE debug)
|
||||
|
||||
include_directories("/usr/local/include")
|
||||
|
||||
find_library(ssl_LIBRARY NAMES ssl PATHS "/usr/local/lib")
|
||||
|
||||
add_custom_command(OUTPUT "ver.c" "ver.h" COMMAND ./ver.sh)
|
||||
|
||||
add_executable(foo foo.c bar.c baz.c ver.c)
|
||||
|
||||
target_link_libraries(foo ${ssl_LIBRARY})
|
||||
25
samples/CMake/sample2.cmake
Normal file
25
samples/CMake/sample2.cmake
Normal file
@@ -0,0 +1,25 @@
|
||||
cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
|
||||
|
||||
project(PCLVisualizer)
|
||||
target_link_libraries (PCLVisualizer ${PCL_LIBRARIES})
|
||||
|
||||
#it seems it's needed only on OS X 10.9
|
||||
find_package(GLEW REQUIRED)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/include -v")
|
||||
|
||||
find_package(PCL 1.7 REQUIRED)
|
||||
|
||||
include_directories(${PCL_INCLUDE_DIRS})
|
||||
link_directories(${PCL_LIBRARY_DIRS})
|
||||
add_definitions(${PCL_DEFINITIONS})
|
||||
|
||||
set(PCL_BUILD_TYPE Release)
|
||||
|
||||
file(GLOB PCL_openni_viewer_SRC
|
||||
"src/*.h"
|
||||
"src/*.cpp"
|
||||
)
|
||||
add_executable(PCLVisualizer ${PCL_openni_viewer_SRC})
|
||||
|
||||
#add this line to solve probem in mac os x 10.9
|
||||
target_link_libraries(PCLVisualizer ${PCL_COMMON_LIBRARIES} ${PCL_IO_LIBRARIES} ${PCL_VISUALIZATION_LIBRARIES} ${PCL_FEATURES_LIBRARIES})
|
||||
33
samples/CMake/sample3.cmake
Normal file
33
samples/CMake/sample3.cmake
Normal file
@@ -0,0 +1,33 @@
|
||||
# Specifications for building user and development documentation.
|
||||
#
|
||||
# ====================================================================
|
||||
# Copyright (c) 2009 Ian Blumel. All rights reserved.
|
||||
#
|
||||
# This software is licensed as described in the file LICENSE, which
|
||||
# you should have received as part of this distribution.
|
||||
# ====================================================================
|
||||
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
|
||||
|
||||
FIND_FILE( SPHINX sphinx-build.exe)
|
||||
|
||||
# If we are windows call to the make.bat file, otherwise rely on the Makefile
|
||||
# to handle the processing.
|
||||
IF(WIN32)
|
||||
SET(SPHINX_MAKE make.bat)
|
||||
ELSE(WIN32)
|
||||
SET(SPHINX_MAKE make)
|
||||
ENDIF(WIN32)
|
||||
|
||||
ADD_CUSTOM_TARGET(
|
||||
doc_usr
|
||||
COMMAND ${SPHINX_MAKE} html
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/usr
|
||||
)
|
||||
|
||||
ADD_CUSTOM_TARGET(
|
||||
doc_dev
|
||||
COMMAND ${SPHINX_MAKE} html
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/dev
|
||||
)
|
||||
|
||||
33
samples/CMake/sample4.cmake
Normal file
33
samples/CMake/sample4.cmake
Normal file
@@ -0,0 +1,33 @@
|
||||
cmake_minimum_required (VERSION 2.6)
|
||||
|
||||
set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "bin")
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/vala)
|
||||
find_package(Vala REQUIRED)
|
||||
include(ValaPrecompile)
|
||||
include(ValaVersion)
|
||||
ensure_vala_version("0.11.0" MINIMUM)
|
||||
|
||||
project (template C)
|
||||
|
||||
find_package(PkgConfig)
|
||||
|
||||
pkg_check_modules(GOBJECT REQUIRED gobject-2.0)
|
||||
add_definitions(${GOBJECT_CFLAGS} ${GOBJECT_CFLAGS_OTHER})
|
||||
link_libraries(${GOBJECT_LIBRARIES})
|
||||
link_directories(${GOBJECT_LIBRARY_DIRS})
|
||||
|
||||
|
||||
vala_precompile(VALA_C
|
||||
src/template.vala
|
||||
PACKAGES
|
||||
OPTIONS
|
||||
--thread
|
||||
CUSTOM_VAPIS
|
||||
GENERATE_VAPI
|
||||
GENERATE_HEADER
|
||||
DIRECTORY
|
||||
gen
|
||||
)
|
||||
|
||||
add_executable("template" ${VALA_C})
|
||||
89
samples/CMake/sample5.cmake
Normal file
89
samples/CMake/sample5.cmake
Normal file
@@ -0,0 +1,89 @@
|
||||
# - Check if the STDCALL function exists.
|
||||
# This works for non-cdecl functions (kernel32 functions, for example)
|
||||
# CHECK_STDCALL_FUNCTION_EXISTS(FUNCTION FUNCTION_DUMMY_ARGS VARIABLE)
|
||||
# - macro which checks if the stdcall function exists
|
||||
# FUNCTION_DECLARATION - the definition of the function ( e.g.: Sleep(500) )
|
||||
# VARIABLE - variable to store the result
|
||||
#
|
||||
# The following variables may be set before calling this macro to
|
||||
# modify the way the check is run:
|
||||
#
|
||||
# CMAKE_REQUIRED_FLAGS = string of compile command line flags
|
||||
# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)
|
||||
# CMAKE_REQUIRED_INCLUDES = list of include directories
|
||||
# CMAKE_REQUIRED_LIBRARIES = list of libraries to link
|
||||
# CMAKE_EXTRA_INCLUDE_FILES = list of extra includes to check in
|
||||
|
||||
MACRO(CHECK_STDCALL_FUNCTION_EXISTS FUNCTION_DECLARATION VARIABLE)
|
||||
IF("${VARIABLE}" MATCHES "^${VARIABLE}$")
|
||||
#get includes
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN)
|
||||
FOREACH(def ${CMAKE_EXTRA_INCLUDE_FILES})
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"${def}\"\n")
|
||||
ENDFOREACH(def)
|
||||
|
||||
#add some default includes
|
||||
IF ( HAVE_WINDOWS_H )
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"windows.h\"\n")
|
||||
ENDIF ( HAVE_WINDOWS_H )
|
||||
IF ( HAVE_UNISTD_H )
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"unistd.h\"\n")
|
||||
ENDIF ( HAVE_UNISTD_H )
|
||||
IF ( HAVE_DIRECT_H )
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"direct.h\"\n")
|
||||
ENDIF ( HAVE_DIRECT_H )
|
||||
IF ( HAVE_IO_H )
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"io.h\"\n")
|
||||
ENDIF ( HAVE_IO_H )
|
||||
IF ( HAVE_SYS_TIMEB_H )
|
||||
SET(CHECK_STDCALL_FUNCTION_PREMAIN "${CHECK_STDCALL_FUNCTION_PREMAIN}#include \"sys/timeb.h\"\n")
|
||||
ENDIF ( HAVE_SYS_TIMEB_H )
|
||||
|
||||
STRING(REGEX REPLACE "(\\(.*\\))" "" CHECK_STDCALL_FUNCTION_EXISTS_FUNCTION ${FUNCTION_DECLARATION} )
|
||||
|
||||
SET(MACRO_CHECK_STDCALL_FUNCTION_DEFINITIONS "${CMAKE_REQUIRED_FLAGS}")
|
||||
MESSAGE(STATUS "Looking for ${CHECK_STDCALL_FUNCTION_EXISTS_FUNCTION}")
|
||||
|
||||
IF(CMAKE_REQUIRED_LIBRARIES)
|
||||
SET(CHECK_STDCALL_FUNCTION_EXISTS_ADD_LIBRARIES
|
||||
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
|
||||
ELSE(CMAKE_REQUIRED_LIBRARIES)
|
||||
SET(CHECK_STDCALL_FUNCTION_EXISTS_ADD_LIBRARIES)
|
||||
ENDIF(CMAKE_REQUIRED_LIBRARIES)
|
||||
|
||||
IF(CMAKE_REQUIRED_INCLUDES)
|
||||
SET(CHECK_STDCALL_FUNCTION_EXISTS_ADD_INCLUDES
|
||||
"-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
|
||||
ELSE(CMAKE_REQUIRED_INCLUDES)
|
||||
SET(CHECK_STDCALL_FUNCTION_EXISTS_ADD_INCLUDES)
|
||||
ENDIF(CMAKE_REQUIRED_INCLUDES)
|
||||
|
||||
SET(CHECK_STDCALL_FUNCTION_DECLARATION ${FUNCTION_DECLARATION})
|
||||
CONFIGURE_FILE("${clucene-shared_SOURCE_DIR}/cmake/CheckStdCallFunctionExists.cpp.in"
|
||||
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckStdCallFunctionExists.cpp" IMMEDIATE @ONLY)
|
||||
FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckStdCallFunctionExists.cpp"
|
||||
CHECK_STDCALL_FUNCTION_CONTENT)
|
||||
|
||||
TRY_COMPILE(${VARIABLE}
|
||||
${CMAKE_BINARY_DIR}
|
||||
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckStdCallFunctionExists.cpp"
|
||||
COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
|
||||
CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_STDCALL_FUNCTION_DEFINITIONS}
|
||||
"${CHECK_STDCALL_FUNCTION_EXISTS_ADD_LIBRARIES}"
|
||||
"${CHECK_STDCALL_FUNCTION_EXISTS_ADD_INCLUDES}"
|
||||
OUTPUT_VARIABLE OUTPUT)
|
||||
IF(${VARIABLE})
|
||||
SET(${VARIABLE} 1 CACHE INTERNAL "Have function ${FUNCTION_DECLARATION}")
|
||||
MESSAGE(STATUS "Looking for ${FUNCTION_DECLARATION} - found")
|
||||
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
|
||||
"Determining if the stdcall function ${FUNCTION_DECLARATION} exists passed with the following output:\n"
|
||||
"${OUTPUT}\nCheckStdCallFunctionExists.cpp:\n${CHECK_STDCALL_FUNCTION_CONTENT}\n\n")
|
||||
ELSE(${VARIABLE})
|
||||
MESSAGE(STATUS "Looking for ${FUNCTION_DECLARATION} - not found")
|
||||
SET(${VARIABLE} "" CACHE INTERNAL "Have function ${FUNCTION_DECLARATION}")
|
||||
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
|
||||
"Determining if the stdcall function ${FUNCTION_DECLARATION} exists failed with the following output:\n"
|
||||
"${OUTPUT}\nCheckStdCallFunctionExists.cpp:\n${CHECK_STDCALL_FUNCTION_CONTENT}\n\n")
|
||||
ENDIF(${VARIABLE})
|
||||
ENDIF("${VARIABLE}" MATCHES "^${VARIABLE}$")
|
||||
ENDMACRO(CHECK_STDCALL_FUNCTION_EXISTS)
|
||||
22
samples/CMake/uninstall.cmake.in
Normal file
22
samples/CMake/uninstall.cmake.in
Normal file
@@ -0,0 +1,22 @@
|
||||
IF (NOT EXISTS "@PROJECT_BINARY_DIR@/install_manifest.txt")
|
||||
MESSAGE (FATAL_ERROR "Cannot find install manifest: \"@PROJECT_BINARY_DIR@/install_manifest.txt\"")
|
||||
ENDIF (NOT EXISTS "@PROJECT_BINARY_DIR@/install_manifest.txt")
|
||||
|
||||
FILE (READ "@PROJECT_BINARY_DIR@/install_manifest.txt" files)
|
||||
STRING (REGEX REPLACE "\n" ";" files "${files}")
|
||||
FOREACH (file ${files})
|
||||
MESSAGE (STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
|
||||
IF (EXISTS "$ENV{DESTDIR}${file}")
|
||||
EXEC_PROGRAM (
|
||||
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||
OUTPUT_VARIABLE rm_out
|
||||
RETURN_VALUE rm_retval
|
||||
)
|
||||
IF (NOT "${rm_retval}" STREQUAL 0)
|
||||
MESSAGE (FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
|
||||
ENDIF (NOT "${rm_retval}" STREQUAL 0)
|
||||
ELSE (EXISTS "$ENV{DESTDIR}${file}")
|
||||
MESSAGE (STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
|
||||
ENDIF (EXISTS "$ENV{DESTDIR}${file}")
|
||||
ENDFOREACH (file)
|
||||
|
||||
1879
samples/CartoCSS/amenity-points.mss
Normal file
1879
samples/CartoCSS/amenity-points.mss
Normal file
File diff suppressed because it is too large
Load Diff
172
samples/Clarion/CStringClass.clw
Normal file
172
samples/Clarion/CStringClass.clw
Normal file
@@ -0,0 +1,172 @@
|
||||
Member()
|
||||
omit('***$***',_VER_C55)
|
||||
_ABCDllMode_ EQUATE(0)
|
||||
_ABCLinkMode_ EQUATE(1)
|
||||
***$***
|
||||
Include('Equates.CLW'),ONCE
|
||||
Include('Keycodes.CLW'),ONCE
|
||||
Include('Errors.CLW'),ONCE
|
||||
Map
|
||||
End ! map
|
||||
Include('CStringClass.inc'),ONCE
|
||||
CStringClass.Construct PROCEDURE ! Declare Procedure
|
||||
CODE
|
||||
SELF.bufferSize = DEFAULT_CS_BUFFER_SIZE
|
||||
SELF.CS &= New(CSTRING(SELF.bufferSize))
|
||||
CStringClass.Destruct PROCEDURE ! Declare Procedure
|
||||
CODE
|
||||
Dispose(SELF.cs)
|
||||
CStringClass.Cat PROCEDURE (STRING pStr) !,*CSTRING,PROC ! Declare Procedure
|
||||
newLen LONG,AUTO
|
||||
oldCS &CSTRING
|
||||
CODE
|
||||
newLen = Len(pStr)
|
||||
IF (newLen+SELF.strLength+2) > SELF.newStrSize
|
||||
! Only grow the internal string if the result of the cat will be larger than the string currently is.
|
||||
! The reason for the "+2" is because this is used in the string slicing outside this IF. Without this matching +2 there is potential for an out of bounds slice which would be bad!
|
||||
|
||||
! Save a temporary copy of the old string so we can us it in the concatination after we have grown it!
|
||||
oldCS &= New(CSTRING(SELF.strLength+1))
|
||||
oldCS = SELF.CS
|
||||
Dispose(SELF.CS)
|
||||
|
||||
SELF.newStrSize = newLen + SELF.strLength + 1 + SELF.bufferSize
|
||||
SELF.CS &= New(CSTRING(SELF.newStrSize))
|
||||
SELF.CS = oldCS
|
||||
Dispose(oldCS)
|
||||
END
|
||||
|
||||
! Append the new string directly to the end of the old one.
|
||||
SELF.CS[SELF.strLength+1 : SELF.strLength+newLen] = pStr
|
||||
! And terminate the CSTRING manually
|
||||
SELF.CS[SELF.strLength+newLen+1] = '<0>'
|
||||
|
||||
! This is the same as doing "SELF.strLength = Len(SELF.CS)" but the Len() is _really_ slow on large strings. This is much faster!
|
||||
SELF.strLength += newLen
|
||||
|
||||
! This is what it used to be:
|
||||
! SELF.Str(SELF.Str() & s)
|
||||
! It is a nice and neat solution but performance, especially on large strings was terrible!
|
||||
|
||||
RETURN SELF.Str()
|
||||
CStringClass.Str PROCEDURE (STRING pStr) !,*CSTRING, PROC ! Declare Procedure
|
||||
CODE
|
||||
IF Len(pStr) > SELF.newStrSize
|
||||
! Only Dispose/New the internal string if the new one requires it.
|
||||
! This might be slightly innefficient in terms of memory usage when the string gets smaller
|
||||
! But it is _vasty_ better for performance when the string gets added to a lot.
|
||||
Dispose(SELF.CS)
|
||||
SELF.newStrSize = Len(pStr) + 1 + SELF.bufferSize
|
||||
SELF.CS &= New(CSTRING(SELF.newStrSize))
|
||||
END
|
||||
|
||||
SELF.CS = pStr
|
||||
SELF.strLength = Len(SELF.CS)
|
||||
|
||||
RETURN SELF.CS
|
||||
CStringClass.Len PROCEDURE !,LONG ! Declare Procedure
|
||||
CODE
|
||||
RETURN SELF.strLength
|
||||
CStringClass.Replace PROCEDURE (STRING pFind, STRING pReplace) !,*CSTRING,PROC ! Declare Procedure
|
||||
! FindString , ReplaceWith
|
||||
locate LONG,AUTO
|
||||
lastLocate LONG
|
||||
CODE
|
||||
LOOP
|
||||
locate = InString(Upper(pFind), Upper(SELF.Str()), 1, lastLocate+1)
|
||||
IF ~locate
|
||||
BREAK
|
||||
END
|
||||
|
||||
! So we dont end up having recursive replacement.
|
||||
lastLocate = locate + Len(pReplace)-1
|
||||
|
||||
SELF.Str(Sub(SELF.Str(), 1, locate-1) & |
|
||||
pReplace & |
|
||||
Sub(SELF.Str(), locate+Len(pFind), SELF.Len()) |
|
||||
)
|
||||
END
|
||||
|
||||
RETURN SELF.Str()
|
||||
CStringClass.Str PROCEDURE () !,*CSTRING ! Declare Procedure 3
|
||||
CODE
|
||||
RETURN SELF.CS
|
||||
!------------------------------------------------------------------------------
|
||||
CStringClass.Contains PROCEDURE (STRING pFind, BYTE pCaseSensitive=TRUE) !,BYTE ! Declare Procedure
|
||||
! Returns a value (TRUE) indicating whether the specified String occurs within this string.
|
||||
! Second parameter defaults to a case sensitive search.
|
||||
CODE
|
||||
IF pCaseSensitive = TRUE
|
||||
IF InString(pFind, SELF.Str(), 1 , 1) > 0
|
||||
RETURN TRUE
|
||||
END
|
||||
ELSE
|
||||
IF InString(Lower(pFind), SELF.Lower(), 1 , 1) > 0
|
||||
RETURN TRUE
|
||||
END
|
||||
END
|
||||
|
||||
RETURN FALSE
|
||||
CStringClass.Lower PROCEDURE () !,STRING ! Declare Procedure
|
||||
! Returns a "Lowered" version of the self.cs doesnt change the self.cs
|
||||
CODE
|
||||
RETURN Lower(SELF.CS)
|
||||
CStringClass.SubString PROCEDURE (LONG pPosition, LONG pLength) !,STRING,PROC ! Declare Procedure
|
||||
CODE
|
||||
RETURN Sub(SELF.Str(), pPosition, pLength)
|
||||
CStringClass.ToLower PROCEDURE () !,*CSTRING,PROC ! Declare Procedure
|
||||
! Converts this string to lowercase and returns the converted string
|
||||
|
||||
CODE
|
||||
RETURN SELF.Str(SELF.Lower())
|
||||
CStringClass.ToUpper PROCEDURE () !,*CSTRING,PROC ! Declare Procedure
|
||||
! Converts this string to uppercase and returns the converted string
|
||||
|
||||
CODE
|
||||
RETURN SELF.Str(SELF.Upper())
|
||||
CStringClass.Trim PROCEDURE () !,*CSTRING,PROC ! Declare Procedure
|
||||
CODE
|
||||
SELF.Str(Left(SELF.Str()))
|
||||
SELF.Str(Clip(SELF.Str()))
|
||||
RETURN SELF.Str()
|
||||
CStringClass.Upper PROCEDURE () !,STRING ! Declare Procedure
|
||||
CODE
|
||||
RETURN Upper(SELF.Str())
|
||||
CStringClass.IndexOf PROCEDURE (STRING pLookIn, BYTE pCaseSensitive=TRUE) !,LONG ! Declare Procedure
|
||||
! Returns the index of the first parameter (pLookIn) is found within the SELF.CS
|
||||
! zero if it is not found
|
||||
CODE
|
||||
IF pCaseSensitive = TRUE
|
||||
RETURN InString(SELF.Str(), pLookIn, 1 , 1)
|
||||
ELSE
|
||||
RETURN InString(SELF.Lower(), Lower(pLookIn), 1 , 1)
|
||||
END
|
||||
CStringClass.FoundIn PROCEDURE (STRING pLookIn, BYTE pCaseSensitive=TRUE) !,BYTE ! Declare Procedure
|
||||
! Returns TRUE if the first parameter (pLookIn) is found within the SELF.CS
|
||||
! FALSE if it is no
|
||||
CODE
|
||||
IF SELF.IndexOf(pLookIn, pCaseSensitive) > 0
|
||||
RETURN TRUE
|
||||
ELSE
|
||||
RETURN FALSE
|
||||
END
|
||||
CStringClass.SetBuffer PROCEDURE (LONG pNewBuffer) ! Declare Procedure
|
||||
CODE
|
||||
SELF.bufferSize = pNewBuffer
|
||||
CStringClass.EscapeXml PROCEDURE (<STRING pStr>) !,STRING ! Declare Procedure
|
||||
CS CStringClass
|
||||
CODE
|
||||
IF Omitted(pStr)=FALSE
|
||||
CS.Str(pStr)
|
||||
ELSE
|
||||
! Make a copy so we don't alter the original
|
||||
CS.Str(SELF.Str())
|
||||
END
|
||||
CS.Replace('&', '&')
|
||||
CS.Replace('<', '<')
|
||||
CS.Replace('>', '>')
|
||||
CS.Replace('"', '"')
|
||||
CS.Replace('''', ''')
|
||||
|
||||
RETURN CS.Str()
|
||||
|
||||
68
samples/Clarion/ConsoleSupport.clw
Normal file
68
samples/Clarion/ConsoleSupport.clw
Normal file
@@ -0,0 +1,68 @@
|
||||
Member()
|
||||
Include('ConsoleSupport.inc'),ONCE
|
||||
Map
|
||||
MODULE('32-bit Windows API')
|
||||
! General functions
|
||||
GetLastError(),DWORD,PASCAL
|
||||
|
||||
! Console functions
|
||||
GetStdHandle(DWORD),HANDLE,PASCAL,PROC,RAW
|
||||
WriteConsole(Handle,Long,Dword,long,long),bool,Raw,Pascal,name('WriteConsoleA')
|
||||
ReadConsole(Handle,Long,Dword,long,long),bool,Raw,Pascal,name('ReadConsoleA')
|
||||
SetConsoleTitle(Long),Bool,Raw,Pascal,name('SetConsoleTitleA')
|
||||
GetConsoleTitle(Long,dword),Bool,Raw,Pascal,name('GetConsoleTitleA')
|
||||
SetConsoleMode(Handle,dWord),BOOL,RAW,PASCAL
|
||||
GetConsoleMode(Handle,Long),BOOL,RAW,PASCAL
|
||||
End
|
||||
End
|
||||
|
||||
ConsoleSupport.Construct PROCEDURE
|
||||
|
||||
CODE
|
||||
|
||||
ConsoleSupport.Destruct PROCEDURE
|
||||
|
||||
CODE
|
||||
|
||||
ConsoleSupport.Init PROCEDURE () !,BYTE,VIRTUAL
|
||||
CODE
|
||||
|
||||
SELF.OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE)
|
||||
If SELF.OutputHandle = INVALID_HANDLE_VALUE
|
||||
Halt(1,'Unable to get output handle (' & GetLastError() & ')')
|
||||
RETURN INVALID_HANDLE_VALUE
|
||||
End
|
||||
|
||||
SELF.InputHandle = GetStdHandle(STD_INPUT_HANDLE)
|
||||
if SELF.InputHandle = INVALID_HANDLE_VALUE
|
||||
Halt(2,'Unable to get console input handle (' & GetLastError() & ')')
|
||||
RETURN INVALID_HANDLE_VALUE
|
||||
End
|
||||
|
||||
If ~SetConsoleMode(SELF.InputHandle,ENABLE_PROCESSED_INPUT )
|
||||
Halt(3,'Unable to set console mode (' & GetLastError() & ')')
|
||||
RETURN INVALID_OTHER
|
||||
End
|
||||
|
||||
RETURN FALSE
|
||||
|
||||
ConsoleSupport.WriteLine PROCEDURE (STRING pText) !,BYTE,PROC,VIRTUAL
|
||||
CODE
|
||||
SELF.TextBuffer = SELF.Prefix & pText & '<13,10>'
|
||||
If WriteConsole(SELF.OutputHandle, ADDRESS(SELF.TextBuffer), LEN(SELF.TextBuffer),ADDRESS(SELF.BytesWritten), NULL) = 0
|
||||
Halt(4,'WriteConsoleError (' & GetLastError() & ')')
|
||||
RETURN -1
|
||||
End
|
||||
RETURN FALSE
|
||||
|
||||
Consolesupport.ReadKey PROCEDURE () !,STRING,PROC,VIRTUAL
|
||||
CODE
|
||||
SELF.WriteLine('Press any key to continue...')
|
||||
Clear(SELF.InBuffer)
|
||||
Loop
|
||||
IF ReadConsole(SELF.InputHandle,Address(SELF.InBuffer),100,Address(SELF.BytesRead),NULL) = 0 THEN
|
||||
Halt(5,'Error on read console (' & GetLastError() & ')')
|
||||
Break
|
||||
End
|
||||
Until SELF.BytesRead > 0
|
||||
RETURN SELF.InBuffer
|
||||
10
samples/Clarion/HelloWorld.clw
Normal file
10
samples/Clarion/HelloWorld.clw
Normal file
@@ -0,0 +1,10 @@
|
||||
PROGRAM
|
||||
|
||||
MAP
|
||||
END
|
||||
|
||||
CODE
|
||||
|
||||
MESSAGE('Hello World!')
|
||||
|
||||
RETURN
|
||||
12
samples/Clarion/hello.clw
Normal file
12
samples/Clarion/hello.clw
Normal file
@@ -0,0 +1,12 @@
|
||||
MEMBER()
|
||||
INCLUDE('HelloClass.inc'),ONCE
|
||||
MAP
|
||||
END
|
||||
|
||||
HelloClass.Construct PROCEDURE
|
||||
CODE
|
||||
HelloClass.Destruct PROCEDURE() !,VIRTUAL
|
||||
CODE
|
||||
HelloClass.SayHello PROCEDURE
|
||||
CODE
|
||||
MESSAGE('Hello World!')
|
||||
11
samples/Clean/GenHylo.dcl
Normal file
11
samples/Clean/GenHylo.dcl
Normal 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
9
samples/Clean/GenMap.dcl
Normal 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
19
samples/Clean/GenMap.icl
Normal 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
54
samples/Clean/fsieve.icl
Normal 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
99
samples/Clean/sem.icl
Normal 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
14
samples/Clean/stack.dcl
Normal 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
33
samples/Clean/stack.icl
Normal 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
16
samples/Clean/streams.dcl
Normal 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
49
samples/Clean/streams.icl
Normal 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) _ _ = []
|
||||
|
||||
15
samples/Clojure/build.boot
Normal file
15
samples/Clojure/build.boot
Normal file
@@ -0,0 +1,15 @@
|
||||
;; from: https://github.com/boot-clj/boot#configure-task-options
|
||||
|
||||
(set-env!
|
||||
:source-paths #{"src"}
|
||||
:dependencies '[[me.raynes/conch "0.8.0"]])
|
||||
|
||||
(task-options!
|
||||
pom {:project 'my-project
|
||||
:version "0.1.0"}
|
||||
jar {:manifest {"Foo" "bar"}})
|
||||
|
||||
(deftask build
|
||||
"Build my project."
|
||||
[]
|
||||
(comp (pom) (jar) (install)))
|
||||
40
samples/CoffeeScript/example.cjsx
Normal file
40
samples/CoffeeScript/example.cjsx
Normal file
@@ -0,0 +1,40 @@
|
||||
###* @cjsx React.DOM ###
|
||||
define 'myProject.ReactExampleComponent', [
|
||||
'React'
|
||||
'myProject.ExampleStore'
|
||||
'myProject.ExampleActions'
|
||||
'myProject.ReactExampleTable'
|
||||
], (React, ExampleStore, ExampleActions, ReactExampleTable ) ->
|
||||
|
||||
ReactExampleComponent = React.createClass
|
||||
mixins: [ListenMixin]
|
||||
|
||||
getInitialState: ->
|
||||
rows: ExampleStore.getRows()
|
||||
meta: ExampleStore.getMeta()
|
||||
|
||||
componentWillMount: ->
|
||||
@listenTo ExampleStore
|
||||
|
||||
componentDidMount: ->
|
||||
ExampleActions.getExampleData()
|
||||
|
||||
onStoreChange: ->
|
||||
if this.isMounted()
|
||||
@setState
|
||||
rows: ExampleStore.getRows()
|
||||
meta: ExampleStore.getMeta()
|
||||
|
||||
componentWillUnmount: ->
|
||||
@stopListening ExampleStore
|
||||
|
||||
render: ->
|
||||
<div className="page-wrap">
|
||||
<header>
|
||||
<strong> {@state.title} </strong>
|
||||
<header>
|
||||
<ReactExampleTable
|
||||
rows={@state.rows},
|
||||
meta={@state.meta}
|
||||
/>
|
||||
</div>
|
||||
21
samples/Common Lisp/sample.lsp
Normal file
21
samples/Common Lisp/sample.lsp
Normal file
@@ -0,0 +1,21 @@
|
||||
;;;; -*- lisp -*-
|
||||
|
||||
(in-package :foo)
|
||||
|
||||
;;; Header comment.
|
||||
(defvar *foo*)
|
||||
|
||||
(eval-when (:execute :compile-toplevel :load-toplevel)
|
||||
(defun add (x &optional y &key z)
|
||||
(declare (ignore z))
|
||||
;; Inline comment.
|
||||
(+ x (or y 1))))
|
||||
|
||||
#|
|
||||
Multi-line comment.
|
||||
|#
|
||||
|
||||
(defmacro foo (x &body b)
|
||||
(if x
|
||||
`(1+ ,x) ;After-line comment.
|
||||
42))
|
||||
26
samples/Cool/list.cl
Normal file
26
samples/Cool/list.cl
Normal file
@@ -0,0 +1,26 @@
|
||||
(* This simple example of a list class is adapted from an example in the
|
||||
Cool distribution. *)
|
||||
|
||||
class List {
|
||||
isNil() : Bool { true };
|
||||
head() : Int { { abort(); 0; } };
|
||||
tail() : List { { abort(); self; } };
|
||||
cons(i : Int) : List {
|
||||
(new Cons).init(i, self)
|
||||
};
|
||||
};
|
||||
|
||||
class Cons inherits List {
|
||||
car : Int; -- The element in this list cell
|
||||
cdr : List; -- The rest of the list
|
||||
isNil() : Bool { false };
|
||||
head() : Int { car };
|
||||
tail() : List { cdr };
|
||||
init(i : Int, rest : List) : List {
|
||||
{
|
||||
car <- i;
|
||||
cdr <- rest;
|
||||
self;
|
||||
}
|
||||
};
|
||||
};
|
||||
71
samples/Cool/sample.cl
Normal file
71
samples/Cool/sample.cl
Normal file
@@ -0,0 +1,71 @@
|
||||
(* Refer to Alex Aiken, "The Cool Reference Manual":
|
||||
http://theory.stanford.edu/~aiken/software/cool/cool-manual.pdf
|
||||
for language specification.
|
||||
*)
|
||||
|
||||
-- Exhibit various language constructs
|
||||
class Sample {
|
||||
testCondition(x: Int): Bool {
|
||||
if x = 0
|
||||
then false
|
||||
else
|
||||
if x < (1 + 2) * 3
|
||||
then true
|
||||
else false
|
||||
fi
|
||||
fi
|
||||
};
|
||||
|
||||
testLoop(y: Int): Bool {
|
||||
while y > 0 loop
|
||||
{
|
||||
if not condition(y)
|
||||
then y <- y / 2
|
||||
else y <- y - 1;
|
||||
}
|
||||
pool
|
||||
};
|
||||
|
||||
testAssign(z: Int): Bool {
|
||||
i : Int;
|
||||
i <- ~z;
|
||||
};
|
||||
|
||||
testCase(var: Sample): SELF_TYPE {
|
||||
io : IO <- new IO;
|
||||
case var of
|
||||
a : A => io.out_string("Class type is A\n");
|
||||
b : B => io.out_string("Class type is B\n");
|
||||
s : Sample => io.out_string("Class type is Sample\n");
|
||||
o : Object => io.out_string("Class type is object\n");
|
||||
esac
|
||||
};
|
||||
|
||||
testLet(i: Int): Int {
|
||||
let (a: Int in
|
||||
let(b: Int <- 3, c: Int <- 4 in
|
||||
{
|
||||
a <- 2;
|
||||
a * b * 2 / c;
|
||||
}
|
||||
)
|
||||
)
|
||||
};
|
||||
};
|
||||
|
||||
-- Used to test subclasses
|
||||
class A inherits Sample {};
|
||||
class B inherits A {};
|
||||
|
||||
class C {
|
||||
main() : Int {
|
||||
(new Sample).testLet(1)
|
||||
};
|
||||
};
|
||||
|
||||
-- "Hello, world" example
|
||||
class Main inherits IO {
|
||||
main(): SELF_TYPE {
|
||||
out_string("Hello, World.\n")
|
||||
};
|
||||
};
|
||||
318
samples/D/mpq.d
Normal file
318
samples/D/mpq.d
Normal file
@@ -0,0 +1,318 @@
|
||||
/*
|
||||
* mpq.d -- D programming language module for libmpq
|
||||
*
|
||||
* Copyright (c) 2008 Georg Lukas <georg@op-co.de>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* This module is written to support Phobos. Patches to allow binding to
|
||||
* Tango are welcome.
|
||||
*/
|
||||
|
||||
module mpq;
|
||||
|
||||
/* the following pragma does not work on DMD/Linux, generates a warning on
|
||||
* GDC/Linux and has not been tested on Windows. Commented out for now. */
|
||||
// pragma(lib, "libmpq");
|
||||
|
||||
import std.string; // for format() and toStringz()
|
||||
import std.traits; // for ParameterTypeTuple!()
|
||||
|
||||
/* XXX: this assumes that libmpq is compiled with Large File Support on */
|
||||
alias long off_t;
|
||||
|
||||
/* libmpq error return values */
|
||||
const LIBMPQ_ERROR_OPEN = -1; /* open error on file. */
|
||||
const LIBMPQ_ERROR_CLOSE = -2; /* close error on file. */
|
||||
const LIBMPQ_ERROR_SEEK = -3; /* lseek error on file. */
|
||||
const LIBMPQ_ERROR_READ = -4; /* read error on file. */
|
||||
const LIBMPQ_ERROR_WRITE = -5; /* write error on file. */
|
||||
const LIBMPQ_ERROR_MALLOC = -6; /* memory allocation error. */
|
||||
const LIBMPQ_ERROR_FORMAT = -7; /* format errror. */
|
||||
const LIBMPQ_ERROR_NOT_INITIALIZED = -8; /* init() wasn't called. */
|
||||
const LIBMPQ_ERROR_SIZE = -9; /* buffer size is to small. */
|
||||
const LIBMPQ_ERROR_EXIST = -10; /* file or block does not exist in archive. */
|
||||
const LIBMPQ_ERROR_DECRYPT = -11; /* we don't know the decryption seed. */
|
||||
const LIBMPQ_ERROR_UNPACK = -12; /* error on unpacking file. */
|
||||
|
||||
/** libmpq internal meta-data for an archive */
|
||||
extern struct mpq_archive_s;
|
||||
|
||||
extern(C) {
|
||||
|
||||
/* libmpq__generic information about library. */
|
||||
char *libmpq__version();
|
||||
|
||||
/* libmpq__generic mpq archive information. */
|
||||
int libmpq__archive_open(mpq_archive_s **mpq_archive, char *mpq_filename, off_t archive_offset);
|
||||
int libmpq__archive_close(mpq_archive_s *mpq_archive);
|
||||
int libmpq__archive_packed_size(mpq_archive_s *mpq_archive, off_t *packed_size);
|
||||
int libmpq__archive_unpacked_size(mpq_archive_s *mpq_archive, off_t *unpacked_size);
|
||||
int libmpq__archive_offset(mpq_archive_s *mpq_archive, off_t *offset);
|
||||
int libmpq__archive_version(mpq_archive_s *mpq_archive, uint *version_);
|
||||
int libmpq__archive_files(mpq_archive_s *mpq_archive, uint *files);
|
||||
|
||||
/* libmpq__generic file processing functions. */
|
||||
int libmpq__file_packed_size(mpq_archive_s *mpq_archive, uint file_number, off_t *packed_size);
|
||||
int libmpq__file_unpacked_size(mpq_archive_s *mpq_archive, uint file_number, off_t *unpacked_size);
|
||||
int libmpq__file_offset(mpq_archive_s *mpq_archive, uint file_number, off_t *offset);
|
||||
int libmpq__file_blocks(mpq_archive_s *mpq_archive, uint file_number, uint *blocks);
|
||||
int libmpq__file_encrypted(mpq_archive_s *mpq_archive, uint file_number, uint *encrypted);
|
||||
int libmpq__file_compressed(mpq_archive_s *mpq_archive, uint file_number, uint *compressed);
|
||||
int libmpq__file_imploded(mpq_archive_s *mpq_archive, uint file_number, uint *imploded);
|
||||
int libmpq__file_number(mpq_archive_s *mpq_archive, char *filename, uint *number);
|
||||
int libmpq__file_read(mpq_archive_s *mpq_archive, uint file_number, ubyte *out_buf, off_t out_size, off_t *transferred);
|
||||
|
||||
/* libmpq__generic block processing functions. */
|
||||
int libmpq__block_open_offset(mpq_archive_s *mpq_archive, uint file_number);
|
||||
int libmpq__block_close_offset(mpq_archive_s *mpq_archive, uint file_number);
|
||||
int libmpq__block_unpacked_size(mpq_archive_s *mpq_archive, uint file_number, uint block_number, off_t *unpacked_size);
|
||||
int libmpq__block_read(mpq_archive_s *mpq_archive, uint file_number, uint block_number, ubyte *out_buf, off_t out_size, off_t *transferred);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/** exception class for failed libmpq calls */
|
||||
class MPQException : Exception {
|
||||
const string[] Errors = [
|
||||
"unknown error",
|
||||
"open error on file",
|
||||
"close error on file",
|
||||
"lseek error on file",
|
||||
"read error on file",
|
||||
"write error on file",
|
||||
"memory allocation error",
|
||||
"format errror",
|
||||
"init() wasn't called",
|
||||
"buffer size is to small",
|
||||
"file or block does not exist in archive",
|
||||
"we don't know the decryption seed",
|
||||
"error on unpacking file"];
|
||||
|
||||
public int errno;
|
||||
this(char[] fnname = "unknown_function", int errno = 0) {
|
||||
|
||||
this.errno = errno;
|
||||
if (-errno >= Errors.length)
|
||||
errno = 0;
|
||||
super(std.string.format("Error in %s(): %s (%d)",
|
||||
fnname, Errors[-errno], errno));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** template to wrap function calls and throw exceptions in case of error
|
||||
*
|
||||
* thanks for the idea to while(nan) blog,
|
||||
* http://while-nan.blogspot.com/2007/06/wrapping-functions-for-fun-and-profit.html
|
||||
*
|
||||
* use: MPQ_CHECKERR(libmpq__archive_open)(&m, "foo.mpq", -1);
|
||||
* returns the retval of archive_open on success;
|
||||
* throws an MPQException on failure.
|
||||
*
|
||||
* @param Fn libmpq__function reference
|
||||
* @param args libmpq__function parameters
|
||||
* @return return value of libmpq__function on success
|
||||
* @throw MPQException on error
|
||||
*/
|
||||
int MPQ_CHECKERR(alias Fn)(ParameterTypeTuple!(Fn) args)
|
||||
{
|
||||
int result = Fn(args);
|
||||
if (result < 0) {
|
||||
/* XXX: relying on non-specified stringof() behaviour */
|
||||
throw new MPQException((&Fn).stringof[2..$], result);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/** mixin alias to wrap library functions into MPQ_CHECKERR.
|
||||
*
|
||||
* alias mpq.func_name(...) to MPQ_CHECKERR(libmpq__func_name)(...)
|
||||
* @param func_name name of the function to be wrapped
|
||||
*/
|
||||
template MPQ_FUNC(char[] func_name) {
|
||||
const char[] MPQ_FUNC = "alias MPQ_CHECKERR!(libmpq__" ~ func_name ~ ") " ~ func_name ~ ";";
|
||||
}
|
||||
|
||||
alias libmpq__version libversion; /* must be direct alias because it returns char*, not error int */
|
||||
mixin(MPQ_FUNC!("archive_open"));
|
||||
mixin(MPQ_FUNC!("archive_close"));
|
||||
mixin(MPQ_FUNC!("archive_packed_size"));
|
||||
mixin(MPQ_FUNC!("archive_unpacked_size"));
|
||||
mixin(MPQ_FUNC!("archive_offset"));
|
||||
mixin(MPQ_FUNC!("archive_version"));
|
||||
mixin(MPQ_FUNC!("archive_files"));
|
||||
mixin(MPQ_FUNC!("file_packed_size"));
|
||||
mixin(MPQ_FUNC!("file_unpacked_size"));
|
||||
mixin(MPQ_FUNC!("file_offset"));
|
||||
mixin(MPQ_FUNC!("file_blocks"));
|
||||
mixin(MPQ_FUNC!("file_encrypted"));
|
||||
mixin(MPQ_FUNC!("file_compressed"));
|
||||
mixin(MPQ_FUNC!("file_imploded"));
|
||||
mixin(MPQ_FUNC!("file_number"));
|
||||
mixin(MPQ_FUNC!("file_read"));
|
||||
mixin(MPQ_FUNC!("block_open_offset"));
|
||||
mixin(MPQ_FUNC!("block_close_offset"));
|
||||
mixin(MPQ_FUNC!("block_unpacked_size"));
|
||||
mixin(MPQ_FUNC!("block_read"));
|
||||
|
||||
/** getter function named name for returning archive_* single values:
|
||||
*
|
||||
* <type> Archive.<name>() { return libmpq__archive_<name>() }
|
||||
*
|
||||
* @param type return type for the original function reference
|
||||
* @param name name of the original function
|
||||
* @param name2 name for the prototype (defaults to name, used for "version")
|
||||
* @return getter function mixin
|
||||
*/
|
||||
template MPQ_A_GET(char[] type, char[] name, char[] name2 = name) {
|
||||
const char[] MPQ_A_GET = type ~ " " ~ name2 ~ "() { " ~
|
||||
type ~ " ret; " ~
|
||||
"archive_" ~ name ~ "(m, &ret); return ret;" ~
|
||||
"}";
|
||||
}
|
||||
|
||||
/** wrapper class for an MPQ Archive
|
||||
*
|
||||
* syntax: auto a = new mpq.Archive("somefile.mpq");
|
||||
*/
|
||||
class Archive {
|
||||
mpq_archive_s *m;
|
||||
File listfile;
|
||||
char[][] listfiledata;
|
||||
|
||||
this(char[] archivename, off_t offset = -1) {
|
||||
archive_open(&m, toStringz(archivename), offset);
|
||||
}
|
||||
|
||||
mixin(MPQ_A_GET!("off_t", "packed_size"));
|
||||
mixin(MPQ_A_GET!("off_t", "unpacked_size"));
|
||||
mixin(MPQ_A_GET!("off_t", "offset"));
|
||||
mixin(MPQ_A_GET!("uint", "version", "version_"));
|
||||
mixin(MPQ_A_GET!("uint", "files"));
|
||||
|
||||
~this() {
|
||||
archive_close(m);
|
||||
}
|
||||
|
||||
mpq_archive_s* archive() {
|
||||
return m;
|
||||
}
|
||||
|
||||
File opIndex(char[] fname) {
|
||||
return new File(this, fname);
|
||||
}
|
||||
File opIndex(int fno) {
|
||||
return new File(this, fno);
|
||||
}
|
||||
|
||||
char[][] filelist() {
|
||||
try {
|
||||
if (!listfile) {
|
||||
listfile = this["(listfile)"];
|
||||
listfiledata = (cast(char[])listfile.read()).splitlines();
|
||||
}
|
||||
return listfiledata;
|
||||
} catch (MPQException e) {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/+uint filenumber(char[] filename) {
|
||||
try {
|
||||
if (!listfile) {
|
||||
listfile = this["(listfile)"];
|
||||
listfiledata = (cast(char[])listfile.read()).splitlines();
|
||||
}
|
||||
return listfiledata;
|
||||
} catch (MPQException e) {
|
||||
return [];
|
||||
}
|
||||
}+/
|
||||
|
||||
}
|
||||
|
||||
|
||||
/** getter function named name for returning file_* single values:
|
||||
*
|
||||
* <type> File.<name>() { return libmpq__file_<name>() }
|
||||
*
|
||||
* @param type return type for the original function reference
|
||||
* @param name name of the original function
|
||||
* @param name2 name for the prototype (defaults to name, used for "version")
|
||||
* @return getter function mixin
|
||||
*/
|
||||
template MPQ_F_GET(char[] type, char[] name, char[] name2 = name) {
|
||||
const char[] MPQ_F_GET = type ~ " " ~ name2 ~ "() { " ~
|
||||
type ~ " ret; " ~
|
||||
"file_" ~ name ~ "(am, fileno, &ret); " ~
|
||||
"return ret;" ~
|
||||
"}";
|
||||
}
|
||||
|
||||
/** wrapper class for a single file in an MPQ Archive
|
||||
*
|
||||
* syntax:
|
||||
* auto a = new mpq.Archive("somefile.mpq");
|
||||
* auto f = a["(listfile)"];
|
||||
* auto f2 = a[0];
|
||||
* auto f3 = new File(a, "(listfile)");
|
||||
*/
|
||||
class File {
|
||||
Archive a;
|
||||
mpq_archive_s* am;
|
||||
char[] filename;
|
||||
uint fileno;
|
||||
|
||||
this(Archive a, int fileno) {
|
||||
this.a = a;
|
||||
this.am = a.archive();
|
||||
if (fileno >= a.files) {
|
||||
throw new MPQException(format("File(%d)", fileno),
|
||||
LIBMPQ_ERROR_EXIST);
|
||||
}
|
||||
this.filename = format("file%04d.xxx", fileno);
|
||||
this.fileno = fileno;
|
||||
}
|
||||
|
||||
this(Archive a, char[] filename) {
|
||||
this.a = a;
|
||||
this.am = a.archive();
|
||||
this.filename = filename;
|
||||
/* this line will throw an exception when the file is not there */
|
||||
mpq.file_number(am, toStringz(filename), &this.fileno);
|
||||
}
|
||||
|
||||
mixin(MPQ_F_GET!("off_t", "packed_size"));
|
||||
mixin(MPQ_F_GET!("off_t", "unpacked_size"));
|
||||
mixin(MPQ_F_GET!("off_t", "offset"));
|
||||
mixin(MPQ_F_GET!("uint", "blocks"));
|
||||
mixin(MPQ_F_GET!("uint", "encrypted"));
|
||||
mixin(MPQ_F_GET!("uint", "compressed"));
|
||||
mixin(MPQ_F_GET!("uint", "imploded"));
|
||||
|
||||
uint no() { return fileno; }
|
||||
char[] name() { return filename; }
|
||||
|
||||
ubyte[] read() {
|
||||
ubyte[] content;
|
||||
content.length = this.unpacked_size();
|
||||
off_t trans;
|
||||
mpq.file_read(am, fileno, content.ptr, content.length, &trans);
|
||||
content.length = trans;
|
||||
return content;
|
||||
}
|
||||
}
|
||||
23
samples/DTrace/counts.d
Normal file
23
samples/DTrace/counts.d
Normal file
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* This software is in the public domain.
|
||||
*
|
||||
* $Id: counts.d 10510 2005-08-15 01:46:19Z kateturner $
|
||||
*/
|
||||
|
||||
#pragma D option quiet
|
||||
|
||||
self int tottime;
|
||||
BEGIN {
|
||||
tottime = timestamp;
|
||||
}
|
||||
|
||||
php$target:::function-entry
|
||||
@counts[copyinstr(arg0)] = count();
|
||||
}
|
||||
|
||||
END {
|
||||
printf("Total time: %dus\n", (timestamp - tottime) / 1000);
|
||||
printf("# calls by function:\n");
|
||||
printa("%-40s %@d\n", @counts);
|
||||
}
|
||||
|
||||
73
samples/DTrace/javascript-trace.d
Normal file
73
samples/DTrace/javascript-trace.d
Normal file
@@ -0,0 +1,73 @@
|
||||
/* -*- Mode: dtrace-script; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* ***** BEGIN LICENSE BLOCK *****
|
||||
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||||
*
|
||||
* The contents of this file are subject to the Mozilla Public License Version
|
||||
* 1.1 (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.mozilla.org/MPL/
|
||||
*
|
||||
* Software distributed under the License is distributed on an "AS IS" basis,
|
||||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
||||
* for the specific language governing rights and limitations under the
|
||||
* License.
|
||||
*
|
||||
* Copyright (C) 2007 Sun Microsystems, Inc. All Rights Reserved.
|
||||
*
|
||||
* Alternatively, the contents of this file may be used under the terms of
|
||||
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
||||
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||||
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||||
* of those above. If you wish to allow use of your version of this file only
|
||||
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||||
* use your version of this file under the terms of the MPL, indicate your
|
||||
* decision by deleting the provisions above and replace them with the notice
|
||||
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||||
* the provisions above, a recipient may use your version of this file under
|
||||
* the terms of any one of the MPL, the GPL or the LGPL.
|
||||
*
|
||||
* ***** END LICENSE BLOCK ***** */
|
||||
|
||||
/*
|
||||
* javascript provider probes
|
||||
*
|
||||
* function-entry (filename, classname, funcname)
|
||||
* function-info (filename, classname, funcname, lineno,
|
||||
* runfilename, runlineno)
|
||||
* function-args (filename, classname, funcname, argc, argv, argv0,
|
||||
* argv1, argv2, argv3, argv4)
|
||||
* function-rval (filename, classname, funcname, lineno, rval, rval0)
|
||||
* function-return (filename, classname, funcname)
|
||||
* object-create-start (filename, classname)
|
||||
* object-create (filename, classname, *object, rlineno)
|
||||
* object-create-done (filename, classname)
|
||||
* object-finalize (NULL, classname, *object)
|
||||
* execute-start (filename, lineno)
|
||||
* execute-done (filename, lineno)
|
||||
*/
|
||||
|
||||
provider javascript {
|
||||
probe function__entry(char *, char *, char *);
|
||||
probe function__info(char *, char *, char *, int, char *, int);
|
||||
probe function__args(char *, char *, char *, int, void *, void *, void *,
|
||||
void *, void *, void *);
|
||||
probe function__rval(char *, char *, char *, int, void *, void *);
|
||||
probe function__return(char *, char *, char *);
|
||||
probe object__create__start(char *, char *);
|
||||
probe object__create__done(char *, char *);
|
||||
/* XXX must use unsigned longs here instead of uintptr_t for OS X
|
||||
(Apple radar: 5194316 & 5565198) */
|
||||
probe object__create(char *, char *, unsigned long, int);
|
||||
probe object__finalize(char *, char *, unsigned long);
|
||||
probe execute__start(char *, int);
|
||||
probe execute__done(char *, int);
|
||||
};
|
||||
|
||||
/*
|
||||
#pragma D attributes Unstable/Unstable/Common provider mozilla provider
|
||||
#pragma D attributes Private/Private/Unknown provider mozilla module
|
||||
#pragma D attributes Private/Private/Unknown provider mozilla function
|
||||
#pragma D attributes Unstable/Unstable/Common provider mozilla name
|
||||
#pragma D attributes Unstable/Unstable/Common provider mozilla args
|
||||
*/
|
||||
|
||||
93
samples/DTrace/probes.d
Normal file
93
samples/DTrace/probes.d
Normal file
@@ -0,0 +1,93 @@
|
||||
/* ----------
|
||||
* DTrace probes for PostgreSQL backend
|
||||
*
|
||||
* Copyright (c) 2006-2009, PostgreSQL Global Development Group
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/utils/probes.d,v 1.11 2009/04/02 20:59:10 momjian Exp $
|
||||
* ----------
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Typedefs used in PostgreSQL.
|
||||
*
|
||||
* NOTE: Do not use system-provided typedefs (e.g. uintptr_t, uint32_t, etc)
|
||||
* in probe definitions, as they cause compilation errors on Mac OS X 10.5.
|
||||
*/
|
||||
#define LocalTransactionId unsigned int
|
||||
#define LWLockId int
|
||||
#define LWLockMode int
|
||||
#define LOCKMODE int
|
||||
#define BlockNumber unsigned int
|
||||
#define Oid unsigned int
|
||||
#define ForkNumber int
|
||||
#define bool char
|
||||
|
||||
provider postgresql {
|
||||
|
||||
probe transaction__start(LocalTransactionId);
|
||||
probe transaction__commit(LocalTransactionId);
|
||||
probe transaction__abort(LocalTransactionId);
|
||||
|
||||
probe lwlock__acquire(LWLockId, LWLockMode);
|
||||
probe lwlock__release(LWLockId);
|
||||
probe lwlock__wait__start(LWLockId, LWLockMode);
|
||||
probe lwlock__wait__done(LWLockId, LWLockMode);
|
||||
probe lwlock__condacquire(LWLockId, LWLockMode);
|
||||
probe lwlock__condacquire__fail(LWLockId, LWLockMode);
|
||||
|
||||
probe lock__wait__start(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, LOCKMODE);
|
||||
probe lock__wait__done(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, LOCKMODE);
|
||||
|
||||
probe query__parse__start(const char *);
|
||||
probe query__parse__done(const char *);
|
||||
probe query__rewrite__start(const char *);
|
||||
probe query__rewrite__done(const char *);
|
||||
probe query__plan__start();
|
||||
probe query__plan__done();
|
||||
probe query__execute__start();
|
||||
probe query__execute__done();
|
||||
probe query__start(const char *);
|
||||
probe query__done(const char *);
|
||||
probe statement__status(const char *);
|
||||
|
||||
probe sort__start(int, bool, int, int, bool);
|
||||
probe sort__done(bool, long);
|
||||
|
||||
probe buffer__read__start(ForkNumber, BlockNumber, Oid, Oid, Oid, bool, bool);
|
||||
probe buffer__read__done(ForkNumber, BlockNumber, Oid, Oid, Oid, bool, bool, bool);
|
||||
probe buffer__flush__start(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
probe buffer__flush__done(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
|
||||
probe buffer__checkpoint__start(int);
|
||||
probe buffer__checkpoint__sync__start();
|
||||
probe buffer__checkpoint__done();
|
||||
probe buffer__sync__start(int, int);
|
||||
probe buffer__sync__written(int);
|
||||
probe buffer__sync__done(int, int, int);
|
||||
probe buffer__write__dirty__start(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
probe buffer__write__dirty__done(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
|
||||
probe deadlock__found();
|
||||
|
||||
probe checkpoint__start(int);
|
||||
probe checkpoint__done(int, int, int, int, int);
|
||||
probe clog__checkpoint__start(bool);
|
||||
probe clog__checkpoint__done(bool);
|
||||
probe subtrans__checkpoint__start(bool);
|
||||
probe subtrans__checkpoint__done(bool);
|
||||
probe multixact__checkpoint__start(bool);
|
||||
probe multixact__checkpoint__done(bool);
|
||||
probe twophase__checkpoint__start();
|
||||
probe twophase__checkpoint__done();
|
||||
|
||||
probe smgr__md__read__start(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
probe smgr__md__read__done(ForkNumber, BlockNumber, Oid, Oid, Oid, int, int);
|
||||
probe smgr__md__write__start(ForkNumber, BlockNumber, Oid, Oid, Oid);
|
||||
probe smgr__md__write__done(ForkNumber, BlockNumber, Oid, Oid, Oid, int, int);
|
||||
|
||||
probe xlog__insert(unsigned char, unsigned char);
|
||||
probe xlog__switch();
|
||||
probe wal__buffer__write__dirty__start();
|
||||
probe wal__buffer__write__dirty__done();
|
||||
};
|
||||
44
samples/Eiffel/application.e
Normal file
44
samples/Eiffel/application.e
Normal file
@@ -0,0 +1,44 @@
|
||||
note
|
||||
description : "nino application root class"
|
||||
date : "$Date$"
|
||||
revision : "$Revision$"
|
||||
|
||||
class
|
||||
APPLICATION
|
||||
|
||||
inherit
|
||||
ARGUMENTS
|
||||
|
||||
HTTP_SERVER_SHARED_CONFIGURATION
|
||||
|
||||
create
|
||||
make
|
||||
|
||||
feature {NONE} -- Initialization
|
||||
|
||||
make
|
||||
-- Run application.
|
||||
local
|
||||
l_server : HTTP_SERVER
|
||||
l_cfg: HTTP_SERVER_CONFIGURATION
|
||||
l_http_handler : HTTP_HANDLER
|
||||
do
|
||||
create l_cfg.make
|
||||
l_cfg.http_server_port := 9_000
|
||||
l_cfg.document_root := default_document_root
|
||||
set_server_configuration (l_cfg)
|
||||
debug ("nino")
|
||||
l_cfg.set_is_verbose (True)
|
||||
end
|
||||
|
||||
create l_server.make (l_cfg)
|
||||
create {APPLICATION_CONNECTION_HANDLER} l_http_handler.make (l_server)
|
||||
l_server.setup (l_http_handler)
|
||||
end
|
||||
|
||||
feature -- Access
|
||||
|
||||
default_document_root: STRING = "webroot"
|
||||
|
||||
end
|
||||
|
||||
82
samples/Eiffel/book_collection.e
Normal file
82
samples/Eiffel/book_collection.e
Normal file
@@ -0,0 +1,82 @@
|
||||
class
|
||||
BOOK_COLLECTION
|
||||
|
||||
create
|
||||
make
|
||||
|
||||
feature {NONE} -- Initialization
|
||||
|
||||
make (a_name: STRING_32)
|
||||
-- Create a book collection with `a_name' as `name'.
|
||||
do
|
||||
set_name (a_name)
|
||||
create book_index.make (10)
|
||||
ensure
|
||||
name_set: name = a_name
|
||||
end
|
||||
|
||||
feature -- Access
|
||||
|
||||
name: STRING_32
|
||||
-- Name.
|
||||
|
||||
books: LIST [BOOK]
|
||||
-- collection of book.
|
||||
do
|
||||
create {LINKED_LIST [BOOK]} Result.make
|
||||
across
|
||||
book_index as it
|
||||
loop
|
||||
Result.append (it.item)
|
||||
end
|
||||
end
|
||||
|
||||
books_by_author (a_author: STRING_32): LIST [BOOK]
|
||||
-- Books wrote by `a_author' in this collection.
|
||||
do
|
||||
if attached book_index [a_author] as l_result then
|
||||
Result := l_result
|
||||
else
|
||||
create {LINKED_LIST [BOOK]} Result.make
|
||||
end
|
||||
end
|
||||
|
||||
feature -- Change
|
||||
|
||||
set_name (a_name: STRING_32)
|
||||
-- Set `name' with `a_name'.
|
||||
do
|
||||
name := a_name
|
||||
ensure
|
||||
name_set: name = a_name
|
||||
end
|
||||
|
||||
add_book (a_book: BOOK)
|
||||
-- Extend collection with `a_book'.
|
||||
local
|
||||
l: detachable LIST [BOOK]
|
||||
do
|
||||
l := book_index.at (a_book.author.name)
|
||||
if l = Void then
|
||||
create {LINKED_LIST [BOOK]} l.make
|
||||
book_index.put (l, a_book.author.name)
|
||||
end
|
||||
l.force (a_book)
|
||||
end
|
||||
|
||||
add_books (book_list: like books)
|
||||
-- Append collection with `book_list'.
|
||||
do
|
||||
across
|
||||
book_list as it
|
||||
loop
|
||||
add_book (it.item)
|
||||
end
|
||||
end
|
||||
|
||||
feature {NONE} -- Implementation
|
||||
|
||||
book_index: HASH_TABLE [LIST [BOOK], STRING_32]
|
||||
-- Association of author name and its books.
|
||||
|
||||
end -- class BOOK_COLLECTION
|
||||
41
samples/Eiffel/git_checkout_command.e
Normal file
41
samples/Eiffel/git_checkout_command.e
Normal file
@@ -0,0 +1,41 @@
|
||||
note
|
||||
description: "Git checkout command."
|
||||
author: "Olivier Ligot"
|
||||
|
||||
class
|
||||
GIT_CHECKOUT_COMMAND
|
||||
|
||||
inherit
|
||||
GIT_COMMAND
|
||||
|
||||
create
|
||||
make,
|
||||
make_master
|
||||
|
||||
feature {NONE} -- Initialization
|
||||
|
||||
make (a_branch: STRING)
|
||||
-- Checkout the branch `a_branch'.
|
||||
do
|
||||
initialize
|
||||
arguments.force_last (a_branch)
|
||||
branch := a_branch
|
||||
ensure
|
||||
branch_set: branch = a_branch
|
||||
end
|
||||
|
||||
make_master
|
||||
-- Checkout the master branch.
|
||||
do
|
||||
make ("master")
|
||||
end
|
||||
|
||||
feature -- Access
|
||||
|
||||
branch: STRING
|
||||
-- Branch to checkout
|
||||
|
||||
name: STRING = "checkout"
|
||||
-- Git subcommand name
|
||||
|
||||
end
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user