├── sample ├── sample683.nev.err ├── sample687.nev.err ├── sample659.nev.err ├── sample660.nev.err ├── sample666.nev.err ├── sample668.nev.err ├── sample670.nev.err ├── sample679.nev.err ├── sample680.nev.err ├── sample681.nev.err ├── sample684.nev.err ├── sample690.nev.err ├── sample692.nev.err ├── sample504.nev ├── sample505.nev ├── sample665.nev.err ├── sample677.nev.err ├── sample42.nev ├── sample206.nev ├── sample207.nev ├── sample31.nev ├── sample41.nev ├── sample_man1.nev ├── sample29.nev ├── sample214.nev ├── sample640.nev.err ├── sample672.nev.err ├── sample676.nev ├── sample663.nev.err ├── sample_hello.nev ├── sample368.nev ├── sample51.nev ├── sample484.nev ├── sample671.nev.err ├── sample184.nev ├── sample488.nev ├── sample480.nev ├── sample671.nev ├── sample209.nev ├── sample653.nev.err ├── sample658.nev.err ├── sample203.nev ├── sample205.nev ├── sample219.nev ├── sample655.nev.err ├── sample673.nev.err ├── sample676.nev.err ├── sample679.nev ├── sample686.nev.err ├── sample202.nev ├── sample204.nev ├── sample208.nev ├── sample210.nev ├── sample211.nev ├── sample212.nev ├── sample267.nev ├── sample485.nev ├── sample486.nev ├── sample674.nev.err ├── sample680.nev ├── sample681.nev ├── sample688.nev.err ├── lib │ ├── mthree.nev │ ├── mseven.nev │ ├── mone.nev │ ├── mfive.nev │ ├── EM.nev │ ├── msix.nev │ ├── mtail.nev │ ├── mtwo.nev │ └── EN.nev ├── sample221.nev ├── sample468.nev ├── sample672.nev ├── sample675.nev.err ├── sample220.nev ├── sample669.nev ├── sample670.nev ├── sample529.nev ├── sample218.nev ├── sample472.nev ├── sample227.nev ├── sample678.nev ├── sample683.nev ├── sample243.nev ├── sample272.nev ├── sample684.nev ├── sample_man2.nev ├── sample244.nev ├── sample638.nev ├── sample647.nev ├── sample507.nev ├── sample677.nev ├── sample_gcd.nev ├── sample193.nev ├── sample217.nev ├── sample262.nev ├── sample264.nev ├── sample265.nev ├── sample487.nev ├── sample627.nev ├── sample80.nev ├── sample80.nevs ├── sample263.nev ├── sample266.nev ├── sample9.nev ├── sample_or.nev ├── sample224.nev ├── sample438.nev ├── sample52.nev ├── sample524.nev ├── sample682.nev ├── sample163.nev ├── sample216.nev ├── sample362.nev ├── sample667.nev ├── sample668.nev ├── sample685.nev ├── sample180.nev ├── sample639.nev ├── sample640.nev ├── sample650.nev ├── sample651.nev ├── sample93.nev ├── sample97.nev ├── sample114.nev ├── sample437.nev ├── sample614.nev ├── sample81.nevs ├── sample_fib_tail.nev ├── sample_man7.nev ├── sample19.nev ├── sample191.nev ├── sample4.nev ├── sample467.nev ├── sample649.nev ├── sample652.nev ├── sample653.nev ├── sample179.nev ├── sample190.nev ├── sample611.nev ├── sample621.nev ├── sample655.nev ├── sample659.nev ├── sample654.nev ├── sample656.nev ├── sample657.nev ├── sample658.nev ├── sample642.nev ├── sample656.nev.err ├── sample673.nev ├── sample675.nev ├── sample_embed.nev ├── sample119.nev ├── sample121.nev ├── sample228.nev ├── sample381.nev ├── sample623.nev ├── sample632.nev ├── sample674.nev ├── sample186.nev ├── sample240.nev ├── sample436.nev ├── sample660.nev ├── sample171.nev ├── sample231.nev ├── sample604.nev ├── sample120.nev ├── sample166.nev ├── sample183.nev ├── sample239.nev ├── sample261.nev ├── sample690.nev ├── sample691.nev ├── sample692.nev ├── sample693.nev ├── sample268.nev ├── sample50.nev ├── sample537.nev ├── sample165.nev ├── sample170.nev ├── sample194.nev ├── sample200.nev ├── sample453.nev ├── sample528.nev ├── sample112.nev ├── sample116.nev ├── sample199.nev ├── sample312.nev ├── sample343.nev ├── sample376.nev ├── sample92.nev ├── sample123.nev ├── sample176.nev ├── sample229.nev ├── sample297.nev ├── sample313.nev ├── sample348.nev ├── sample525.nev ├── sample538.nev ├── sample625.nev ├── sample140.nev ├── sample192.nev ├── sample483.nev ├── sample314.nev ├── sample322.nev ├── sample429.nev ├── sample430.nev ├── sample482.nev ├── sample18.nev ├── sample222.nev ├── sample341.nev ├── sample616.nev ├── sample95.nev ├── sample98.nev ├── sample117.nev ├── sample130.nev ├── sample178.nev ├── sample273.nev ├── sample342.nev ├── sample431.nev ├── sample432.nev ├── sample628.nev ├── sample_fib_tail_nested.nev ├── sample11.nev ├── sample118.nev ├── sample182.nev ├── sample189.nev ├── sample344.nev ├── sample346.nev ├── sample388.nev ├── sample389.nev ├── sample5.nev ├── sample602.nev ├── sample606.nev ├── sample626.nev ├── sample629.nev ├── sample181.nev ├── sample21nok.nev ├── sample230.nev ├── sample363.nev ├── sample131.nev ├── sample185.nev ├── sample345.nev ├── sample367.nev ├── sample662.nev ├── sample664.nev ├── sample665.nev ├── sample94.nev ├── sample_man6.nev ├── sample30.nev ├── sample356.nev ├── sample433.nev ├── sample526.nev ├── sample_fib_tail_ret.nev ├── sample_man10.nev ├── sample172.nev ├── sample174.nev ├── sample198.nev ├── sample347.nev ├── sample354.nev ├── sample466.nev ├── sample637.nev ├── sample663.nev ├── sample91.nev ├── sample96.nev ├── sample113.nev ├── sample16.nev ├── sample169.nev ├── sample173.nev ├── sample298.nev ├── sample323.nev ├── sample398.nev ├── sample519.nev ├── sample110.nev ├── sample13.nev ├── sample188.nev ├── sample195.nev ├── sample315.nev ├── sample328.nev ├── sample641.nev ├── sample_man8.nev ├── sample111.nev ├── sample196.nev ├── sample325.nev ├── sample330.nev ├── sample447.nev ├── sample622.nev ├── sample624.nev ├── sample634.nev ├── sample15.nev ├── sample260.nev ├── sample329.nev ├── sample509.nev ├── sample645.nev ├── sample661.nev ├── sample90.nev ├── sample_fib.nev ├── sample101.nev ├── sample25.nev ├── sample324.nev ├── sample40.nev ├── sample481.nev ├── sample512.nev ├── sample102.nev ├── sample150.nev ├── sample175.nev ├── sample352.nev ├── sample435.nev ├── sample155.nev ├── sample197.nev ├── sample201.nev ├── sample319.nev ├── sample399.nev ├── sample522.nev ├── sample530.nev ├── sample686.nev ├── sample8.nev ├── sample_even_odd.nev ├── sample100.nev ├── sample122.nev ├── sample151.nev ├── sample157.nev ├── sample390.nev ├── sample510.nev ├── sample_man3.nev ├── sample_reverse.nev ├── sample245.nev ├── sample270.nev ├── sample327.nev ├── sample331.nev ├── sample439.nev ├── sample450.nev ├── sample532.nev ├── sample12.nev ├── sample153.nev ├── sample156.nev ├── sample22.nev ├── sample357.nev ├── sample391.nev ├── sample446.nev ├── sample457.nev ├── sample687.nev ├── sample688.nev ├── sample_man5.nev ├── sample242.nev ├── sample434.nev ├── sample527.nev ├── sample133.nev ├── sample281.nev ├── sample104.nev ├── sample154.nev ├── sample158.nev ├── sample493.nev ├── sample511.nev ├── sample608.nev ├── sample609.nev ├── sample618.nev ├── sample_man4.nev ├── sample280.nev ├── sample355.nev ├── sample630.nev ├── sample3.nev ├── sample326.nev ├── sample361.nev ├── sample462.nev ├── sample421.nev ├── sample644.nev ├── sample177.nev ├── sample286.nev ├── sample353.nev ├── sample404.nev ├── sample407.nev ├── sample408.nev ├── sample448.nev ├── sample287.nev ├── sample292.nev ├── sample365.nev ├── sample371.nev ├── sample531.nev ├── sample605.nev ├── sample612.nev ├── sample115.nev ├── sample414.nev ├── sample422.nev ├── sample445.nev ├── sample271.nev ├── sample370.nev ├── sample378.nev ├── sample_lcomp.nev ├── sample223.nev ├── sample288.nev ├── sample332.nev ├── sample_curradd.nev ├── sample380.nev ├── sample613.nev ├── sample_man9.nev ├── sample285.nev ├── sample306.nev ├── sample373.nev ├── sample375.nev ├── sample443.nev ├── sample283.nev ├── sample103.nev ├── sample372.nev ├── sample494.nev ├── sample187.nev ├── sample420.nev ├── sample132.nev ├── sample17.nev ├── sample282.nev ├── sample23.nev ├── sample24.nev ├── sample413.nev ├── sample423.nev ├── sample617.nev ├── sample10.nev ├── sample293.nev ├── sample415.nev ├── sample646.nev ├── sample401.nev ├── sample402.nev ├── sample_main_strarr.nev ├── sample515.nev ├── sample610.nev ├── sample164.nev ├── sample454.nev ├── sample514.nev ├── sample523.nev ├── sample235.nev ├── sample452.nev ├── sample513.nev ├── sample215.nev ├── sample234.nev ├── sample238.nev ├── sample382.nev ├── sample387.nev ├── sample405.nev ├── sample241.nev ├── sample284.nev ├── sample302.nev ├── sample364.nev ├── sample648.nev ├── sample_fficonc.nev ├── sample_lcomp2.nev ├── sample451.nev ├── sample666.nev ├── sample161.nev ├── sample213.nev ├── sample689.nev ├── sample2.nev ├── sample28.nev ├── sample309.nev ├── sample403.nev ├── sample464.nev ├── sample_lcomp3.nev ├── sample307.nev ├── sample385.nev ├── sample619.nev ├── sample635.nev ├── sample_sum_digits.nev ├── sample_temp.nev ├── sample428.nev ├── sample20.nev ├── sample236.nev ├── sample291.nev ├── sample600.nev ├── sample141.nev ├── sample237.nev ├── sample340.nev ├── sample349.nev ├── sample416.nev ├── sample607.nev ├── sample615.nev ├── sample162.nev ├── sample160.nev ├── sample233.nev ├── sample289.nev ├── sample377.nev ├── sample304.nev ├── sample320.nev ├── sample449.nev ├── sample27.nev ├── sample290.nev ├── sample383.nev ├── sample26.nev ├── sample620.nev ├── sample14.nev ├── sample294.nev ├── sample411.nev ├── sample394.nev ├── sample7.nev └── sample152.nev ├── docs ├── index.md └── _config.yml ├── .github └── workflows │ └── codeql-buildscript.sh ├── dyntest ├── dyntest.h └── Makefile ├── never-init.js ├── .gitignore └── appveyor.yml /sample/sample683.nev.err: -------------------------------------------------------------------------------- 1 | :6: error: cannot assign to const int -------------------------------------------------------------------------------- /sample/sample687.nev.err: -------------------------------------------------------------------------------- 1 | :10: error: cannot assign to const int -------------------------------------------------------------------------------- /sample/sample659.nev.err: -------------------------------------------------------------------------------- 1 | :4: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample660.nev.err: -------------------------------------------------------------------------------- 1 | :4: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample666.nev.err: -------------------------------------------------------------------------------- 1 | :13: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample668.nev.err: -------------------------------------------------------------------------------- 1 | :6: error: cannot assign to const float 2 | -------------------------------------------------------------------------------- /sample/sample670.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample679.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample680.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample681.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample684.nev.err: -------------------------------------------------------------------------------- 1 | :6: error: cannot assign to const int 2 | -------------------------------------------------------------------------------- /sample/sample690.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const func 2 | -------------------------------------------------------------------------------- /sample/sample692.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const func 2 | -------------------------------------------------------------------------------- /sample/sample504.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> long 3 | { 4 | 0L 5 | } 6 | -------------------------------------------------------------------------------- /sample/sample505.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> double 3 | { 4 | 0.0d 5 | } 6 | -------------------------------------------------------------------------------- /sample/sample665.nev.err: -------------------------------------------------------------------------------- 1 | :11: error: cannot assign const record to var 2 | -------------------------------------------------------------------------------- /sample/sample677.nev.err: -------------------------------------------------------------------------------- 1 | :8: error: cannot assign different types enum int 2 | -------------------------------------------------------------------------------- /sample/sample42.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | sin(3.141) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample206.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let a = 1.0; 5 | a 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample207.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | let a = 1; 5 | a 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample31.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert(20 / 5 / 2 == 2) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample41.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | 1 != 1 ? 12.0 : 40.0 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample_man1.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | 100.0 * 1.8 + 32.0 5 | } 6 | 7 | -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | # Never Documentation 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /sample/sample29.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((2 + 2 * 2) == 6) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample214.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((10 + 2) % (2 + 1) == 0) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample640.nev.err: -------------------------------------------------------------------------------- 1 | :8: error: cannot assign to const int 2 | :9: error: cannot assign to const int 3 | -------------------------------------------------------------------------------- /sample/sample672.nev.err: -------------------------------------------------------------------------------- 1 | :6: warning: expression on assignment left side is not an identifier but seq 2 | -------------------------------------------------------------------------------- /sample/sample676.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | { 10; 20 } = { 30; 40 }; 5 | 6 | 0 7 | } 8 | -------------------------------------------------------------------------------- /sample/sample663.nev.err: -------------------------------------------------------------------------------- 1 | :13: error: cannot assign to const int 2 | :14: error: cannot assign to const int 3 | -------------------------------------------------------------------------------- /sample/sample_hello.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | prints("Hello World!\n"); 5 | 10 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample368.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | prints("one" + "two\n"); 5 | 6 | 0 7 | } 8 | 9 | -------------------------------------------------------------------------------- /sample/sample51.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert(1 < 10 && 20 < 30 ? true : false) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /.github/workflows/codeql-buildscript.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | mkdir build && cd build 4 | cmake ../ 5 | make 6 | -------------------------------------------------------------------------------- /sample/sample484.nev: -------------------------------------------------------------------------------- 1 | 2 | use msix 3 | 4 | func main() -> int 5 | { 6 | assert(msix.six() == 6); 7 | 0 8 | } 9 | -------------------------------------------------------------------------------- /sample/sample671.nev.err: -------------------------------------------------------------------------------- 1 | :7: error: cannot assign to const int 2 | :7: error: cannot assign different types int char 3 | -------------------------------------------------------------------------------- /sample/sample184.nev: -------------------------------------------------------------------------------- 1 | func main() -> float 2 | { 3 | printf(10.0); 4 | printf(20.0); 5 | printf(30.0) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample488.nev: -------------------------------------------------------------------------------- 1 | 2 | use mtail 3 | 4 | func main() -> int 5 | { 6 | mtail.spaces(200); 7 | 0 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample480.nev: -------------------------------------------------------------------------------- 1 | 2 | use mone 3 | 4 | func main() -> int 5 | { 6 | print(mone.Z); 7 | mone.one(10) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample671.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let x = 0; 6 | 7 | x = { 'X' }; 8 | 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample209.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | let a = 12.0; 5 | let b = 3.0; 6 | 7 | a / b 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample653.nev.err: -------------------------------------------------------------------------------- 1 | :12: error: passing const expression to variable param a at line 2 2 | :12: error: function call type mismatch 3 | -------------------------------------------------------------------------------- /sample/sample658.nev.err: -------------------------------------------------------------------------------- 1 | :12: error: passing const expression to variable param t at line 2 2 | :12: error: function call type mismatch 3 | -------------------------------------------------------------------------------- /dyntest/dyntest.h: -------------------------------------------------------------------------------- 1 | 2 | char * test_conc_str(const char * a, const char * b); 3 | 4 | char * test_conc_int_str(int d, const char * s); 5 | 6 | 7 | -------------------------------------------------------------------------------- /sample/sample203.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 < 10.0 ? 1 : 0) == 1); 5 | assert((1 < 10 ? 1 : 0) == 1) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample205.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 > 10.0 ? 1 : 0) == 0); 5 | assert((1 > 10 ? 1 : 0) == 0) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample219.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let i = 10; 5 | 6 | if (i > 0) { print(10) } else { print(20) } 7 | } 8 | 9 | -------------------------------------------------------------------------------- /sample/sample655.nev.err: -------------------------------------------------------------------------------- 1 | :4: error: passing const expression to variable param at line 2 2 | :2: error: incorrect return type in function f1 3 | -------------------------------------------------------------------------------- /sample/sample673.nev.err: -------------------------------------------------------------------------------- 1 | :10: warning: expression on assignment left side is not an identifier but seq 2 | :10: error: cannot assign to temp int 3 | -------------------------------------------------------------------------------- /sample/sample676.nev.err: -------------------------------------------------------------------------------- 1 | :4: warning: expression on assignment left side is not an identifier but seq 2 | :4: error: cannot assign to temp int 3 | -------------------------------------------------------------------------------- /sample/sample679.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let t = {[ 2, 2 ]} : int; 6 | 7 | t[0,0] = 10; 8 | 9 | 0 10 | } -------------------------------------------------------------------------------- /sample/sample686.nev.err: -------------------------------------------------------------------------------- 1 | :16: warning: expression on assignment left side is not an identifier but seq 2 | :16: error: cannot assign to temp int 3 | -------------------------------------------------------------------------------- /sample/sample202.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 <= 10.0 ? 1 : 0) == 1); 5 | assert((1 <= 10 ? 1 : 0) == 1) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample204.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 >= 10.0 ? 1 : 0) == 0); 5 | assert((1 >= 10 ? 1 : 0) == 0) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample208.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | let a = 1; 5 | let b = 10; 6 | 7 | assert((b - 1) == 9) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample210.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | let a = 12; 5 | let b = 3; 6 | 7 | assert((a % b) == 0) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample211.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 == 10.0 ? 1 : 0) == 0); 5 | assert((1 == 10 ? 1 : 0) == 0) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample212.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert((1.0 != 10.0 ? 1 : 0) == 1); 5 | assert((1 != 10 ? 1 : 0) == 1) 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample267.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | prints("and" + " " + "the" + " " + "answer" + " " + "is" + "\n"); 5 | 0 6 | } 7 | 8 | -------------------------------------------------------------------------------- /sample/sample485.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | use msix 4 | use mseven 5 | 6 | func main() -> int 7 | { 8 | assert(msix.six() == 6); 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample486.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | use mseven 4 | use msix 5 | 6 | func main() -> int 7 | { 8 | assert(msix.six() == 6); 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample674.nev.err: -------------------------------------------------------------------------------- 1 | :11: warning: expression on assignment left side is not an identifier but while 2 | :11: error: cannot assign to const int 3 | -------------------------------------------------------------------------------- /sample/sample680.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var t = {[ 2, 2 ]} : let int; 6 | 7 | t[0,0] = 10; 8 | 9 | 0 10 | } -------------------------------------------------------------------------------- /sample/sample681.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let t = {[ 2, 2 ]} : let int; 6 | 7 | t[0,0] = 10; 8 | 9 | 0 10 | } -------------------------------------------------------------------------------- /sample/sample688.nev.err: -------------------------------------------------------------------------------- 1 | :13: warning: expression on assignment left side is not an identifier but match 2 | :13: error: cannot assign to temp int 3 | -------------------------------------------------------------------------------- /sample/lib/mthree.nev: -------------------------------------------------------------------------------- 1 | 2 | module mthree { 3 | 4 | func three(i : int) -> int 5 | { 6 | 10 / i 7 | } 8 | 9 | } 10 | 11 | -------------------------------------------------------------------------------- /sample/sample221.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let i = 10; 5 | let val = if (i > 0) { 1000 }; 6 | 7 | val 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample468.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 10; 5 | 6 | if (i == 20) { i = 10 } else { 5 }; 7 | 8 | 0 9 | } 10 | -------------------------------------------------------------------------------- /sample/sample672.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var x = 0; 5 | 6 | { x } = 20; 7 | assert(x == 20); 8 | 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample675.nev.err: -------------------------------------------------------------------------------- 1 | :10: warning: expression on assignment left side is not an identifier but do while 2 | :10: error: cannot assign to const int 3 | -------------------------------------------------------------------------------- /sample/sample220.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let i = 10; 5 | let val = 1000; 6 | 7 | if (i > 0) { print(val) } 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample669.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var x = 0; 6 | 7 | x = { 20 }; 8 | assert(x == 20); 9 | 10 | 0 11 | } 12 | -------------------------------------------------------------------------------- /sample/sample670.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let x = 0; 6 | 7 | x = { 20 }; 8 | assert(x == 20); 9 | 10 | 0 11 | } 12 | -------------------------------------------------------------------------------- /sample/lib/mseven.nev: -------------------------------------------------------------------------------- 1 | 2 | module mseven { 3 | 4 | var SEVEN = 7 5 | 6 | func seven() -> int 7 | { 8 | SEVEN 9 | } 10 | 11 | } 12 | -------------------------------------------------------------------------------- /sample/sample529.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | (12 + 19) |> let func(i : int) -> int { prints("aa" + i + "aa" + "\n"); 0 }(); 5 | 6 | 0 7 | } 8 | 9 | -------------------------------------------------------------------------------- /sample/sample218.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 0; 5 | let w = while (i < 10) { print(i); i = i + 1 }; 6 | 7 | w 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample472.nev: -------------------------------------------------------------------------------- 1 | 2 | let val = 20; 3 | 4 | func one() -> int 5 | { 6 | val 7 | } 8 | 9 | func main() -> int 10 | { 11 | one() 12 | } 13 | 14 | 15 | -------------------------------------------------------------------------------- /sample/lib/mone.nev: -------------------------------------------------------------------------------- 1 | 2 | module mone { 3 | 4 | var Z = 1000; 5 | 6 | func one(a : int) -> int 7 | { 8 | a + 1 9 | } 10 | 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample227.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 1; 5 | var f = for (i = 15; i >= 0; i = i - 1) { print(i) }; 6 | 7 | f 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample678.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var t = {[ 2, 2 ]} : int; 6 | 7 | t[0,0] = 10; 8 | assert(t[0,0] == 10); 9 | 10 | 0 11 | } -------------------------------------------------------------------------------- /sample/sample683.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let s = [ x * x | x in [10, 20, 30, 40, 50] : int ] : int; 5 | 6 | s[0] = 10; 7 | 8 | 0 9 | } 10 | -------------------------------------------------------------------------------- /sample/sample243.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | sqrt(-1); 5 | assert(false); 6 | 0 7 | } 8 | catch (invalid_domain) 9 | { 10 | -1 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample272.nev: -------------------------------------------------------------------------------- 1 | 2 | func fib(n : int) -> int 3 | { 4 | n < 2 ? n : fib(n - 1) + fib(n - 2) 5 | } 6 | 7 | func main() -> int 8 | { 9 | fib(14) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample684.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var s = [ x * x | x in [10, 20, 30, 40, 50] : int ] : let int; 5 | 6 | s[0] = 10; 7 | 8 | 0 9 | } 10 | -------------------------------------------------------------------------------- /sample/sample_man2.nev: -------------------------------------------------------------------------------- 1 | 2 | func cel2fah(c : float) -> float 3 | { 4 | c * 1.8 + 32.0 5 | } 6 | 7 | func main() -> float 8 | { 9 | cel2fah(200.0) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/lib/mfive.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | module mfive { 4 | 5 | use mthree 6 | 7 | func five(i : int) -> int 8 | { 9 | mthree.three(i) 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample244.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> float 3 | { 4 | log(-10.0); 5 | assert(false); 6 | 1.0 7 | } 8 | catch (invalid_domain) 9 | { 10 | -1.0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample638.nev: -------------------------------------------------------------------------------- 1 | 2 | func F1(s : string, a : int) -> int 3 | { 4 | 10 5 | } 6 | 7 | func main() -> int 8 | { 9 | print(F1( "ala", 100)); 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample647.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1( [ from .. to ] : range) -> int 3 | { 4 | 0 5 | } 6 | 7 | func main() -> int 8 | { 9 | f1( [ 10 .. 200] ); 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /dyntest/Makefile: -------------------------------------------------------------------------------- 1 | 2 | CC = gcc -g 3 | CFLAGS = -Wall 4 | 5 | dyntest.o: dyntest.c dyntest.h 6 | $(CC) $(CFLAGS) -fPIC -c dyntest.c -o dyntest.o 7 | $(CC) -shared dyntest.o -o dyntest.so 8 | -------------------------------------------------------------------------------- /sample/sample507.nev: -------------------------------------------------------------------------------- 1 | 2 | use raylib 3 | 4 | let D = 20; 5 | 6 | func main() -> int 7 | { 8 | var a = {[ D ]} : float; 9 | 10 | a[0] = 10.0; 11 | 12 | 0 13 | } 14 | -------------------------------------------------------------------------------- /sample/sample677.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Index { Zero, One, Two, Three, Four } 3 | 4 | func main() -> int 5 | { 6 | var i = Index::Zero; 7 | 8 | i = 10; 9 | 10 | 0 11 | } 12 | -------------------------------------------------------------------------------- /sample/sample_gcd.nev: -------------------------------------------------------------------------------- 1 | 2 | func gcd(x : int, y : int) -> int 3 | { 4 | (y == 0) ? x : gcd(y, x % y) 5 | } 6 | 7 | func main() -> int 8 | { 9 | gcd(56, 12) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample193.nev: -------------------------------------------------------------------------------- 1 | func f(a : int) -> [_] : int 2 | { 3 | (a == 0) ? [ 10, 11, 12 ] : int : [ 1, 2, 3 ] : int 4 | } 5 | 6 | func main() -> int 7 | { 8 | f(0)[0] 9 | } 10 | 11 | -------------------------------------------------------------------------------- /sample/sample217.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var n = 32; 5 | 6 | do 7 | { 8 | print(n % 2); 9 | n = n / 2 10 | } while (n != 0) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample262.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | let s1 = "text equal"; 5 | let s2 = "text equal"; 6 | 7 | assert((if (s1 == s2) { 1 } else { 0 }) == 1) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample264.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let s1 = "beginning"; 5 | let s2 = "and end"; 6 | 7 | prints(s1 + " " + s2 + "\n"); 8 | 9 | 0 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample265.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let txt = "answer is "; 5 | let value = 200; 6 | 7 | prints(txt + value + "\n"); 8 | 9 | 0 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample487.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | enum E { ONE, TWO, THREE } 4 | 5 | func test() -> E 6 | { 7 | E::ONE 8 | } 9 | 10 | func main() -> int 11 | { 12 | test(); 13 | 0 14 | } 15 | -------------------------------------------------------------------------------- /sample/sample627.nev: -------------------------------------------------------------------------------- 1 | 2 | func t ( a : (int) ) -> (int) 3 | { 4 | ((10,) : (int)) 5 | } 6 | 7 | func main() -> int 8 | { 9 | t( (1,) : (int) ); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample80.nev: -------------------------------------------------------------------------------- 1 | 2 | func add(a : int, b : int, c : int) -> int 3 | { 4 | a + b + c 5 | } 6 | 7 | func main(a : int, b : int) -> int 8 | { 9 | add(a, b, 1) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample80.nevs: -------------------------------------------------------------------------------- 1 | 2 | func add(a : int, b : int, c : int) -> int 3 | { 4 | a + b + c 5 | } 6 | 7 | func main(a : int, b : int) -> int 8 | { 9 | add(a, b, 1) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample263.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | let s1 = "text equal"; 5 | let s2 = "text not equal"; 6 | 7 | assert((if (s1 != s2) { 1 } else { 0 }) == 1) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample266.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let txt = "answer is "; 5 | let value = 102.98; 6 | 7 | prints(txt + strf(value) + "\n"); 8 | 9 | 0 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample9.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * more crazy stuff 3 | */ 4 | func main() -> bool 5 | { 6 | assert(let func min(a : float, b : float) -> float { (a < b) ? a : b }(100.0, 20.0) == 20.0) 7 | } 8 | 9 | -------------------------------------------------------------------------------- /sample/sample_or.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let i = true; 5 | 6 | let z = { i } || { prints("false\n"); false }; 7 | 8 | printb(z); 9 | 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample224.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 1; 5 | var C = 10; 6 | 7 | for (i = 15; i >= 0; i = i - 1) 8 | { 9 | print(C + i) 10 | } 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample438.nev: -------------------------------------------------------------------------------- 1 | 2 | func exec() -> int 3 | { 4 | while (false) 5 | { 6 | 10 7 | } 8 | } 9 | 10 | func main() -> int 11 | { 12 | print(exec()) 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /sample/sample52.nev: -------------------------------------------------------------------------------- 1 | /* this example shows that condition expression will be eliminated */ 2 | func main() -> int 3 | { 4 | print( false ? 10 : let func (a : int) -> int { a } (20 * 2) ) 5 | } 6 | 7 | -------------------------------------------------------------------------------- /sample/sample524.nev: -------------------------------------------------------------------------------- 1 | 2 | func rec(i : int) -> int 3 | { 4 | print(i); 5 | i > 0 ? (i - 1) |> rec() : 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | print(rec(10)); 11 | 12 | 0 13 | } -------------------------------------------------------------------------------- /sample/sample682.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var s = [ x * x | x in [10, 20, 30, 40, 50] : int ] : int; 5 | 6 | s[0] = 10; 7 | assert(s[0] == 10); 8 | 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample163.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | i < 10 ? { print(i); loop(i + 1) } : 10 7 | }; 8 | 9 | loop(0) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample216.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 0; 5 | 6 | while (i < 10) 7 | { 8 | print(i); 9 | i = i + 1 10 | }; 11 | 12 | i 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample362.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let system = let extern "libc.so.6" func system(cmd : string) -> float; 6 | let v = system("uname -a"); 7 | 8 | 0 9 | } 10 | 11 | -------------------------------------------------------------------------------- /sample/sample667.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t = (10.0, 20, 30, 40) : (float, int, int, int); 5 | 6 | t[0] = 1.0; 7 | 8 | assert(t[0] == 1.0); 9 | 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample668.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let t = (10.0, 20, 30, 40) : (float, int, int, int); 5 | 6 | t[0] = 1.0; 7 | 8 | assert(t[0] == 1.0); 9 | 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample685.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var s = [ x * x | x in [10, 20, 30, 40, 50] : int ] : var int; 5 | 6 | s[0] = 10; 7 | assert(s[0] == 10); 8 | 9 | 0 10 | } 11 | -------------------------------------------------------------------------------- /sample/sample180.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> () -> int 3 | { 4 | let func f2() -> int { a + b + c } 5 | } 6 | 7 | func main() -> int 8 | { 9 | f1(80, 90, 100)() 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample639.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var a = 10; 6 | let b = 100; 7 | 8 | a = b; 9 | a = 1000; 10 | 11 | prints("a = " + a + "\n"); 12 | 13 | 0 14 | } 15 | -------------------------------------------------------------------------------- /sample/sample640.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let a = 10; 6 | var b = 100; 7 | 8 | a = b; 9 | a = 1000; 10 | 11 | prints("a = " + a + "\n"); 12 | 13 | 0 14 | } 15 | -------------------------------------------------------------------------------- /sample/sample650.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int) -> int 3 | { 4 | 0 5 | } 6 | 7 | func main() -> int 8 | { 9 | let a = 1; 10 | let b = 2; 11 | 12 | f1(a, b); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample651.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int) -> int 3 | { 4 | 0 5 | } 6 | 7 | func main() -> int 8 | { 9 | var a = 1; 10 | var b = 2; 11 | 12 | f1(a, b); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample93.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(tab[row, col] : int) -> int 3 | { 4 | row * col 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert(f1([ [ 10, 20, 30 ], [ 30, 40, 50 ] ] : int) == 6) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample97.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab(tab[dim1, dim2] : int) -> int 3 | { 4 | print(tab[dim1 - 1, dim2 - 1]) 5 | } 6 | 7 | func main() -> int 8 | { 9 | printtab( {[10, 20]} : int ) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample114.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D] : int 3 | { 4 | [ a, b, a + c, b ] : int 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert(f1(80, 90, 100)[2] == 180) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample437.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let a = [ false, true, false, true ] : bool; 5 | 6 | assert(a[0] == false); 7 | assert(a[1] == true); 8 | 9 | 0 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample614.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var x = 10; 5 | var y = x; 6 | var z = y; 7 | 8 | z = 20; 9 | 10 | print(x); 11 | 12 | assert(x == 20); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample81.nevs: -------------------------------------------------------------------------------- 1 | #!../debug/never -f 2 | 3 | func add(a : int, b : int, c : int) -> int 4 | { 5 | a + b + c 6 | } 7 | 8 | func main(a : int, b : int) -> int 9 | { 10 | add(a, b, 1) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample_fib_tail.nev: -------------------------------------------------------------------------------- 1 | func fib(n : int, a : int, b : int) -> int 2 | { 3 | (n == 0) ? a : (n == 1) ? b : fib(n - 1, b, a + b) 4 | } 5 | 6 | func main() -> int 7 | { 8 | fib(20, 1, 1) 9 | } 10 | 11 | -------------------------------------------------------------------------------- /sample/sample_man7.nev: -------------------------------------------------------------------------------- 1 | 2 | func calc() -> (float) -> float 3 | { 4 | let func fah2cel(f : float) -> float { (f - 32.0) / 1.8 } 5 | } 6 | 7 | func main() -> float 8 | { 9 | calc()(212.0) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample19.nev: -------------------------------------------------------------------------------- 1 | func main() -> bool 2 | { 3 | func fib(n : int) -> int 4 | { 5 | (n == 0) ? 1 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2) 6 | }; 7 | assert(fib(7) == 21) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample191.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> int 2 | { 3 | var a = 0; 4 | var b = i * i * i; 5 | 6 | a = b = 10; 7 | b = a + 20 8 | } 9 | 10 | func main() -> int 11 | { 12 | f(5) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample4.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func min(a : float, b : float) -> float 4 | { 5 | (a < b) ? a : b 6 | } 7 | 8 | func main() -> bool 9 | { 10 | assert(min(min(10.0, 8.0), min(20.0, 30.0)) == 8.0) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample467.nev: -------------------------------------------------------------------------------- 1 | 2 | let f = let func() -> int { 10 * 10 }; 3 | let A = f(); 4 | let B = A; 5 | 6 | func main() -> int 7 | { 8 | print(f()); 9 | print(A); 10 | print(B); 11 | 12 | 0 13 | } 14 | -------------------------------------------------------------------------------- /sample/sample649.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var a = "aaaaaa"; 5 | var b = "bbbbbb"; 6 | 7 | a = b; 8 | b = "ccccccc"; 9 | 10 | prints("a = " + a + "\n"); 11 | 12 | 0 13 | } 14 | -------------------------------------------------------------------------------- /sample/sample652.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int, var b : int) -> int 3 | { 4 | 0 5 | } 6 | 7 | func main() -> int 8 | { 9 | var a = 1; 10 | var b = 2; 11 | 12 | f1(a, b); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample653.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int, var b : int) -> int 3 | { 4 | 0 5 | } 6 | 7 | func main() -> int 8 | { 9 | let a = 1; 10 | let b = 2; 11 | 12 | f1(a, b); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/lib/EM.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | module EM 4 | { 5 | let ONE = 1; 6 | 7 | func one() -> int 8 | { 9 | ONE 10 | } 11 | 12 | func two() -> int 13 | { 14 | 2 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /sample/lib/msix.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | module msix { 4 | 5 | use mseven 6 | 7 | var SIX = 6 8 | 9 | func six() -> int 10 | { 11 | print(SIX); 12 | mseven.seven() - 1 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample179.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> float 3 | { 4 | let q = 10.0; 5 | let p = a + q; 6 | 7 | p + q 8 | } 9 | 10 | func main() -> float 11 | { 12 | outer(3.0, 5.0) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample190.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> int 2 | { 3 | var a = 2; 4 | var b = i * i * i; 5 | 6 | a = a * 10; 7 | b = a; 8 | b 9 | } 10 | 11 | func main() -> int 12 | { 13 | f(5) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample611.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t = [1, 2, 3, 4, 5] : int; 5 | 6 | for (a in t) 7 | a = 10 * a; 8 | 9 | for (a in t) 10 | print(a); 11 | 12 | 0 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample621.nev: -------------------------------------------------------------------------------- 1 | 2 | func t ( a : (int, float) ) -> (int, float) 3 | { 4 | ((10, 10.0) : (int, float)) 5 | } 6 | 7 | func main() -> int 8 | { 9 | t( (1, 2.0) : (int, float) ); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample655.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int) -> var int 3 | { 4 | a 5 | } 6 | 7 | func main() -> int 8 | { 9 | let a = 1; 10 | 11 | f1(a) = 10; 12 | 13 | assert(a == 10); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample659.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(t[D] : int) -> int 3 | { 4 | t[0] = 0; 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | let t = [ 1, 2, 3, 4 ] : int; 11 | 12 | f1(t); 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample654.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int) -> var int 3 | { 4 | a 5 | } 6 | 7 | func main() -> int 8 | { 9 | var a = 1; 10 | 11 | f1(a) = 10; 12 | 13 | assert(a == 10); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample656.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int) -> var int 3 | { 4 | a 5 | } 6 | 7 | func main() -> int 8 | { 9 | let a = 1; 10 | 11 | f1(a) = 10; 12 | 13 | assert(a == 10); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample657.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var t[D] : int) -> int 3 | { 4 | t[0] = 0; 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | var t = [ 1, 2, 3, 4 ] : int; 11 | 12 | f1(t); 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample658.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var t[D] : int) -> int 3 | { 4 | t[0] = 0; 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | let t = [ 1, 2, 3, 4 ] : int; 11 | 12 | f1(t); 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample642.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int) -> var int 3 | { 4 | a 5 | } 6 | 7 | func main() -> int 8 | { 9 | var a = 1; 10 | 11 | f1(a) = 10; 12 | 13 | prints("a = " + a + "\n"); 14 | 15 | 0 16 | } 17 | -------------------------------------------------------------------------------- /sample/sample656.nev.err: -------------------------------------------------------------------------------- 1 | :11: error: passing const expression to variable param a at line 2 2 | :11: error: function call type mismatch 3 | :11: error: cannot assign to temp error 4 | :11: error: cannot assign different types error int 5 | -------------------------------------------------------------------------------- /sample/sample673.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 0; 5 | var s = 0; 6 | 7 | for (i = 1; i <= 10; i = i + 1) 8 | { 9 | s = s + i 10 | } = 55; 11 | print(s); 12 | 13 | 0 14 | } 15 | -------------------------------------------------------------------------------- /sample/sample675.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 1; 5 | var s = 0; 6 | 7 | do { 8 | s = s + i; 9 | i = i + 1 10 | } while (i <= 10) = 55; 11 | print(s); 12 | 13 | 0 14 | } 15 | -------------------------------------------------------------------------------- /sample/sample_embed.nev: -------------------------------------------------------------------------------- 1 | 2 | extern "host" func test_print_str(str : string) -> int 3 | 4 | func main() -> int 5 | { 6 | test_print_str("0123456789\n"); 7 | test_print_str("987" + "123\n"); 8 | 9 | 0 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample119.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, tab[row, col] : int) -> int 3 | { 4 | tab[row - 1, col - 1] 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert(f1(10 * 10, [[ 10, 20, 30 ], [ 30, 40, 50 ]] : int) == 50) 10 | } 11 | 12 | -------------------------------------------------------------------------------- /sample/sample121.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int) -> int 3 | { 4 | ([ [ a, 2, 3, 4, 5 ] : int, 5 | [ a + 10, 12, 13 ] : int ] : [_] : int)[1][0] 6 | } 7 | 8 | func main() -> bool 9 | { 10 | assert(f1(1) == 11) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample228.nev: -------------------------------------------------------------------------------- 1 | 2 | func ass(var v : int) -> int 3 | { 4 | v = 10 5 | } 6 | 7 | func main() -> int 8 | { 9 | var i = 1; 10 | 11 | print(i); 12 | 13 | ass(i); 14 | 15 | print(i) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample381.nev: -------------------------------------------------------------------------------- 1 | enum E { one, two, three } 2 | 3 | func main() -> int 4 | { 5 | let e = E::one; 6 | let s = if (e == E::one) { "E::one\n" } else { "other\n" }; 7 | 8 | prints(s); 9 | 10 | 0 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample623.nev: -------------------------------------------------------------------------------- 1 | 2 | func t ( a : (int, float), b : (int, int) ) -> (int, float) 3 | { 4 | ((a)) 5 | } 6 | 7 | func main() -> int 8 | { 9 | t( (1, 2.0) : (int, float), (10, 20) : (int, int) ); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample632.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t1 = {[ 5 ]} : (int, float); 5 | 6 | t1[0] = (10, 10.0) : (int, float); 7 | 8 | assert(t1[0][0] == 10); 9 | assert(t1[0][1] == 10.0); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample674.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 0; 5 | var s = 0; 6 | 7 | while (i <= 10) 8 | { 9 | s = s + i; 10 | i = i + 1 11 | } = 55; 12 | print(s); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /never-init.js: -------------------------------------------------------------------------------- 1 | var Module = { 2 | 'print': function(text) { var output = document.getElementById("output"); output.value += text; }, 3 | 'printErr': function(text) { var output = document.getElementById("output"); output.value += text; } 4 | }; 5 | -------------------------------------------------------------------------------- /sample/sample186.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> int 2 | { 3 | let a = i * i; 4 | let b = i * i * i; 5 | 6 | print(2 * i); 7 | print(a); 8 | print(b) 9 | } 10 | 11 | func main() -> int 12 | { 13 | f(5) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample240.nev: -------------------------------------------------------------------------------- 1 | 2 | func one(d : int) -> int 3 | { 4 | d < 10 ? { print(d); one(d + 1) } : 0 5 | } 6 | catch (division_by_zero) 7 | { 8 | one(1) 9 | } 10 | 11 | func main() -> int 12 | { 13 | one(0) 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /sample/sample436.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var a = {[ 10 ]} : bool; 5 | 6 | a[0] = false; 7 | a[1] = true; 8 | 9 | assert(a[0] == false); 10 | assert(a[1] == true); 11 | 12 | 0 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample660.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var t[D] : int) -> int 3 | { 4 | D = 10; 5 | t[0] = 0; 6 | 0 7 | } 8 | 9 | func main() -> int 10 | { 11 | var t = [ 1, 2, 3, 4 ] : int; 12 | 13 | f1(t); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample171.nev: -------------------------------------------------------------------------------- 1 | 2 | func sum(a : float, b : float, c : float) -> float 3 | { 4 | let p = a + b + c; 5 | let q = 10.0 + 2.0; 6 | 7 | p + q 8 | } 9 | 10 | func main() -> float 11 | { 12 | sum(3.0, 4.0, 5.0) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample231.nev: -------------------------------------------------------------------------------- 1 | 2 | func ass(var a : float) -> float 3 | { 4 | printf(a); 5 | a = 12.5 6 | } 7 | 8 | func main() -> int 9 | { 10 | var i = 10.0; 11 | 12 | print(i); 13 | ass(i); 14 | print(i) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample604.nev: -------------------------------------------------------------------------------- 1 | 2 | use mone 3 | 4 | var I = 0 5 | 6 | func test() -> int 7 | { 8 | I = mone.Z 9 | }; 10 | 11 | print(mone.Z); 12 | 13 | func main() -> int 14 | { 15 | test(); 16 | 17 | print(I); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /docs/_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-cayman 2 | title: never-lang 3 | description: Functional Programming Language 4 | 5 | #defaults: 6 | # - 7 | # scope: 8 | # path: "index.md" 9 | # values: 10 | # permalink: "index.html" 11 | 12 | -------------------------------------------------------------------------------- /sample/lib/mtail.nev: -------------------------------------------------------------------------------- 1 | 2 | module mtail { 3 | func spaces(n: int) -> string { 4 | func spaces0(s:string, n:int) -> string { 5 | (n == 0) ? s : spaces0(s+" ", n-1) 6 | }; 7 | spaces0(" ", n-1) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /sample/sample120.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int) -> int 3 | { 4 | ([[ 1, 2, 3 ], 5 | [ 3, 4, 5 ], 6 | [ 8, 9, 7 ], 7 | [ 7, 6, 6 ]] : int)[a, a - 1] 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f1(2) == 9) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample166.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | let val = i > 10 ? loop(5) : 5; 7 | 8 | i < 10 ? { print(i); loop(i + 1) } : 10 9 | }; 10 | 11 | loop(0) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /sample/sample183.nev: -------------------------------------------------------------------------------- 1 | func outer(to : int) -> () -> int 2 | { 3 | let p = 2 * to; 4 | let f = let func () -> int 5 | { 6 | p 7 | }; 8 | 9 | f 10 | } 11 | 12 | func main() -> int 13 | { 14 | outer(10)() 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample239.nev: -------------------------------------------------------------------------------- 1 | 2 | func one(d : int) -> int 3 | { 4 | if (d == 1) { 0 } else { 10 / d } 5 | } 6 | catch (division_by_zero) 7 | { 8 | one(1) 9 | } 10 | 11 | func main() -> bool 12 | { 13 | assert(one(0) == 0) 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /sample/sample261.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let s1 = "string one\n"; 5 | var s2 = "text two\n"; 6 | 7 | prints(s1); 8 | prints(s2); 9 | 10 | s2 = s1; 11 | 12 | prints(s2); 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample690.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let f1 = let func() -> int { 1000 }; 5 | let f2 = let func() -> int { 2000 }; 6 | 7 | f2 = f1; 8 | assert(f2() == 1000); 9 | assert(f1() == 1000); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample691.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let f1 = let func() -> int { 1000 }; 5 | var f2 = let func() -> int { 2000 }; 6 | 7 | f2 = f1; 8 | assert(f2() == 1000); 9 | assert(f1() == 1000); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample692.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var f1 = let func() -> int { 1000 }; 5 | let f2 = let func() -> int { 2000 }; 6 | 7 | f2 = f1; 8 | assert(f2() == 1000); 9 | assert(f1() == 1000); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample693.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var f1 = let func() -> int { 1000 }; 5 | var f2 = let func() -> int { 2000 }; 6 | 7 | f2 = f1; 8 | assert(f2() == 1000); 9 | assert(f1() == 1000); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample268.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | prints(120 + "," + 10 + "\n"); 5 | prints(120.0 + "," + 10.0 + "\n"); 6 | prints("[" + 120 + "," + 10.0 + "]\n"); 7 | prints("[" + 120.0 + "," + 10 + "]\n"); 8 | 0 9 | } 10 | 11 | -------------------------------------------------------------------------------- /sample/sample50.nev: -------------------------------------------------------------------------------- 1 | func one() -> bool 2 | { 3 | print(0); 4 | false 5 | } 6 | 7 | func two() -> bool 8 | { 9 | print(20); 10 | true 11 | } 12 | 13 | func main() -> bool 14 | { 15 | assert(one() || two() ? true : false) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample537.nev: -------------------------------------------------------------------------------- 1 | 2 | func rec_tail(i : int, j : int) -> int 3 | { 4 | prints(i + " " + j + "\n"); 5 | 6 | i > 0 ? (i - 1) |> rec_tail(10) : 0 7 | } 8 | 9 | func main() -> int 10 | { 11 | rec_tail(10, 10); 12 | 13 | 0 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample165.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | i < 10 ? { print(i); loop(i + 1) } : 10 7 | } 8 | catch 9 | { 10 | loop(100) 11 | }; 12 | 13 | loop(0) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample170.nev: -------------------------------------------------------------------------------- 1 | 2 | func area(a : float, b : float, c : float) -> float 3 | { 4 | let p = (a + b + c) / 2.0; 5 | 6 | sqrt(p * (p - a) * (p - b) * (p - c)) 7 | } 8 | 9 | func main() -> float 10 | { 11 | area(3.0, 4.0, 5.0) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /sample/sample194.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> [_] : int 2 | { 3 | var t1 = [ 1, 2, 3 ] : int; 4 | var t2 = [ 11, 12, 13, 14 ] : int; 5 | 6 | t1 = t2; 7 | t1 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f(5)[1] == 12) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample200.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | let t = [ 1, 2, 3, 4, 5 ] : int; 7 | 8 | i < 10 ? { print(t[i % 5]); loop(i + 1) } : 10 9 | }; 10 | 11 | loop(0) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /sample/sample453.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let str1 = "Hello World!"; 6 | let str2 = "!dlroW olleH"; 7 | 8 | prints(str1[length(str1) - 1 .. 0] + "\n"); 9 | assert(str1[length(str1) - 1 .. 0] == str2); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample528.nev: -------------------------------------------------------------------------------- 1 | 2 | func try(i : int) -> int 3 | { 4 | func pr() -> int { 5 | prints("iii" + i + "iii\n"); 6 | 0 7 | }; 8 | 9 | pr() 10 | } 11 | 12 | func main() -> int 13 | { 14 | 10 |> try(); 15 | 16 | 0 17 | } 18 | -------------------------------------------------------------------------------- /sample/sample112.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[row, col] : int) -> int 3 | { 4 | tab[row - 1, col - 1] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | call( {[ a, a ]} : int ) 10 | } 11 | 12 | func main() -> bool 13 | { 14 | assert(f1(3) == 0) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample116.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(tab[row, col] : int) -> [D] : [D,D] : int 3 | { 4 | [ tab, tab, tab ] : [D, D] : int 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert( f1( [ [ 1, 2 ], 10 | [ 3, 4 ] ] : int)[0][1,1] == 4 ) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample199.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var count = 0; 5 | 6 | func loop(i : int) -> int 7 | { 8 | i < 10 ? { print(i); count = count + 2; loop(i + 1) } : 10 9 | }; 10 | 11 | loop(0); 12 | count 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample312.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var str = "test test test"; 5 | 6 | assert(str != nil); 7 | assert(nil != str); 8 | 9 | 0 10 | } 11 | 12 | func main() -> int 13 | { 14 | test(); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample343.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | func getA() -> A 9 | { 10 | var a = A::one; 11 | a 12 | } 13 | 14 | func main() -> int 15 | { 16 | assert(getA() == A::one); 17 | 18 | 0 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample376.nev: -------------------------------------------------------------------------------- 1 | 2 | extern "libc.so.6" func getchar() -> int 3 | extern "libc.so.6" func putchar(c : int) -> int 4 | 5 | func main() -> int 6 | { 7 | var c = 0; 8 | 9 | /* c = getchar(); 10 | putchar(c); */ 11 | 12 | 0 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample92.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int) -> [D, D] : int 3 | { 4 | [[ a, 0, 0, 0 ], 5 | [ 0, a, 0, 0 ], 6 | [ 0, 0, a, 0 ], 7 | [ 0, 0, 0, a ]] : int 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f1(11)[0, 0] == 11) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample123.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(E : int, a[D] : int) -> int 3 | { 4 | assert(D == E); 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | f1( 0, [] : int ); 11 | f1( 3, [ 1, 2, 3 ] : int ); 12 | f1( 10, {[ 10 ]} : int ); 13 | 0 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample176.nev: -------------------------------------------------------------------------------- 1 | 2 | func table(a : float, b : float, c : float) -> float 3 | { 4 | let p = [ a, b, c, a + b, a + c, b + c ] : float; 5 | let q = 3; 6 | 7 | p[q] 8 | } 9 | 10 | func main() -> float 11 | { 12 | table(3.0, 4.0, 5.0) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample229.nev: -------------------------------------------------------------------------------- 1 | 2 | func ass(var tab[_] : int) -> int 3 | { 4 | tab[0] = 10 5 | } 6 | 7 | func main() -> int 8 | { 9 | var tab = [ 1, 2, 3, 4 ] : int; 10 | 11 | print(tab[0]); 12 | 13 | ass(tab); 14 | 15 | print(tab[0]) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample297.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var i = 0; 6 | var j = 0; 7 | 8 | for (i = 0; i < 10; i = i + 1) 9 | for (j = 0; j < 10; j = j + 1) 10 | prints(i + " " + j + "\n"); 11 | 12 | 0 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample313.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var arr = [ 1, 2, 3, 4 ] : int; 5 | 6 | assert(arr != nil); 7 | assert(nil != arr); 8 | 9 | 0 10 | } 11 | 12 | func main() -> int 13 | { 14 | test(); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample348.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { one, two, three } 3 | 4 | record R { v : A; } 5 | 6 | func getA(b : A) -> R 7 | { 8 | var r = R(b); 9 | r 10 | } 11 | 12 | func main() -> int 13 | { 14 | assert(getA(A::two).v == A::two); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample525.nev: -------------------------------------------------------------------------------- 1 | 2 | func getF() -> (int) -> int 3 | { 4 | let func(i : int) -> int 5 | { 6 | let v = 10 * i; 7 | v |> print(); 8 | v 9 | } 10 | } 11 | 12 | func main() -> int 13 | { 14 | 2 |> getF()(); 15 | 16 | 0 17 | } -------------------------------------------------------------------------------- /sample/sample538.nev: -------------------------------------------------------------------------------- 1 | 2 | func test_range(s : string, r[from..to] : range) -> int 3 | { 4 | for (a in r) { 5 | prints(a + s) 6 | }; 7 | 8 | 0 9 | } 10 | 11 | func main() -> int 12 | { 13 | "aaa\n" |> test_range([1..6]); 14 | 15 | 0 16 | } 17 | -------------------------------------------------------------------------------- /sample/sample625.nev: -------------------------------------------------------------------------------- 1 | 2 | func t1000( a : (int, int) ) -> int 3 | { 4 | prints("func t1000\n"); 5 | 10 6 | } 7 | 8 | func main() -> int 9 | { 10 | let p = (10, 10) : (int, int); 11 | 12 | ( p, ) : ( (int, int) ) |> t1000(); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample140.nev: -------------------------------------------------------------------------------- 1 | 2 | func rodCut( rod : int ) -> int 3 | { 4 | func __rodCut( rod : int ) -> int 5 | { 6 | rod < 10 ? rodCut( rod + 1 ) : 0 7 | }; 8 | __rodCut( rod ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | rodCut( 0 ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample192.nev: -------------------------------------------------------------------------------- 1 | func f(a : int) -> int 2 | { 3 | var t = [ 1, 2, 3, 4, 5 ] : int; 4 | let i = [ 4, 3, 2, 1, 0 ] : int; 5 | 6 | t[i[a]] = 20; 7 | t[i[a]] = 30; 8 | t[i[a]] 9 | } 10 | 11 | func main() -> int 12 | { 13 | f(3) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample483.nev: -------------------------------------------------------------------------------- 1 | 2 | use mfive 3 | 4 | func test() -> int 5 | { 6 | mfive.five(0); 7 | assert(false); 8 | 0 9 | } 10 | catch (division_by_zero) 11 | { 12 | 10 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(test() == 10); 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample314.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | let f1 = let func(a : int) -> int { 2 * a }; 5 | 6 | assert(f1 != nil); 7 | assert(nil != f1); 8 | 9 | 0 10 | } 11 | 12 | func main() -> int 13 | { 14 | test(); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample322.nev: -------------------------------------------------------------------------------- 1 | 2 | record P { 3 | x : int; 4 | y : int; 5 | f : float; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var p = P(10, 20, 30.0); 11 | 12 | print(p.x); 13 | print(p.y); 14 | printf(p.f); 15 | 16 | 0 17 | } 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /sample/sample429.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let v = if (true) 6 | { 7 | 10 8 | } 9 | else 10 | { 11 | 0 12 | }; 13 | 14 | print(v); 15 | assert(v == 10); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample430.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let v = if (false) 6 | { 7 | 10 8 | } 9 | else 10 | { 11 | 0 12 | }; 13 | 14 | print(v); 15 | assert(v == 0); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample482.nev: -------------------------------------------------------------------------------- 1 | 2 | use mthree 3 | 4 | func test() -> int 5 | { 6 | mthree.three(0); 7 | assert(false); 8 | 0 9 | } 10 | catch (division_by_zero) 11 | { 12 | 10 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(test() == 10); 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample18.nev: -------------------------------------------------------------------------------- 1 | 2 | func get(f(float, float) -> float) -> (float, float) -> float 3 | { 4 | f 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert(get(let func min(a : float, b : float) -> float { a < b ? a : b })(130.0, 20.0 - -80.0) == 100.0) 10 | } 11 | 12 | 13 | 14 | -------------------------------------------------------------------------------- /sample/sample222.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let i = 40; 5 | 6 | if (i > 100) 7 | { 8 | print(100) 9 | } 10 | else if (i > 50) 11 | { 12 | print(50) 13 | } 14 | else 15 | { 16 | print(0) 17 | } 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample341.nev: -------------------------------------------------------------------------------- 1 | 2 | record A { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func getA(a : int) -> A 8 | { 9 | if (a == 10) A(10, 20) else A(100, 200) 10 | } 11 | 12 | 13 | func main() -> int 14 | { 15 | assert(getA(110).x == 100); 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample616.nev: -------------------------------------------------------------------------------- 1 | 2 | func set(var i : int) -> int 3 | { 4 | var j = i; 5 | 6 | j = 20; 7 | 8 | 0 9 | } 10 | 11 | func main() -> int 12 | { 13 | var i = 10; 14 | 15 | set(i); 16 | 17 | print(i); 18 | 19 | assert(i == 20); 20 | 21 | 0 22 | } 23 | -------------------------------------------------------------------------------- /sample/sample95.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab(i : int, t[dim1, dim2] : int) -> int 3 | { 4 | print(t[dim1 - 1, dim2 - 1]) 5 | } 6 | 7 | func main() -> int 8 | { 9 | printtab(3, [ [ 10, 20 ], 10 | [ 30, 40 ], 11 | [ 50, 60 ] ] : int) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /sample/sample98.nev: -------------------------------------------------------------------------------- 1 | 2 | func exec( f[dim] : (int) -> int ) -> int 3 | { 4 | f[dim - 1](200) 5 | } 6 | 7 | func main() -> int 8 | { 9 | exec( [ let func X(a : int) -> int { 2 * a }, 10 | let func X(a : int) -> int { 220 + a } ] : (int) -> int ) 11 | } 12 | 13 | 14 | -------------------------------------------------------------------------------- /sample/sample117.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D,D] : int 3 | { 4 | [[ 1, a, 2, 3 ], 5 | [ 4, 5, 6, 7 ], 6 | [ 8, b, 0, c ], 7 | [ 2, 3, 4, 5 ]] : int 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f1(80, 90, 100)[0, 1] == 80) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample130.nev: -------------------------------------------------------------------------------- 1 | 2 | func factorial(n : int) -> int 3 | { 4 | func factrec(n : int, val : int) -> int 5 | { 6 | n == 0 ? val : factrec(n - 1, n * val) 7 | }; 8 | 9 | factrec(n, 1) 10 | } 11 | 12 | func main() -> int 13 | { 14 | factorial(3) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample178.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> float 3 | { 4 | let p = a + b; 5 | func inner(c : float) -> float 6 | { 7 | p * c 8 | }; 9 | 10 | inner(2.0) 11 | } 12 | 13 | func main() -> float 14 | { 15 | outer(3.0, 5.0) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample273.nev: -------------------------------------------------------------------------------- 1 | 2 | func tab(a : int) -> [_] : int 3 | { 4 | [ a, a, a, a ] : int 5 | } 6 | 7 | func main() -> int 8 | { 9 | var a = 12; 10 | var v = {[ 1 ]} : int; 11 | 12 | v = tab(a); 13 | print(v[0]); 14 | 15 | a = 10; 16 | print(v[0]) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample342.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | 9 | func getA(a : int) -> A 10 | { 11 | if (a == 10) A::two else A::three 12 | } 13 | 14 | 15 | func main() -> int 16 | { 17 | assert(getA(10) == A::two); 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample431.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let v = if (true && true) 6 | { 7 | 10 8 | } 9 | else 10 | { 11 | 0 12 | }; 13 | 14 | print(v); 15 | assert(v == 10); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample432.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | let v = if (true || false) 6 | { 7 | 10 8 | } 9 | else 10 | { 11 | 0 12 | }; 13 | 14 | print(v); 15 | assert(v == 10); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample628.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_two(a : float, b : int) -> int 3 | { 4 | prints(a + " " + b + "\n"); 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | let t = (10.0, 20, 30, 40) : (float, int, int, int); 11 | 12 | print_two(t[0], t[1]); 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample_fib_tail_nested.nev: -------------------------------------------------------------------------------- 1 | func fib(n : int) -> int 2 | { 3 | let func fib_h(n : int, a : int, b : int) -> int 4 | { 5 | (n == 0) ? a : (n == 1) ? b : fib_h(n - 1, b, a + b) 6 | } (n, 1, 1) 7 | } 8 | 9 | func main() -> int 10 | { 11 | fib(20) 12 | } 13 | 14 | -------------------------------------------------------------------------------- /sample/sample11.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * Crazy level max 3 | */ 4 | func main() -> bool 5 | { 6 | assert((2 < 1 ? let func min(a : float, b : float) -> float { a < b ? a : b } 7 | : let func max(a : float, b : float) -> float { a > b ? a : b })(10.0, 20.0) == 20.0) 8 | } 9 | 10 | -------------------------------------------------------------------------------- /sample/sample118.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D,D] : int 3 | { 4 | [[ 1, a, 2, 3 ], 5 | [ 4, 5, 6, 7 ], 6 | [ 8, b, 0, c ], 7 | [ 2, 3, 4, 5 ]] : int 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f1(80, 90, 100)[3, 3] == 5) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample182.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(to : int) -> (int) -> int 3 | { 4 | let f = let func rec(start : int) -> int 5 | { 6 | start < to ? { print(start); rec(start + 1) } : 0 7 | }; 8 | 9 | f 10 | } 11 | 12 | func main() -> int 13 | { 14 | outer(10)(0) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample189.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> (float) -> float 3 | { 4 | let p = (a + b) / 2.0; 5 | 6 | let func inner(c : float) -> float 7 | { 8 | c * p 9 | } 10 | } 11 | 12 | func main() -> float 13 | { 14 | outer(3.0, 5.0)(3.0) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample344.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | func getA() -> A 9 | { 10 | var a = A::one; 11 | 12 | a = A::two; 13 | 14 | a 15 | } 16 | 17 | func main() -> int 18 | { 19 | assert(getA() == A::two); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample346.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | record R { 9 | v : A; 10 | } 11 | 12 | func getA(b : A) -> R 13 | { 14 | R(b) 15 | } 16 | 17 | func main() -> int 18 | { 19 | assert(getA(A::two).v == A::two); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample388.nev: -------------------------------------------------------------------------------- 1 | enum E { one } 2 | 3 | func getE(e : E) -> int 4 | { 5 | var v = 1; 6 | 7 | v = match e 8 | { 9 | else -> 4; 10 | }; 11 | 12 | v 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(getE(E::one) == 4); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample389.nev: -------------------------------------------------------------------------------- 1 | enum E { one } 2 | 3 | func getE(e : E) -> int 4 | { 5 | var v = 1; 6 | 7 | v = match e 8 | { 9 | E::one -> 4; 10 | }; 11 | 12 | v 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(getE(E::one) == 4); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample5.nev: -------------------------------------------------------------------------------- 1 | 2 | func deg2rad(deg : float) -> float 3 | { 4 | deg * 3.14159265359 / 180.0 5 | } 6 | 7 | func get_func() -> (float) -> float 8 | { 9 | cos 10 | } 11 | 12 | func main() -> int 13 | { 14 | assertf(get_func()(deg2rad(60.0)) - 0.5, 0.0001) 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /sample/sample602.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var f = 10; 5 | 6 | for (f in [ 10 * x + y | x in [1 .. 4]; y in [ 1 .. 4 ] ] : int) 7 | { 8 | print(f) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func main() -> int 15 | { 16 | test(); 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample606.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func f1(var i : int, j : int) -> int 4 | { 5 | var k = i; 6 | 7 | k = 100; 8 | 9 | i + j 10 | } 11 | 12 | func main() -> int 13 | { 14 | var i = 10; 15 | let j = 20; 16 | 17 | f1(i, j); 18 | 19 | print(i); 20 | 21 | 0 22 | } 23 | -------------------------------------------------------------------------------- /sample/sample626.nev: -------------------------------------------------------------------------------- 1 | 2 | func t1000( a : int, b : int, c : char ) -> int 3 | { 4 | prints("func t1000(" + a + ", " + b + ", " + c + ")\n"); 5 | 10 6 | } 7 | 8 | func main() -> int 9 | { 10 | let p = (10, 20) : (int, int); 11 | 12 | p |> t1000('A'); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/sample629.nev: -------------------------------------------------------------------------------- 1 | 2 | func t1000( a : (int, int) ) -> int 3 | { 4 | prints("func t1000 " + a[0] + " " + a[1] + "\n"); 5 | 10 6 | } 7 | 8 | func main() -> int 9 | { 10 | let p = (10, 10) : (int, int); 11 | 12 | ( p, ) : ( (int, int) ) |> t1000(); 13 | 14 | 0 15 | } 16 | -------------------------------------------------------------------------------- /sample/lib/mtwo.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | module mtwo { 4 | 5 | enum E { ONE, TWO, THREE } 6 | enum R { A { i : int; }, B { i : int; } } 7 | 8 | func two() -> E 9 | { 10 | E::TWO 11 | } 12 | 13 | func twoB() -> R 14 | { 15 | R::A(100) 16 | } 17 | 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample181.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D] : () -> int 3 | { 4 | [ 5 | let func () -> int { a + b + c }, 6 | let func () -> int { a + b - c } 7 | ] : () -> int 8 | } 9 | 10 | func main() -> int 11 | { 12 | f1(80, 90, 100)[1]() 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample21nok.nev: -------------------------------------------------------------------------------- 1 | func calc(n : int, coeff : int) -> int 2 | { 3 | func fib(n : int) -> int 4 | { 5 | ((n == 0) ? 1 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2)) * coeff 6 | }; 7 | 8 | fib(n) 9 | } 10 | func main() -> int 11 | { 12 | calc(7, 2) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample230.nev: -------------------------------------------------------------------------------- 1 | 2 | func ass(var tab[_] : int) -> int 3 | { 4 | tab = [ 10, 20, 30, 40 ] : int; 5 | 0 6 | } 7 | 8 | func main() -> int 9 | { 10 | var tab = [ 1, 2, 3, 4 ] : int; 11 | 12 | print(tab[0]); 13 | 14 | ass(tab); 15 | 16 | print(tab[0]) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample363.nev: -------------------------------------------------------------------------------- 1 | 2 | func sinhf(x : float) -> float 3 | { 4 | 2.0 * x 5 | } 6 | 7 | func main() -> int 8 | { 9 | let v1 = sinhf(1.0); 10 | let sinhf = let func (x : float) -> float { 3.0 * x }; 11 | 12 | printf(v1); 13 | printf(sinhf(2.0)); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample131.nev: -------------------------------------------------------------------------------- 1 | 2 | func power(a : int, n : int) -> int 3 | { 4 | func powrec(a : int, n : int, val : int) -> int 5 | { 6 | n == 0 ? val : powrec(a, n - 1, a * val) 7 | }; 8 | 9 | powrec(a, n, 1) 10 | } 11 | 12 | func main() -> int 13 | { 14 | power(2, 5) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample185.nev: -------------------------------------------------------------------------------- 1 | func rec(i : int) -> int 2 | { 3 | print(i) > 0 4 | ? 5 | { 6 | print(9999); 7 | print(8888); 8 | rec(i - 1) 9 | } 10 | : 11 | 0 12 | } 13 | 14 | func main() -> int 15 | { 16 | rec(5) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample345.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | func getA(b : A) -> A 9 | { 10 | var a = A::one; 11 | 12 | a = b; 13 | 14 | a 15 | } 16 | 17 | func main() -> int 18 | { 19 | assert(getA(A::two) == A::two); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample367.nev: -------------------------------------------------------------------------------- 1 | 2 | func test(arr[D] : int) -> () -> int 3 | { 4 | func getD() -> int { 5 | D 6 | }; 7 | 8 | getD 9 | } 10 | 11 | func main() -> int 12 | { 13 | let dim = test([1, 2, 3, 4, 5] : int); 14 | 15 | assert(dim() == 5); 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample662.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | a : int; 5 | b : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var r1 = R(10, 20); 11 | let r2 = r1; 12 | 13 | r2.a = 100; 14 | r2.b = 200; 15 | 16 | assert(r1.a == 100); 17 | assert(r1.b == 200); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample664.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | a : int; 5 | b : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | let r1 = R(10, 20); 11 | let r2 = r1; 12 | 13 | r2.a = 100; 14 | r2.b = 200; 15 | 16 | assert(r1.a == 100); 17 | assert(r1.b == 200); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample665.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | a : int; 5 | b : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | let r1 = R(10, 20); 11 | var r2 = r1; 12 | 13 | r2.a = 100; 14 | r2.b = 200; 15 | 16 | assert(r1.a == 100); 17 | assert(r1.b == 200); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample94.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, tab[FD1, FD2] : int) -> int 3 | { 4 | 2 * FD1 * FD2 5 | } 6 | 7 | func f2(tab2[D1, D2] : int) -> int 8 | { 9 | f1(10, 20, tab2) 10 | } 11 | 12 | func main() -> int 13 | { 14 | f2([[ 1, 2 ], 15 | [ 3, 4 ]] : int) 16 | } 17 | 18 | 19 | -------------------------------------------------------------------------------- /sample/sample_man6.nev: -------------------------------------------------------------------------------- 1 | 2 | func degrees(conv(float) -> float, degree : float) -> float 3 | { 4 | conv(degree) 5 | } 6 | 7 | func main() -> float 8 | { 9 | degrees(let func rea2cel(d : float) -> float 10 | { 11 | d * 4.0 / 5.0 12 | }, 100.0) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample30.nev: -------------------------------------------------------------------------------- 1 | 2 | func one(a : float, b : float, c : float) -> float 3 | { 4 | a + b + c 5 | } 6 | 7 | func two() -> float 8 | { 9 | 10.0 + 20.0 + 100.0 10 | } 11 | 12 | func main() -> float 13 | { 14 | two() + one(10.0, 0.0, 0.0) + two() + one(1.0, 2.0, 3.0) 15 | } 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /sample/sample356.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | func main() -> int 5 | { 6 | var i = 0; 7 | var j = 0; 8 | 9 | while (i < 10) 10 | while (j < 10) 11 | { 12 | print(i + j); 13 | i = i + 1; 14 | j = j + 1 15 | }; 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample433.nev: -------------------------------------------------------------------------------- 1 | 2 | func boolexpr(a : bool, b : bool) -> bool 3 | { 4 | a || b 5 | } 6 | 7 | func main() -> bool 8 | { 9 | assert(boolexpr(true, true)); 10 | assert(boolexpr(true, false)); 11 | assert(boolexpr(false, true)); 12 | assert(!boolexpr(false, false)) 13 | } 14 | 15 | 16 | -------------------------------------------------------------------------------- /sample/sample526.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func p( a[B..E] : range ) -> int 4 | { 5 | prints("range from " + B + " to " + E + "\n"); 6 | 7 | for (e in a) 8 | { 9 | e |> print() 10 | }; 11 | 12 | 0 13 | } 14 | 15 | func main() -> int 16 | { 17 | [1 .. 10] |> p(); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample_fib_tail_ret.nev: -------------------------------------------------------------------------------- 1 | func get_fib() -> (int, int, int) -> int 2 | { 3 | func fib(n : int, a : int, b : int) -> int 4 | { 5 | (n == 0) ? a : (n == 1) ? b : fib(n - 1, b, a + b) 6 | }; 7 | fib 8 | } 9 | 10 | func main() -> int 11 | { 12 | get_fib()(20, 1, 1) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample_man10.nev: -------------------------------------------------------------------------------- 1 | 2 | func dir_deg(d : int) -> (float) -> float 3 | { 4 | d == 0 ? let func fah2cel(f : float) -> float { (f - 32.0) / 1.8 } 5 | : let func cel2fah(c : float) -> float { c * 1.8 + 32.0 } 6 | } 7 | 8 | func main() -> float 9 | { 10 | dir_deg(0)(100.0) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample172.nev: -------------------------------------------------------------------------------- 1 | 2 | func area(a : float, b : float, c : float) -> float 3 | { 4 | let p = (a + b + c) / 2.0; 5 | func coeff() -> float { 100.0 }; 6 | 7 | coeff() * sqrt(p * (p - a) * (p - b) * (p - c)) 8 | } 9 | 10 | func main() -> float 11 | { 12 | area(3.0, 4.0, 5.0) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample174.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> (float) -> float 3 | { 4 | func inner(c : float) -> float 5 | { 6 | let p = (a + b) / 2.0; 7 | c * p 8 | }; 9 | 10 | inner 11 | } 12 | 13 | func main() -> float 14 | { 15 | outer(3.0, 5.0)(3.0) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample198.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> var [_] : int 2 | { 3 | var t2 = i * [ 11, 12, 13, 14 ] : int; 4 | t2 5 | } 6 | 7 | func main() -> int 8 | { 9 | var t = f(5); 10 | 11 | t[0] = 120; 12 | 13 | print(t[0]); 14 | print(t[1]); 15 | print(t[2]); 16 | print(t[3]) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample347.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A { 3 | one, 4 | two, 5 | three 6 | } 7 | 8 | record R { 9 | v : A; 10 | } 11 | 12 | func getA(b : A) -> R 13 | { 14 | var r = R(b); 15 | r 16 | } 17 | 18 | func main() -> int 19 | { 20 | assert(getA(A::two).v == A::two); 21 | 22 | 0 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample354.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | x : int; 5 | r : R; 6 | } 7 | 8 | func getR() -> R 9 | { 10 | R(110, R(130, R)) 11 | } 12 | 13 | func main() -> int 14 | { 15 | let r = getR(); 16 | 17 | assert(r.x == 110); 18 | assert(r.r.x == 130); 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample466.nev: -------------------------------------------------------------------------------- 1 | 2 | let B = 2; 3 | let A = 2 + 2 * B; 4 | let xyz = let func (i : int) -> int { A + B + i }; 5 | 6 | func boo(a : int) -> int 7 | { 8 | print(a) 9 | } 10 | 11 | func main() -> int 12 | { 13 | let a = A + B; 14 | let b = 130; 15 | 16 | boo(xyz(b)); 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample637.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var C = 1000; 5 | var a = [ [ 1, 2, 3, 4 ], 6 | [ 5, 6, 7, 8 ] ] : int; 7 | 8 | print(a[ { var x = 100; var y = 10; assert(C + x + y == 1110); 0 }, { var x = 10; var y = 1; assert(C + x + y == 1011); 0 } ]); 9 | 10 | 0 11 | } 12 | -------------------------------------------------------------------------------- /sample/sample663.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | let a : int; 5 | let b : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var r1 = R(10, 20); 11 | let r2 = r1; 12 | 13 | r2.a = 100; 14 | r2.b = 200; 15 | 16 | assert(r1.a == 100); 17 | assert(r1.b == 200); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample91.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D] : () -> int 3 | { 4 | [ 5 | let func f1() -> int { a + b + c }, 6 | let func f2() -> int { a + b - c } 7 | ] : () -> int 8 | } 9 | 10 | func main() -> bool 11 | { 12 | assert(f1(80, 90, 100)[1]() == 70) 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample96.nev: -------------------------------------------------------------------------------- 1 | 2 | func tprint(v : int, o : int) -> int 3 | { 4 | print(v) 5 | } 6 | 7 | func enumtab(i : int, t[dim] : int) -> int 8 | { 9 | i < dim ? tprint(t[i], enumtab(i + 1, t)) : 0 10 | } 11 | 12 | func main() -> int 13 | { 14 | enumtab(0, [ 10, 20, 30, 40, 50, 60 ] : int) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample113.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[row] : [D, D] : int) -> int 3 | { 4 | tab[row - 1][0, 0] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | call( [ {[10, 10]} : int, 10 | {[20, 20]} : int ] : [D, D] : int ) 11 | } 12 | 13 | func main() -> bool 14 | { 15 | assert(f1(8) == 0) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample16.nev: -------------------------------------------------------------------------------- 1 | func min(a : float, b : float) -> float 2 | { 3 | a < b ? a + a : b + b 4 | } 5 | 6 | func execute(a : float, b : float, f1(float, float) -> float) -> float 7 | { 8 | f1(a, b) 9 | } 10 | 11 | func main() -> bool 12 | { 13 | assert(execute(15.0, 20.0, min) == 30.0) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample169.nev: -------------------------------------------------------------------------------- 1 | 2 | func one(a : int, b : int, c : int) -> int 3 | { 4 | let d = a + b + c + 10; 5 | let e = a + b + c + 20; 6 | let f = a + b + c + 30; 7 | 8 | print(d); 9 | print(e); 10 | print(f) 11 | } 12 | 13 | func main() -> int 14 | { 15 | one(10, 20, 30) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample173.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> (float) -> float 3 | { 4 | let p = (a + b) / 2.0; 5 | 6 | func inner(c : float) -> float 7 | { 8 | c * p 9 | }; 10 | 11 | inner 12 | } 13 | 14 | func main() -> float 15 | { 16 | outer(3.0, 5.0)(3.0) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample298.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var i = 0; 6 | var j = 0; 7 | 8 | while (i < 10) 9 | { 10 | for (j = 0; j < 10; j = j + 1) 11 | prints(i + " " + j + "\n"); 12 | 13 | i = i + 1 14 | }; 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample323.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var p = 0; 6 | 7 | print(print(print(10 / p))); 8 | print(20 / p); 9 | 10 | assert(false); 11 | 12 | 0 13 | } 14 | catch (division_by_zero) 15 | { 16 | prints("caught division_by_zero\n"); 17 | -111 18 | } 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /sample/sample398.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some { value : int; }, None } 3 | 4 | func main() -> int 5 | { 6 | let o = Optional::Some(10); 7 | 8 | match o 9 | { 10 | Optional::Some(value) -> print(value); 11 | Optional::None -> print(10); 12 | }; 13 | 14 | 0 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample519.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E 3 | { 4 | ONE = 1, 5 | TWO = 1 <<< 1, 6 | FOUR = 1 <<< 2, 7 | EIGHT = 1 <<< 3 8 | } 9 | 10 | func main() -> int 11 | { 12 | assert(E::ONE == 1); 13 | assert(E::TWO == 2); 14 | assert(E::FOUR == 4); 15 | assert(E::EIGHT == 8); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample110.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[row] : [D] : int) -> int 3 | { 4 | tab[row - 1][1] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | call([ [ 9, 8, 7, 6, 5 ] : int, 10 | [ 9, 7, 5 ] : int ] : [_] : int) 11 | } 12 | 13 | func main() -> bool 14 | { 15 | assert(f1(10) == 7) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample13.nev: -------------------------------------------------------------------------------- 1 | 2 | func get_func(glob1 : float) -> (float, float) -> float 3 | { 4 | func min(a : float, b : float) -> float 5 | { 6 | a < b ? glob1 * a : glob1 * b 7 | }; 8 | min 9 | } 10 | 11 | func main() -> bool 12 | { 13 | assert(get_func(20.0)(15.0, 30.0) == 300.0) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample188.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> (float) -> float 3 | { 4 | let p = (a + b) / 2.0; 5 | 6 | let func inner(c : float) -> float 7 | { 8 | let q = p + 1.0; 9 | c * q 10 | } 11 | } 12 | 13 | func main() -> float 14 | { 15 | outer(3.0, 5.0)(3.0) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample195.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> (int) -> int 2 | { 3 | let a = 2; 4 | let b = i * i * i; 5 | var f1 = let func(a : int) -> int { a * a }; 6 | var f2 = let func(b : int) -> int { b + b }; 7 | 8 | f1 = f2; 9 | f1 10 | } 11 | 12 | func main() -> int 13 | { 14 | f(5)(20) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample315.nev: -------------------------------------------------------------------------------- 1 | 2 | record Rec { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func test() -> int 8 | { 9 | var r1 = Rec(100, 200); 10 | 11 | assert(r1 != nil); 12 | assert(nil != r1); 13 | 14 | 0 15 | } 16 | 17 | func main() -> int 18 | { 19 | test(); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample328.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t = {[ 10 ]} : string; 5 | 6 | assert(t[0] == nil); 7 | assert(nil == t[0]); 8 | 9 | prints(t[0]); 10 | assert(false); 11 | 12 | 0 13 | } 14 | catch (nil_pointer) 15 | { 16 | prints("nil_pointer\n"); 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample641.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(var a : int, b : int) -> int 3 | { 4 | var c = a; 5 | let d = b; 6 | 7 | c = 1110 8 | } 9 | 10 | func main() -> int 11 | { 12 | var a = 1; 13 | let b = 2; 14 | 15 | f1(a, b + 20); 16 | 17 | prints("a = " + a + " b = " + b + "\n"); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample_man8.nev: -------------------------------------------------------------------------------- 1 | 2 | func dir_deg(d : int, degree : float) -> float 3 | { 4 | (d == 0 ? let func fah2cel(f : float) -> float { (f - 32.0) / 1.8 } 5 | : let func cel2fah(c : float) -> float { c * 1.8 + 32.0 })(degree) 6 | } 7 | 8 | func main() -> float 9 | { 10 | dir_deg(1, 100.0) 11 | } 12 | 13 | -------------------------------------------------------------------------------- /sample/sample111.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[row, col] : int) -> int 3 | { 4 | tab[row - 1, col - 1] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | call( [[ a, 2, 3 ], 10 | [ 4, a, 6 ], 11 | [ 9, 8, a + 1 ]] : int) 12 | } 13 | 14 | func main() -> bool 15 | { 16 | assert(f1(10) == 11) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample196.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> [_] : int 2 | { 3 | var t1 = [ 1, 2, 3 ] : int; 4 | var t2 = [ 11, 12, 13, 14 ] : int; 5 | var t3 = [ 111, 112, 113, 114 ] : int; 6 | 7 | t1 = t3; 8 | t2 = t3; 9 | t1 10 | } 11 | 12 | func main() -> bool 13 | { 14 | assert(f(5)[1] == 112) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample325.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var p = 0; 5 | 6 | 10 / p; 7 | 20 / p; 8 | 30 / p; 9 | 10 | 0 11 | } 12 | catch (division_by_zero) 13 | { 14 | prints("caught nil_pointer\n"); 15 | -111 16 | } 17 | 18 | func main() -> int 19 | { 20 | test() 21 | } 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /sample/sample330.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t = {[ 10 ]} : [_] : int; 5 | 6 | assert(t[0] == nil); 7 | assert(nil == t[0]); 8 | 9 | print(t[0][0]); 10 | assert(false); 11 | 12 | 0 13 | } 14 | catch (nil_pointer) 15 | { 16 | prints("nil_pointer\n"); 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample447.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr( [ from .. to ] : range ) -> int 3 | { 4 | prints("[" + from + ".." + to + "]\n"); 5 | 6 | assert(from == 15); 7 | assert(to == 20); 8 | 9 | 0 10 | } 11 | 12 | func main() -> int 13 | { 14 | let r1 = [10..100][0..10][5..10]; 15 | 16 | pr(r1); 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample622.nev: -------------------------------------------------------------------------------- 1 | 2 | func t ( (int, (int, char, float)) ) -> (int, (string) -> int) 3 | { 4 | (10, let func lambda (a : string) -> int { 20 }) : (int, (string) -> int) 5 | } 6 | 7 | func main() -> int 8 | { 9 | t( (10, (30, 'A', 1.0) : (int, char, float)) : (int, (int, char, float)) ); 10 | 11 | 0 12 | } 13 | -------------------------------------------------------------------------------- /sample/sample624.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | a : (int, int); 5 | b : (int, float); 6 | } 7 | 8 | func t1000( a : (int, int) ) -> int 9 | { 10 | 10 11 | } 12 | 13 | func main() -> int 14 | { 15 | let r = R( (10, 10) : (int, int), (20, 20.0) : (int, float) ); 16 | 17 | t1000(r.a); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample634.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var t1 = (10, 10.0) : (int, float); 6 | var t2 = (20, 20.0) : (int, float); 7 | 8 | t1 = t2; 9 | 10 | assert(t1[0] == 20); 11 | assert(t1[1] == 20.0); 12 | 13 | assert(t2[0 + 0] == 20); 14 | assert(t2[1 * 1] == 20.0); 15 | 16 | 0 17 | } -------------------------------------------------------------------------------- /sample/sample15.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * Crazy level max 3 | */ 4 | func min(a : float, b : float) -> float 5 | { 6 | a < b ? a : b 7 | } 8 | 9 | func max(a : float, b : float) -> float 10 | { 11 | a > b ? a : b 12 | } 13 | 14 | func main() -> bool 15 | { 16 | assert((1.0 < 2.0 ? min : max)(10.0, 20.0) == 10.0) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample260.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1() -> string 3 | { 4 | prints("test test test very very\nlong long string\nwhich should be reallocated\n") 5 | } 6 | 7 | func f2(txt : string) -> string 8 | { 9 | prints(txt) 10 | } 11 | 12 | func main() -> int 13 | { 14 | f1(); 15 | f2("to jest string\n"); 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample329.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t = {[ 10 ]} : (int) -> int; 5 | 6 | assert(t[0] == nil); 7 | assert(nil == t[0]); 8 | 9 | print(t[0](10)); 10 | assert(false); 11 | 12 | 0 13 | } 14 | catch (nil_pointer) 15 | { 16 | prints("nil_pointer\n"); 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample509.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { ZERO, ONE, TWO, THREE } 3 | 4 | func check(e : int, v : int) -> bool 5 | { 6 | assert(e == v) 7 | } 8 | 9 | func main() -> int 10 | { 11 | let e = [ E::THREE, E::TWO, E::ONE ] : E; 12 | 13 | check(e[0], 3); 14 | check(e[1], 2); 15 | check(e[2], 1); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample645.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | a : int; 5 | b : int; 6 | } 7 | 8 | func f1(var r : R) -> var int 9 | { 10 | r.a 11 | } 12 | 13 | func main() -> int 14 | { 15 | var r1 = R(10, 20); 16 | 17 | f1(r1) = 100; 18 | 19 | prints("r.a = " + r1.a + " r.b = " + r1.b + "\n"); 20 | 21 | 0 22 | } 23 | -------------------------------------------------------------------------------- /sample/sample661.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1([ from .. to ] : range) -> int 3 | { 4 | from = 10; 5 | to = 20; 6 | 0 7 | } 8 | 9 | func main() -> int 10 | { 11 | var from = 0; 12 | var to = 0; 13 | 14 | f1( [ from .. to ] ); 15 | 16 | assert(from == 10); 17 | assert(to == 20); 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample90.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[row] : [D] : int) -> int 3 | { 4 | tab[row - 1][1] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | call([ [ 9, 8, 7, 6, 5 ] : int, 10 | [ 9, 7, 5 ] : int ] : [_] : int) 11 | } 12 | 13 | func main() -> bool 14 | { 15 | assert(f1(10) == 7) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample_fib.nev: -------------------------------------------------------------------------------- 1 | func fibL(n : long) -> long 2 | { 3 | (n == 0L) ? 0L : (n == 1L) ? 1L : fibL(n - 1L) + fibL(n - 2L) 4 | } 5 | 6 | func fib(n : int) -> int 7 | { 8 | (n == 0) ? 0 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2) 9 | } 10 | 11 | func main() -> int 12 | { 13 | print(fib(14)); 14 | 15 | 0 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample101.nev: -------------------------------------------------------------------------------- 1 | 2 | func tsum( t[elems] : int) -> int 3 | { 4 | func __tsum( sum : int, i : int, t[elems] : int ) -> int 5 | { 6 | i < elems ? __tsum( sum + t[i], i + 1, t ) : sum 7 | }; 8 | __tsum(0, 0, t) 9 | } 10 | 11 | 12 | func main() -> int 13 | { 14 | tsum( [ 10, 20, 30, 40, 50, 60 ] : int ) 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /sample/sample25.nev: -------------------------------------------------------------------------------- 1 | func A(n : float) -> float 2 | { 3 | (n == 1.0) ? B(1.0) : 40.0 4 | } 5 | 6 | func B(n : float) -> float 7 | { 8 | (n == 1.0) ? A(10.0) : 12.0 9 | } 10 | 11 | func C(n : float) -> float 12 | { 13 | A(n) 14 | } 15 | 16 | func main() -> bool 17 | { 18 | assert(C(1.0) == 40.0) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample324.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var p = 0; 5 | 6 | print(print(print(10 / p))); 7 | print(20 / p); 8 | 9 | 0 10 | } 11 | catch (division_by_zero) 12 | { 13 | prints("caught nil_pointer\n"); 14 | -111 15 | } 16 | 17 | func main() -> int 18 | { 19 | test() 20 | } 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /sample/sample40.nev: -------------------------------------------------------------------------------- 1 | 2 | func sub(a : int, b : int) -> int 3 | { 4 | a - b 5 | } 6 | 7 | func add(a : int, b : int) -> int 8 | { 9 | a + b 10 | } 11 | 12 | func execute(f(int, int) -> int, a : int, b : int) -> int 13 | { 14 | f(a, b) 15 | } 16 | 17 | func main() -> int 18 | { 19 | execute(add, 12, 10) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample481.nev: -------------------------------------------------------------------------------- 1 | 2 | use mtwo 3 | 4 | func main() -> int 5 | { 6 | match (mtwo.two()) 7 | { 8 | mtwo.E::ONE -> 1; 9 | mtwo.E::TWO -> 2; 10 | mtwo.E::THREE -> 3; 11 | }; 12 | 13 | match (mtwo.twoB()) 14 | { 15 | mtwo.R::A(i) -> i; 16 | mtwo.R::B(i) -> i; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample512.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | enum E { ONE, TWO, THREE } 4 | 5 | let e = E::ONE; 6 | 7 | func getE(e : E) -> int 8 | { 9 | e 10 | } 11 | 12 | func main() -> int 13 | { 14 | assert(getE(e) == 0); 15 | assert(getE(E::ONE) == 0); 16 | assert(getE(E::TWO) == 1); 17 | assert(getE(E::THREE) == 2); 18 | 19 | 0 20 | } 21 | -------------------------------------------------------------------------------- /sample/sample102.nev: -------------------------------------------------------------------------------- 1 | 2 | func tprint( t[elems] : int ) -> int 3 | { 4 | func __tprint( val : int, i : int, t[elems] : int ) -> int 5 | { 6 | i < elems - 1 ? __tprint( print(t[i]), i + 1, t ) : t[i] 7 | }; 8 | __tprint(t[0], 0, t) 9 | } 10 | 11 | func main() -> int 12 | { 13 | tprint( [ 10, 20, 30, 40, 50, 60 ] : int ) 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /sample/sample150.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : int ) -> int 3 | { 4 | func __print( i : int, tab[n] : int, val : int ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, print(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( 2 * [ 3, 5, 7, 9 ] : int ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample175.nev: -------------------------------------------------------------------------------- 1 | 2 | func outer(a : float, b : float) -> (float) -> float 3 | { 4 | let p = (a + b) / 2.0; 5 | 6 | func inner(c : float) -> float 7 | { 8 | let q = p + 1.0; 9 | c * q 10 | }; 11 | 12 | inner 13 | } 14 | 15 | func main() -> float 16 | { 17 | outer(3.0, 5.0)(3.0) 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample352.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | enum E { one, two, three, four } 4 | 5 | func main() -> int 6 | { 7 | var t = {[ 10 ]} : E; 8 | 9 | t[0] = E::one; 10 | t[1] = E::two; 11 | t[2] = E::three; 12 | 13 | assert(t[0] == E::one); 14 | assert(t[1] == E::two); 15 | assert(t[2] == E::three); 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample435.nev: -------------------------------------------------------------------------------- 1 | 2 | record Bools 3 | { 4 | a : bool; 5 | b : bool; 6 | } 7 | 8 | func calc(b : Bools) -> int 9 | { 10 | assert(b.a == true); 11 | assert(b.b == false); 12 | 0 13 | } 14 | 15 | func main() -> int 16 | { 17 | let b = Bools(true, false); 18 | 19 | calc(b); 20 | 21 | 0 22 | } 23 | 24 | 25 | -------------------------------------------------------------------------------- /sample/sample155.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : int ) -> int 3 | { 4 | func __print( i : int, tab[n] : int, val : int ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, print(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( - [ 1, -2, 3, -4, 5, -6 ] : int ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample197.nev: -------------------------------------------------------------------------------- 1 | func f(i : int) -> (int) -> int 2 | { 3 | var f1 = let func(a : int) -> int { a * a }; 4 | var f2 = let func(b : int) -> int { b + b }; 5 | var f3 = let func(c : int) -> int { i * i }; 6 | 7 | f1 = f3; 8 | f2 = f3; 9 | f1 10 | } 11 | 12 | func main() -> int 13 | { 14 | f(5)(20) 15 | } 16 | 17 | -------------------------------------------------------------------------------- /sample/sample201.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | var t1 = [ 1, 2, 3, 4, 5 ] : int; 7 | var t2 = [ 1, 2, 3, 4, 5, 6, 7, 8 ] : int; 8 | var t3 = [ 1, 2 ] : int; 9 | 10 | i < 10 ? { t2 = t1; t3 = t1; loop(i + 1) } : 10 11 | }; 12 | 13 | loop(0) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample319.nev: -------------------------------------------------------------------------------- 1 | 2 | record Rec { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func test() -> int 8 | { 9 | var r1 = Rec(8, 9); 10 | 11 | r1 = nil; 12 | 13 | assert(r1 == nil); 14 | assert(nil == r1); 15 | 16 | 0 17 | } 18 | 19 | func main() -> int 20 | { 21 | test(); 22 | 23 | 0 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample399.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some { value : int; }, None } 3 | 4 | func calc() -> Optional 5 | { 6 | Optional::Some(10) 7 | } 8 | 9 | func main() -> int 10 | { 11 | match calc() 12 | { 13 | Optional::Some(value) -> print(value); 14 | Optional::None -> print(0); 15 | }; 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample522.nev: -------------------------------------------------------------------------------- 1 | 2 | func one() -> int 3 | { 4 | prints("one "); 5 | 1 6 | } 7 | 8 | func two() -> int 9 | { 10 | prints("two "); 11 | 2 12 | } 13 | 14 | func three() -> int 15 | { 16 | prints("three "); 17 | 3 18 | } 19 | 20 | func main() -> int 21 | { 22 | print(one() + two() * three()); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample530.nev: -------------------------------------------------------------------------------- 1 | 2 | func inc(i : int) -> int 3 | { 4 | i + 1 5 | } 6 | 7 | func main() -> int 8 | { 9 | let a = true; 10 | let b = a == true ? inc(0 + 0) + 10 : inc(1 + 1) + 10; 11 | let c = a == true ? (0 + 0) |> inc() + 10 : (1 + 1) |> inc() + 10; 12 | 13 | assert(b == 11); 14 | assert(c == 11); 15 | 16 | 0 17 | } 18 | -------------------------------------------------------------------------------- /sample/sample686.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; }, Wsg } 3 | 4 | func main() -> int 5 | { 6 | let r = Result::Ok(12); 7 | 8 | if let (Result::Ok(value) = r) 9 | { 10 | print(r) 11 | } 12 | else 13 | { 14 | assert(false); 15 | 0 16 | } = 12; 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample8.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * more crazy find with never 3 | */ 4 | func min(a : float, b : float) -> float 5 | { 6 | a < b ? a : b 7 | } 8 | 9 | func max(a : float, b : float) -> float 10 | { 11 | a > b ? a : b 12 | } 13 | 14 | func main() -> bool 15 | { 16 | assert(((110 != 100) ? min : max)(10.0, 20.0) == 10.0) 17 | } 18 | 19 | 20 | -------------------------------------------------------------------------------- /sample/sample_even_odd.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func isOdd(n : int) -> bool 4 | { 5 | n % 2 == 1 6 | } 7 | 8 | func isEven(n : int) -> bool 9 | { 10 | n % 2 == 0 11 | } 12 | 13 | func main() -> int 14 | { 15 | printb(isOdd(1)); 16 | printb(isOdd(2)); 17 | printb(isEven(1)); 18 | printb(isEven(2)); 19 | 20 | 0 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /sample/sample100.nev: -------------------------------------------------------------------------------- 1 | 2 | func tmin( t[elems] : int ) -> int 3 | { 4 | func __tmin( min : int, i : int, t[elems] : int ) -> int 5 | { 6 | i < elems ? __tmin( t[i] < min ? t[i] : min, i + 1, t ) : min 7 | }; 8 | __tmin(t[0], 0, t) 9 | } 10 | 11 | func main() -> int 12 | { 13 | tmin( [ 60, 20, 10, 30, 50, 40, 80, 90, 100 ] : int ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample122.nev: -------------------------------------------------------------------------------- 1 | 2 | func call(tab[D1, D2] : int) -> int 3 | { 4 | tab[0, 0] 5 | } 6 | 7 | func f1(a : int) -> int 8 | { 9 | var t = [ {[10, 15]} : int, 10 | {[20, 25]} : int ] : [D, D] : int; 11 | t[1][0,0] = 122; 12 | call( t[1] ) 13 | } 14 | 15 | func main() -> bool 16 | { 17 | assert(f1(8) == 122) 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample151.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : int ) -> int 3 | { 4 | func __print( i : int, tab[n] : int, val : int ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, print(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( [ 1, 2, 4 ] : int + [ 3, 4, 3 ] : int ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample157.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : int ) -> int 3 | { 4 | func __print( i : int, tab[n] : int, val : int ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, print(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( [ 5, 6, 3 ] : int - [ 1, 2, 3 ] : int ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample390.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four, five, six } 3 | 4 | func callE(i : int) -> int 5 | { 6 | assert(i == 10); 7 | 0 8 | } 9 | 10 | func main() -> int 11 | { 12 | let e = E::one; 13 | 14 | callE(match(e) { 15 | E::one -> 10; 16 | else -> 20; 17 | }); 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample510.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { FROM = 0, TO = 4 } 3 | 4 | let t = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] : int; 5 | 6 | func main() -> int 7 | { 8 | let a = t[E::FROM .. E::TO]; 9 | 10 | assert(t[0] == 1); 11 | assert(t[1] == 2); 12 | assert(t[2] == 3); 13 | assert(t[3] == 4); 14 | assert(t[4] == 5); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample_man3.nev: -------------------------------------------------------------------------------- 1 | 2 | func fah2cel(f : float) -> float 3 | { 4 | (f - 32.0) / 1.8 5 | } 6 | 7 | func cel2fah(c : float) -> float 8 | { 9 | c * 1.8 + 32.0 10 | } 11 | 12 | func dir_deg(d : int) -> (float) -> float 13 | { 14 | d == 0 ? fah2cel : cel2fah 15 | } 16 | 17 | func main() -> float 18 | { 19 | dir_deg(1)(100.0) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample_reverse.nev: -------------------------------------------------------------------------------- 1 | 2 | func reverse(prog : string) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = length(prog) - 1; i >= 0; i = i - 1) 7 | { 8 | printc(prog[i]) 9 | }; 10 | 11 | prints("\n"); 12 | 13 | 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | reverse("Hello World!"); 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample245.nev: -------------------------------------------------------------------------------- 1 | func one(d : int) -> int 2 | { 3 | let f = let func two(d : int) -> int 4 | { 5 | 12 / d 6 | } 7 | catch (division_by_zero) 8 | { 9 | 12 10 | }; 11 | f(0) 12 | } 13 | 14 | func main() -> bool 15 | { 16 | assert(one(0) == 12) 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample270.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_vector(v[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | prints(v[i] + " ") 9 | }; 10 | prints("\n"); 11 | 12 | 0 13 | } 14 | 15 | func main() -> int 16 | { 17 | let a = [ 1, 2, 3, 4, 5 ] : int; 18 | print_vector(a); 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample327.nev: -------------------------------------------------------------------------------- 1 | 2 | record P { 3 | x : int; 4 | y : int; 5 | print(p : P) -> int; 6 | } 7 | 8 | func pretty_P(p : P) -> int 9 | { 10 | prints("[" + p.x + ", " + p.y + "]\n"); 11 | 0 12 | } 13 | 14 | func main() -> int 15 | { 16 | var p = P(10, 20, pretty_P); 17 | 18 | p.print(p); 19 | 20 | 0 21 | } 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /sample/sample331.nev: -------------------------------------------------------------------------------- 1 | 2 | record P { 3 | x : int; 4 | } 5 | 6 | func main() -> int 7 | { 8 | var t = {[ 10 ]} : P; 9 | 10 | assert(t[0] == nil); 11 | assert(nil == t[0]); 12 | 13 | print(t[0].x); 14 | assert(false); 15 | 16 | 0 17 | } 18 | catch (nil_pointer) 19 | { 20 | prints("nil_pointer\n"); 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample439.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Option { Some { value : int; }, None } 3 | 4 | func main() -> int 5 | { 6 | var o = {[ 2 ]} : Option; 7 | let p = [ Option::Some(10), Option::None ] : Option; 8 | 9 | o[0] = Option::Some(10); 10 | o[1] = Option::None; 11 | 12 | o[0] = p[0]; 13 | o[1] = p[1]; 14 | 15 | 0 16 | } 17 | 18 | 19 | -------------------------------------------------------------------------------- /sample/sample450.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let a = [ 1, 2, 3, 4, 5, 6 ] : int; 5 | let s = a[5 .. 1]; 6 | 7 | for (i in s) 8 | { 9 | print(i) 10 | }; 11 | 12 | assert(s[0] == 6); 13 | assert(s[1] == 5); 14 | assert(s[2] == 4); 15 | assert(s[3] == 3); 16 | assert(s[4] == 2); 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample532.nev: -------------------------------------------------------------------------------- 1 | func compose(f(i : int) -> int, g(i : int) -> int) -> (int) -> int 2 | { 3 | let func (i : int) -> int { f(g(i)) } 4 | } 5 | 6 | func dec(i : int) -> int { 10 * i } 7 | 8 | func succ(i : int) -> int { i + 1 } 9 | 10 | func main() -> int 11 | { 12 | let h = compose(dec, succ); 13 | 14 | print(h(1)); 15 | 16 | 0 17 | } 18 | -------------------------------------------------------------------------------- /sample/sample12.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * level expert 3 | */ 4 | func execute(a : int, b : int, f1(int, int) -> int) -> int 5 | { 6 | f1(a, b) 7 | } 8 | 9 | func main() -> bool 10 | { 11 | assert(execute(10, 20, 12 | let func min(a : int, b : int) -> int 13 | { 14 | a < b ? a : b 15 | }) == 10) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample153.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : float ) -> int 3 | { 4 | func __print( i : int, tab[n] : float, val : float ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, printf(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0.0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( 1.5 * [ 3.0, 5.0, 7.0, 6.0 ] : float ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample156.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : float ) -> int 3 | { 4 | func __print( i : int, tab[n] : float, val : float ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, printf(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0.0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( - [ 10.0, 20.0, -30.0, -40.0 ] : float ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample22.nev: -------------------------------------------------------------------------------- 1 | func calc(coeff : int, n : int) -> int 2 | { 3 | func C() -> int 4 | { 5 | coeff 6 | } 7 | 8 | func fib(n : int) -> int 9 | { 10 | ((n == 0) ? 1 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2)) * C() 11 | }; 12 | 13 | fib(n) 14 | } 15 | 16 | func main() -> int 17 | { 18 | calc(2, 7) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample357.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | func main() -> int 5 | { 6 | var i = 0; 7 | var j = 0; 8 | 9 | while (i < 10) 10 | for (j = 0; j < 10; j = j + 1) 11 | { 12 | print(i + j); 13 | if (j == 9) 14 | { 15 | i = i + 1 16 | } 17 | }; 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample391.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Name { Max, Jacob, Other } 3 | 4 | func hello(n : Name) -> string 5 | { 6 | match (n) 7 | { 8 | Name::Max -> "Hi Max!\n"; 9 | Name::Jacob -> "Hi Jacob!\n"; 10 | else -> "Hi Unknown!\n"; 11 | } 12 | } 13 | 14 | func main() -> int 15 | { 16 | prints(hello(Name::Max)); 17 | 18 | 0 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample446.nev: -------------------------------------------------------------------------------- 1 | 2 | record R { x : int; y : int; } 3 | 4 | func pr( a[D] : R ) -> int 5 | { 6 | for ( i in [ 0 .. D - 1 ] ) 7 | { 8 | prints(a[i].x + " " + a[i].y + "\n") 9 | } 10 | } 11 | 12 | func main() -> int 13 | { 14 | let a = [ R(x, y) | x in [ 0 .. 5 ]; y in [ 0 .. x ] ] : R; 15 | 16 | pr(a); 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample457.nev: -------------------------------------------------------------------------------- 1 | 2 | func check( ra[D] : [..] : range ) -> int 3 | { 4 | assert( ra[0][0][0] == 1 ); 5 | assert( ra[1][0][0] == 10 ); 6 | assert( ra[2][0][0] == 100 ); 7 | 8 | 0 9 | } 10 | 11 | func main() -> int 12 | { 13 | let ra = [ [ 1..10 ], [ 10..20 ], [ 100..200 ] ] : [..] : range; 14 | 15 | check(ra); 16 | 17 | 0 18 | } 19 | -------------------------------------------------------------------------------- /sample/sample687.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { let value : int; }, Err { msg : string; }, Wsg } 3 | 4 | func main() -> int 5 | { 6 | let r = Result::Ok(12); 7 | 8 | match (r) 9 | { 10 | Result::Ok(value) -> value = 12; 11 | Result::Err(msg) -> { prints(msg); 0 }; 12 | Result::Wsg -> print(r); 13 | }; 14 | 15 | 0 16 | } 17 | -------------------------------------------------------------------------------- /sample/sample688.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; }, Wsg } 3 | 4 | func main() -> int 5 | { 6 | let r = Result::Ok(12); 7 | 8 | match (r) 9 | { 10 | Result::Ok(value) -> print(value); 11 | Result::Err(msg) -> { prints(msg); 0 }; 12 | Result::Wsg -> print(r); 13 | } = 12; 14 | 15 | 0 16 | } 17 | -------------------------------------------------------------------------------- /sample/sample_man5.nev: -------------------------------------------------------------------------------- 1 | 2 | func fah2cel(f : float) -> float 3 | { 4 | (f - 32.0) / 1.8 5 | } 6 | 7 | func cel2fah(c : float) -> float 8 | { 9 | c * 1.8 + 32.0 10 | } 11 | 12 | func degrees(conv(float) -> float, degree : float) -> float 13 | { 14 | conv(degree) 15 | } 16 | 17 | func main() -> float 18 | { 19 | degrees(cel2fah, 100.0) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample242.nev: -------------------------------------------------------------------------------- 1 | 2 | func factorize(n : int) -> int 3 | { 4 | var i = 1; 5 | var n = n + 0; 6 | 7 | for (i = 2; i <= n; i = i + 1) 8 | { 9 | while (n % i == 0) 10 | { 11 | print(i); 12 | n = n / i 13 | } 14 | } 15 | 16 | } 17 | 18 | func main() -> int 19 | { 20 | factorize(2020) 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample434.nev: -------------------------------------------------------------------------------- 1 | 2 | func testdo() -> int 3 | { 4 | var i = 10; 5 | var sum = 0; 6 | 7 | do 8 | { 9 | print(i); 10 | sum = sum + i; 11 | i = i - 1 12 | } 13 | while (i > 0); 14 | 15 | assert(sum == 55); 16 | 17 | 0 18 | } 19 | 20 | 21 | func main() -> int 22 | { 23 | testdo() 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample527.nev: -------------------------------------------------------------------------------- 1 | 2 | func rec(i : int) -> int 3 | { 4 | print(i); 5 | 6 | i > 0 ? rec(0) |> rec() : 0 7 | } 8 | 9 | func rec2(i : int, j : int) -> int 10 | { 11 | prints(i + " " + j + "\n"); 12 | 13 | i > 0 ? (i - 1) |> rec2(j) : 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | rec(10); 19 | rec2(10, 10); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample133.nev: -------------------------------------------------------------------------------- 1 | 2 | func exists( e : int, t[elems] : int ) -> int 3 | { 4 | func __exists( i : int, e : int, t[elems] : int ) -> int 5 | { 6 | i < elems ? ( e == t[i] ? 1 : __exists( i + 1, e, t ) ) : 0 7 | }; 8 | __exists( 0, e, t ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | exists( 100, [ 60, 20, 10, 30, 50, 40, 80, 90, 100 ] : int ) 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /sample/sample281.nev: -------------------------------------------------------------------------------- 1 | 2 | func gf(v : int) -> (int) -> int 3 | { 4 | func f(d : int) -> int 5 | { 6 | 10 / d 7 | } 8 | catch 9 | { 10 | func inc(i : int) -> int { i + 1 }; 11 | inc(v) 12 | }; 13 | 14 | f 15 | } 16 | 17 | func main() -> bool 18 | { 19 | let f = gf(87); 20 | assert(f(0) == 88) 21 | } 22 | -------------------------------------------------------------------------------- /sample/sample104.nev: -------------------------------------------------------------------------------- 1 | 2 | func tforeach( t[elems] : int, each(e : int) -> int) -> int 3 | { 4 | func __tforeach( val : int, i : int, t[elems] : int ) -> int 5 | { 6 | i < elems ? __tforeach( each(t[i]), i + 1, t ) : 0 7 | }; 8 | __tforeach(t[0], 0, t) 9 | } 10 | 11 | func main() -> int 12 | { 13 | tforeach( [ 10, 20, 50, 30, 80, 99 ] : int, print ) 14 | } 15 | 16 | 17 | -------------------------------------------------------------------------------- /sample/sample154.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : float ) -> int 3 | { 4 | func __print( i : int, tab[n] : float, val : float ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, printf(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0.0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( [ 1.5, 2.5, 3.5 ] : float + [ 3.0, 4.0, 7.0 ] : float ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample158.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[n] : float ) -> int 3 | { 4 | func __print( i : int, tab[n] : float, val : float ) -> int 5 | { 6 | i < n ? __print( i + 1, tab, printf(tab[i]) ) : 0 7 | }; 8 | __print( 0, tab, 0.0 ) 9 | } 10 | 11 | func main() -> int 12 | { 13 | printtab( [ 3.5, 5.5, 7.5 ] : float - [ 3.0, 4.0, 7.0 ] : float ) 14 | } 15 | 16 | -------------------------------------------------------------------------------- /sample/sample493.nev: -------------------------------------------------------------------------------- 1 | 2 | func check_char() -> int 3 | { 4 | assert('A' == 'A'); 5 | assert('A' != 'B'); 6 | assert('A' < 'B'); 7 | assert('A' <= 'A'); 8 | assert('A' <= 'B'); 9 | assert('B' > 'A'); 10 | assert('A' >= 'A'); 11 | assert('B' >= 'A'); 12 | 13 | 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | check_char(); 19 | 20 | 0 21 | } -------------------------------------------------------------------------------- /sample/sample511.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { ONE = 0, 3 | TWO = E::ONE + 1, 4 | THREE = E::TWO + 1, 5 | FOUR = E::THREE + 1 } 6 | 7 | let t = [ 1, 2, 3, 4, 5 ] : int; 8 | 9 | func main() -> int 10 | { 11 | assert(t[E::ONE] == 1); 12 | assert(t[E::TWO] == 2); 13 | assert(t[E::THREE] == 3); 14 | assert(t[E::FOUR] == 4); 15 | 16 | 0 17 | } 18 | 19 | -------------------------------------------------------------------------------- /sample/sample608.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | i : int; 5 | j : int; 6 | } 7 | 8 | func print_R(r : R) -> int 9 | { 10 | prints(r.i + " " + r.j + "\n"); 11 | 0 12 | } 13 | 14 | func main() -> int 15 | { 16 | var t = [ R(100, 100), R(200, 200), R(300, 300), R(400, 400) ] : R; 17 | 18 | t[2] = R(100, 100); 19 | 20 | print_R(t[2]); 21 | 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample609.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | i : int; 5 | j : int; 6 | } 7 | 8 | func getR() -> R 9 | { 10 | let r = R(10, 10); 11 | r 12 | } 13 | 14 | func main() -> int 15 | { 16 | let r = getR(); 17 | 18 | r.i = 20; 19 | r.j = 30; 20 | 21 | prints(r.i + " " + r.j + "\n"); 22 | 23 | { var i = 10; i } = 40; 24 | 25 | 0 26 | } 27 | 28 | -------------------------------------------------------------------------------- /sample/sample618.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func ra(var r[from..to] : range) -> int 4 | { 5 | from = 10; 6 | to = 20; 7 | 0 8 | } 9 | 10 | func main() -> int 11 | { 12 | let f = 0; 13 | let t = 0; 14 | var r = [ f .. t ]; 15 | 16 | ra(r); 17 | 18 | print(f); 19 | print(t); 20 | 21 | assert(f == 10); 22 | assert(t == 20); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample_man4.nev: -------------------------------------------------------------------------------- 1 | 2 | func dir_deg(d : int) -> (float) -> float 3 | { 4 | func fah2cel(f : float) -> float 5 | { 6 | (f - 32.0) / 1.8 7 | } 8 | func cel2fah(c : float) -> float 9 | { 10 | c * 1.8 + 32.0 11 | }; 12 | 13 | d == 0 ? fah2cel : cel2fah 14 | } 15 | 16 | func main() -> float 17 | { 18 | dir_deg(0)(100.0) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample280.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl() -> [_] : int 15 | { 16 | [ x * x | x in [10, 20, 30, 40, 50] : int ] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl()) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample355.nev: -------------------------------------------------------------------------------- 1 | 2 | func twice(a : int) -> int 3 | { 4 | 2 * a 5 | } 6 | 7 | func test(a : int) -> int 8 | { 9 | twice(twice(twice(32 / a))); 10 | assert(false); 11 | 12 | 0 13 | } 14 | catch (division_by_zero) 15 | { 16 | prints("division_by_zero\n"); 17 | 18 | 0 19 | } 20 | 21 | func main() -> int 22 | { 23 | test(0); 24 | 25 | 0 26 | } 27 | 28 | -------------------------------------------------------------------------------- /sample/sample630.nev: -------------------------------------------------------------------------------- 1 | 2 | func getT() -> (int, int, char) 3 | { 4 | prints("getT\n"); 5 | (10, 20, 'A') : (int, int, char) 6 | } 7 | 8 | func t1000( a : int, b : int, c : char ) -> int 9 | { 10 | prints("func t1000(" + a + ", " + b + ", " + c + ")\n"); 11 | 100 12 | } 13 | 14 | func main() -> int 15 | { 16 | getT() |> t1000() |> print(); 17 | 18 | 0 19 | } 20 | -------------------------------------------------------------------------------- /sample/sample3.nev: -------------------------------------------------------------------------------- 1 | 2 | func min(a : float, b : float) -> float 3 | { 4 | (a < b) ? a : b 5 | } 6 | 7 | func max(a : float, b : float) -> float 8 | { 9 | (a > b) ? a : b 10 | } 11 | 12 | func select(a : int) -> (float, float) -> float 13 | { 14 | a < 100 ? min : max 15 | } 16 | 17 | func main() -> bool 18 | { 19 | assert(select(110)(40.0, 20.0) == 40.0) 20 | } 21 | 22 | 23 | -------------------------------------------------------------------------------- /sample/sample326.nev: -------------------------------------------------------------------------------- 1 | 2 | record P { 3 | x : int; 4 | y : int; 5 | f : float; 6 | } 7 | 8 | func getP() -> P 9 | { 10 | nil 11 | } 12 | 13 | func main() -> int 14 | { 15 | print(print(print(getP().x))); 16 | 17 | assert(false); 18 | 19 | 0 20 | } 21 | catch (nil_pointer) 22 | { 23 | prints("caught nil_pointer\n"); 24 | -111 25 | } 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /sample/sample361.nev: -------------------------------------------------------------------------------- 1 | 2 | extern "libm.so.6" func sinhf(x : float) -> float 3 | 4 | func s(x : float) -> float { var z = 0; 10 / z; 1.0 } 5 | 6 | func main() -> int 7 | { 8 | sinhf(1.0); 9 | 10 | 0 11 | } 12 | catch (division_by_zero) 13 | { 14 | prints("division_by_zero\n"); 15 | 0 16 | } 17 | catch (ffi_fail) 18 | { 19 | prints("ffi_fail\n"); 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample462.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr_range( r[from..to] : range ) -> int 3 | { 4 | prints("[" + from + ".." + to +"]\n"); 5 | 0 6 | } 7 | 8 | func sl_range( r[from..to] : range ) -> int 9 | { 10 | pr_range( r ); 11 | pr_range( r[to..from] ); 12 | 0 13 | } 14 | 15 | func main() -> int 16 | { 17 | let r = [ 0 .. 100 ]; 18 | 19 | sl_range(r); 20 | 21 | 0 22 | } 23 | -------------------------------------------------------------------------------- /sample/sample421.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func calc() -> Result 5 | { 6 | Result::Ok(1) 7 | } 8 | 9 | func main() -> int 10 | { 11 | let i = match calc() 12 | { 13 | Result::Ok -> 200; 14 | Result::Err -> 90; 15 | }; 16 | 17 | assert(i == 200); 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample644.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | var a : int; 5 | var b : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var a = R(10, 20); 11 | let b = R(100, 200); 12 | 13 | a = b; 14 | 15 | b.a = 1000; 16 | b.b = 2000; 17 | 18 | prints("a.a = " + a.a + " a.b = " + a.b + "\n"); 19 | assert(a.a == 1000); 20 | assert(a.b == 2000); 21 | 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample177.nev: -------------------------------------------------------------------------------- 1 | 2 | func fun(a : float) -> float 3 | { 4 | let f1 = let func (a : float) -> float { 2.0 * a }; 5 | 6 | let f2 = let func () -> float 7 | { 8 | 120.0 9 | }; 10 | 11 | let f3 = let func () -> float 12 | { 13 | 222.0 14 | }; 15 | 16 | f1(a) + f2() + f3() 17 | } 18 | 19 | func main() -> float 20 | { 21 | fun(12.0) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample286.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(sq[D] : int) -> [_] : int 15 | { 16 | [ x * x | x in sq ] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl([1, 2, 3, 4, 5, 6] : int)) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample353.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | record R { 4 | x : int; 5 | y : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var t = {[ 10 ]} : R; 11 | 12 | t[0] = R(0, 0); 13 | t[1] = R(1, 1); 14 | t[2] = R(2, 2); 15 | 16 | assert(t[0].x == 0 && t[0].y == 0); 17 | assert(t[1].x == 1 && t[1].y == 1); 18 | assert(t[2].x == 2 && t[2].y == 2); 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample404.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { ONE { x : int; y : int; }, TWO } 3 | 4 | 5 | func main() -> int 6 | { 7 | var e = {[ 10 ]} : E; 8 | 9 | e[0] = E::ONE(10, 20); 10 | e[1] = E::TWO; 11 | 12 | match e[0] 13 | { 14 | E::ONE(x, y) -> prints("E::ONE(" + x + "," + y + ")\n"); 15 | E::TWO -> prints("E::TWO\n"); 16 | }; 17 | 18 | 0 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample407.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some { value : int; }, None } 3 | 4 | func rec(o : Optional) -> int 5 | { 6 | match o 7 | { 8 | Optional::Some(value) -> value > 0 ? { print(value); rec(Optional::Some(value - 1)) } : 0; 9 | Optional::None -> 0; 10 | } 11 | } 12 | 13 | func main() -> int 14 | { 15 | rec(Optional::Some(10)); 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample408.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some { value : int; }, None } 3 | 4 | func rec(o : Optional) -> int 5 | { 6 | match o 7 | { 8 | Optional::Some(value) -> value >= -10 ? { print(value); rec(Optional::Some(value - 1)) } : 0; 9 | Optional::None -> 0; 10 | } 11 | } 12 | 13 | func main() -> int 14 | { 15 | rec(Optional::Some(10)); 16 | 17 | 0 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample448.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr_dim ( dim[D] : int ) -> int 3 | { 4 | for (i in [0 .. D - 1]) 5 | { 6 | print(dim[i]) 7 | }; 8 | 9 | assert( D == 2 ); 10 | assert( dim[0] == 111); 11 | assert( dim[1] == 99); 12 | 13 | 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | let dim = [110..200, 100..0][1, 1]; 19 | 20 | pr_dim(dim); 21 | 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample287.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(sq[D] : int) -> [_] : int 15 | { 16 | [ x * y | x in sq; y in sq ] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl([1, 2, 3, 4, 5, 6] : int)) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample292.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl() -> [_] : int 15 | { 16 | [ x * x | x in [1, 2, 3, 4, 5, 6, 7, 8] : int; x % 2 == 0 ] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl()) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample365.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> () -> int 3 | { 4 | var x = 10; 5 | func nested() -> () -> int { 6 | var f1 = let func () -> int { x }; 7 | var x = 20; 8 | var f2 = let func () -> int { x }; 9 | 10 | f1 11 | }; 12 | 13 | nested() 14 | } 15 | 16 | func main() -> int 17 | { 18 | print(test()()); 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample371.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | assert('A' < 'Z'); 5 | assert('A' <= 'Z'); 6 | assert('A' <= 'A'); 7 | 8 | assert('Z' > 'A'); 9 | assert('Z' >= 'A'); 10 | assert('A' >= 'A'); 11 | 12 | assert('A' == 'A'); 13 | assert('A' != 'Z'); 14 | 15 | 0 16 | } 17 | 18 | func main() -> int 19 | { 20 | test(); 21 | 22 | 0 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /sample/sample531.nev: -------------------------------------------------------------------------------- 1 | record R 2 | { 3 | i : int; 4 | print_R(r : R, s : string) -> R; 5 | } 6 | 7 | func print_R(r : R, s : string) -> R 8 | { 9 | prints(s + r.i + s + "\n"); 10 | r 11 | } 12 | 13 | func main() -> int 14 | { 15 | let r = R(10, print_R); 16 | r |> print_R("+++"); 17 | 18 | printf(cos(sin(10.0))); 19 | printf(10.0 |> sin() |> cos()); 20 | 21 | 0 22 | } 23 | -------------------------------------------------------------------------------- /sample/sample605.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | i : int; 5 | j : int; 6 | t[D] : int; 7 | } 8 | 9 | func print_R(r : R) -> int 10 | { 11 | prints(r.i + " " + r.j + "\n"); 12 | 0 13 | } 14 | 15 | func main() -> int 16 | { 17 | var r1 = R(10, 20, [1, 2, 3, 4] : int); 18 | let r2 = r1; 19 | 20 | r1.i = 20; 21 | r1.j = 20; 22 | 23 | print_R(r2); 24 | 25 | 0 26 | } 27 | -------------------------------------------------------------------------------- /sample/sample612.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t1 = [ 1, 2, 3, 4 ] : int; 5 | var t2 = t1; 6 | 7 | t2 = [ 10, 20, 30, 40 ] : int; 8 | 9 | print(t1[0]); 10 | print(t1[1]); 11 | 12 | print(t2[0]); 13 | print(t2[1]); 14 | 15 | assert(t1[0] == 10); 16 | assert(t1[1] == 20); 17 | assert(t2[0] == 10); 18 | assert(t2[1] == 20); 19 | 20 | 0 21 | } 22 | -------------------------------------------------------------------------------- /sample/sample115.nev: -------------------------------------------------------------------------------- 1 | 2 | func f1(a : int, b : int, c : int) -> [D,D,D] : int 3 | { 4 | [ [[ 1, 2, 3 ], 5 | [ 3, 4, 5 ], 6 | [ 3, 8, 9 ], 7 | [ 6, 7, 8 ]], 8 | 9 | [[ 7, 8, 9 ], 10 | [ 6, 3, 1 ], 11 | [ 2, 4, 2 ], 12 | [ 1, 0, 4 ]]] : int 13 | } 14 | 15 | func main() -> bool 16 | { 17 | assert(f1(80, 90, 100)[1, 3, 2] == 4) 18 | } 19 | 20 | -------------------------------------------------------------------------------- /sample/sample414.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func calc() -> Result 5 | { 6 | Result::Ok(1) 7 | } 8 | 9 | func main() -> int 10 | { 11 | let i = 100; 12 | 13 | if let (Result::Ok = calc()) 14 | { 15 | print(200) 16 | } 17 | else 18 | { 19 | assert(false); 20 | print(90) 21 | }; 22 | 23 | 0 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample422.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func calc() -> Result 5 | { 6 | Result::Ok(200) 7 | } 8 | 9 | func main() -> int 10 | { 11 | var i = match calc() 12 | { 13 | Result::Ok(value) -> value; 14 | Result::Err(msg) -> 90; 15 | }; 16 | 17 | assert(i == 200); 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample445.nev: -------------------------------------------------------------------------------- 1 | 2 | record R { x : int; y : int; } 3 | 4 | func pr( a[D] : R ) -> int 5 | { 6 | var i = 0; 7 | 8 | for (i = 0; i < D; i = i + 1) 9 | { 10 | prints(a[i].x + " " + a[i].y + "\n") 11 | }; 12 | 13 | 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | let a = [ R(x, y) | x in [ 0 .. 5 ]; y in [ 0 .. x ] ] : R; 19 | 20 | pr(a); 21 | 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample271.nev: -------------------------------------------------------------------------------- 1 | 2 | func adder(start : int) -> () -> int 3 | { 4 | var v = start + 0; 5 | func add() -> int 6 | { 7 | v = v + 1 8 | }; 9 | add 10 | } 11 | 12 | func main() -> int 13 | { 14 | let a1 = adder(10); 15 | let a2 = adder(10); 16 | 17 | print(a1()); 18 | print(a1()); 19 | print(a2()); 20 | print(a2()); 21 | print(a1()) 22 | } 23 | 24 | 25 | -------------------------------------------------------------------------------- /sample/sample370.nev: -------------------------------------------------------------------------------- 1 | 2 | func get_char(str : string, i : int, c : char) -> char 3 | { 4 | print(length(str)); 5 | 6 | printc('X'); 7 | printc(c); 8 | printc(str[i]); 9 | 10 | 'Z' 11 | } 12 | 13 | func get_W() -> char 14 | { 15 | 'W' 16 | } 17 | 18 | func main() -> int 19 | { 20 | get_char("texttexttex", 2, ','); 21 | 22 | printc(get_W()); 23 | 24 | 0 25 | } 26 | 27 | -------------------------------------------------------------------------------- /sample/sample378.nev: -------------------------------------------------------------------------------- 1 | 2 | func test(i : int) -> int 3 | { 4 | print(i) 5 | } 6 | 7 | func main() -> int 8 | { 9 | var c = 'X'; 10 | var i = 0; 11 | 12 | i = ord('A'); 13 | print(i); 14 | 15 | c = chr(65); 16 | printc(c); 17 | 18 | prints("\n"); 19 | 20 | /*i = read(); 21 | print(i); 22 | 23 | print(read());*/ 24 | 25 | 0 26 | } 27 | 28 | -------------------------------------------------------------------------------- /sample/sample_lcomp.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func decor(str : string) -> string 4 | { 5 | "###" + str + "###\n" 6 | } 7 | 8 | func main() -> int 9 | { 10 | var i = 0; 11 | var texts = [ "one", "two", "three" ] : string; 12 | var decors = [ decor(txt) | txt in texts ] : string; 13 | 14 | for (i = 0; i < 3; i = i + 1) 15 | { 16 | prints(decors[i]) 17 | }; 18 | 19 | 0 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample223.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var i = 1; 5 | 6 | while (i <= 15) 7 | { 8 | if (i > 10) 9 | { 10 | print(i * 100) 11 | } 12 | else if (i > 5) 13 | { 14 | print(i * 10) 15 | } 16 | else 17 | { 18 | print(i * 1) 19 | }; 20 | 21 | i = i + 1 22 | } 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample288.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(v : int) -> [_] : int 15 | { 16 | [ y + 300 | y in [ z + 20 | z in [ 1, 2, 3, 4, 5 ] : int ] : int ] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl(20)) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample332.nev: -------------------------------------------------------------------------------- 1 | 2 | record R { 3 | x : int; 4 | y : int; 5 | z : int; 6 | v : int; 7 | } 8 | 9 | func gc_test() -> int 10 | { 11 | var i = 0; 12 | var r = R; 13 | 14 | for (i = 0; i < 100000; i = i + 1) 15 | { 16 | r = R(i, 1, 1, 1); 17 | 0 18 | }; 19 | 20 | 0 21 | } 22 | 23 | func main() -> int 24 | { 25 | gc_test(); 26 | 27 | 0 28 | } 29 | 30 | -------------------------------------------------------------------------------- /sample/sample_curradd.nev: -------------------------------------------------------------------------------- 1 | 2 | func add(x : int, y : int) -> int 3 | { 4 | x + y 5 | } 6 | 7 | func cadd(x : int) -> (int) -> int 8 | { 9 | let func (y : int) -> int 10 | { 11 | x + y 12 | } 13 | } 14 | 15 | func main() -> int 16 | { 17 | print(add(5, 7)); 18 | print(add(2, add(3, 7))); 19 | 20 | print(cadd(5)(7)); 21 | print(cadd(2)(cadd(3)(7))); 22 | 23 | 0 24 | } 25 | 26 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | *.o 3 | *.so 4 | 5 | # private files 6 | .vscode 7 | never.code-workspace 8 | 9 | # generated 10 | nev 11 | nev.dSYM/ 12 | scanner.c 13 | parser.txt 14 | test_freevar 15 | test_gc 16 | test_libmath 17 | test_object 18 | test_scanner 19 | test_symtab 20 | test_vm 21 | test_dlcache 22 | 23 | # build 24 | build/ 25 | build_js/ 26 | build_wasm/ 27 | front/parser.h 28 | front/parser.c 29 | front/parser.output 30 | -------------------------------------------------------------------------------- /sample/sample380.nev: -------------------------------------------------------------------------------- 1 | record R { a : int; b : int; } 2 | 3 | func get_func() -> () -> int 4 | { 5 | var r = R(10, 20); 6 | 7 | func f() -> int { 8 | prints("a " + r.a + " b " + r.b + "\n"); 9 | 0 10 | }; 11 | 12 | r.a = 20; 13 | r.b = 40; 14 | 15 | f 16 | } 17 | 18 | func main() -> int 19 | { 20 | let f = get_func(); 21 | 22 | f(); 23 | 24 | 0 25 | } 26 | 27 | -------------------------------------------------------------------------------- /sample/sample613.nev: -------------------------------------------------------------------------------- 1 | 2 | record R 3 | { 4 | x : int; 5 | y : int; 6 | } 7 | 8 | func main() -> int 9 | { 10 | var r = R(10, 20); 11 | var t = r; 12 | var s = t; 13 | 14 | s.x = 20; 15 | prints(r.x + " " + r.y + "\n"); 16 | assert(r.x == 20 && r.y == 20); 17 | 18 | s = R(30, 40); 19 | prints(r.x + " " + r.y + "\n"); 20 | assert(r.x == 30 && r.y == 40); 21 | 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample_man9.nev: -------------------------------------------------------------------------------- 1 | 2 | func dir_deg(d : int, coeff : float) -> (float) -> float 3 | { 4 | func fah2cel(f : float) -> float 5 | { 6 | coeff * ((f - 32.0) / 1.8) 7 | } 8 | func cel2fah(c : float) -> float 9 | { 10 | coeff * (c * 1.8 + 32.0) 11 | }; 12 | 13 | d == 0 ? cel2fah : fah2cel 14 | } 15 | 16 | func main() -> float 17 | { 18 | dir_deg(0, 100.0)(100.0) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample285.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(z : int) -> [_] : int 15 | { 16 | let Z = 2 * z; 17 | 18 | [ Z + x | x in [ 1, 10, 100, 1000 ] : int ] : int 19 | } 20 | 21 | func main() -> int 22 | { 23 | print_cl(cl(50)) 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample306.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func arr_test() -> int 4 | { 5 | var arr = {[ 10 ]} : string; 6 | 7 | arr[0] = "one"; 8 | arr[1] = "two"; 9 | arr[2] = "three"; 10 | 11 | prints(arr[0] + " " + arr[1] + " " + arr[2] + "\n"); 12 | 13 | 0 14 | } 15 | catch (nil_pointer) 16 | { 17 | prints("nil_pointer\n"); 18 | -1 19 | } 20 | 21 | func main() -> int 22 | { 23 | arr_test() 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample373.nev: -------------------------------------------------------------------------------- 1 | 2 | func test(c : char) -> int 3 | { 4 | var str = [ 'A', 'B', 'C' ] : char; 5 | 6 | assert(str[0] == 'A'); 7 | assert(str[1] == 'B'); 8 | assert(str[2] == 'C'); 9 | 10 | printc(str[0]); 11 | printc(str[1]); 12 | printc(str[2]); 13 | 14 | 0 15 | } 16 | 17 | func main() -> int 18 | { 19 | var c = 'X'; 20 | 21 | test(c); 22 | 23 | 0 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /sample/sample375.nev: -------------------------------------------------------------------------------- 1 | 2 | extern "host" func test_char(c : char) -> char 3 | 4 | func test() -> int 5 | { 6 | printc(test_char('A')); 7 | printc(test_char('B')); 8 | printc(test_char('Z')); 9 | 10 | assert(test_char('A') == 'B'); 11 | assert(test_char('B') == 'C'); 12 | assert(test_char('Z') == 'A'); 13 | 14 | 0 15 | } 16 | 17 | func main() -> int 18 | { 19 | test(); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample443.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_range( [ f1 .. t1 ] : range ) -> int 3 | { 4 | assert(f1 == 10); 5 | assert(t1 == 30); 6 | 7 | 0 8 | } 9 | 10 | func main() -> int 11 | { 12 | let f = 10; 13 | let t = 30; 14 | var r1 = [ 10 .. 30 ]; 15 | var r2 = [ f .. t ]; 16 | 17 | print_range( r1 ); 18 | 19 | print_range( r2 ); 20 | 21 | r2 = r1; 22 | print_range( r2 ); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample283.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : string) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | prints(cl[i] + "\n") 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl() -> [_] : string 15 | { 16 | [ "[" + x + "," + y + "]" | x in [1, 2, 3, 4] : int; y in [1, 2, 3, 4, 5] : int ] : string 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl()) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample103.nev: -------------------------------------------------------------------------------- 1 | 2 | func add_five(e : int) -> int 3 | { 4 | print(e + 5) 5 | } 6 | 7 | func tforeach( t[elems] : int, each(e : int) -> int) -> int 8 | { 9 | func __tforeach( val : int, i : int, t[elems] : int ) -> int 10 | { 11 | i < elems ? __tforeach( each(t[i]), i + 1, t ) : 0 12 | }; 13 | __tforeach(t[0], 0, t) 14 | } 15 | 16 | func main() -> int 17 | { 18 | tforeach( [ 10, 20, 50, 30, 40 ] : int, add_five ) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample372.nev: -------------------------------------------------------------------------------- 1 | 2 | func test(var c : char) -> int 3 | { 4 | var i = 'A'; 5 | 6 | assert(i == 'A'); 7 | assert(c == 'X'); 8 | 9 | i = 'Z'; 10 | c = 'Y'; 11 | 12 | assert(i == 'Z'); 13 | assert(c == 'Y'); 14 | 15 | printc(i); 16 | printc(c); 17 | 18 | 0 19 | } 20 | 21 | func main() -> int 22 | { 23 | var c = 'X'; 24 | 25 | test(c); 26 | 27 | 0 28 | } 29 | 30 | 31 | -------------------------------------------------------------------------------- /sample/sample494.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func check_ass() -> int 4 | { 5 | var i = 10; 6 | var l = 10L; 7 | var f = 10.0; 8 | var d = 10.0d; 9 | 10 | i = 20; 11 | l = 20L; 12 | f = 20.0; 13 | d = 20.0d; 14 | 15 | assert(i == 20); 16 | assert(l == 20L); 17 | assert(f == 20.0); 18 | assert(d == 20.0d); 19 | 20 | 0 21 | } 22 | 23 | func main() -> int 24 | { 25 | check_ass(); 26 | 0 27 | } 28 | 29 | -------------------------------------------------------------------------------- /sample/sample187.nev: -------------------------------------------------------------------------------- 1 | func rec(i : int) -> int 2 | { 3 | i > 0 4 | ? 5 | (i % 2 == 0) 6 | ? 7 | { 8 | print(999); 9 | rec(i - 1) 10 | } 11 | : 12 | { 13 | print(888); 14 | rec(i - 1) 15 | } 16 | : 17 | 0 18 | } 19 | 20 | func main() -> int 21 | { 22 | rec(5) 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample420.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func calc() -> Result 5 | { 6 | Result::Ok(1) 7 | } 8 | 9 | func main() -> int 10 | { 11 | let i = if let (Result::Ok = calc()) 12 | { 13 | 200 14 | } 15 | else 16 | { 17 | 90 18 | }; 19 | 20 | assert(i == 200); 21 | 22 | 0 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample132.nev: -------------------------------------------------------------------------------- 1 | 2 | func sum_mapi(i : int, e : int) -> int 3 | { 4 | print(i + e) 5 | } 6 | 7 | func tmapi( t[elems] : int, mapi(i : int, e : int) -> int) -> int 8 | { 9 | func __tmapi( val : int, i : int, t[elems] : int ) -> int 10 | { 11 | i < elems ? __tmapi( mapi(i, t[i]), i + 1, t ) : 0 12 | }; 13 | __tmapi(t[0], 0, t) 14 | } 15 | 16 | func main() -> int 17 | { 18 | tmapi( [ 10, 20, 50, 30, 40 ] : int, sum_mapi ) 19 | } 20 | 21 | 22 | -------------------------------------------------------------------------------- /sample/sample17.nev: -------------------------------------------------------------------------------- 1 | 2 | func get(c : int) -> (float, float) -> float 3 | { 4 | c != 0 ? let func min(a : float, b : float) -> float 5 | { 6 | a < b ? a : b 7 | } 8 | : let func max(a : float, b : float) -> float 9 | { 10 | a > b ? a : b 11 | } 12 | } 13 | 14 | func main() -> bool 15 | { 16 | assert(get(0)(10.0, 20.0) == 20.0) 17 | } 18 | 19 | 20 | 21 | -------------------------------------------------------------------------------- /sample/sample282.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : (int) -> int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i](2)) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(z : int) -> [_] : (int) -> int 15 | { 16 | [ let func(v : int) -> int { v * u } | u in [ 1, 10, 100, 1000 ] : int ] : (int) -> int 17 | } 18 | 19 | func main() -> int 20 | { 21 | print_cl(cl(20)) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample23.nev: -------------------------------------------------------------------------------- 1 | func calc(coeff : int, n : int) -> int 2 | { 3 | func C() -> int 4 | { 5 | coeff 6 | } 7 | 8 | func help(n : int) -> int 9 | { 10 | func fib(n : int) -> int 11 | { 12 | ((n == 0) ? 1 : (n == 1) ? 1 : fib(n - 1) + fib(n - 2)) * C() 13 | }; 14 | fib(n) 15 | }; 16 | 17 | help(n) 18 | } 19 | 20 | func main() -> int 21 | { 22 | calc(2, 7) 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample24.nev: -------------------------------------------------------------------------------- 1 | func mutrec(n : float) -> float 2 | { 3 | func A(n : float) -> float 4 | { 5 | (n == 1.0) ? B(1.0) : 99.0 6 | } 7 | 8 | func B(n : float) -> float 9 | { 10 | (n == 1.0) ? A(10.0) : 12.0 11 | } 12 | 13 | func C(n : float) -> float 14 | { 15 | A(n) 16 | }; 17 | 18 | C(n) 19 | } 20 | 21 | func main() -> bool 22 | { 23 | assert(mutrec(1.0) == 99.0) 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample413.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some { value : int; }, None } 3 | 4 | func printOptional(o : Optional) -> bool 5 | { 6 | match o 7 | { 8 | Optional::Some(value) -> assert(value == 1000); 9 | Optional::None -> assert(false); 10 | } 11 | } 12 | 13 | func main() -> int 14 | { 15 | var o = Optional::None; 16 | 17 | o = Optional::Some(1000); 18 | 19 | printOptional(o); 20 | 21 | 0 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample423.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func calc() -> Result 5 | { 6 | Result::Ok(200) 7 | } 8 | 9 | func main() -> int 10 | { 11 | let i = if let (Result::Ok(value) = calc()) 12 | { 13 | value 14 | } 15 | else 16 | { 17 | 90 18 | }; 19 | 20 | assert(i == 200); 21 | 22 | 0 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample617.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | let t1 = [ 1, 2, 3, 4 ] : int; 5 | var t2 = t1[2..3]; 6 | 7 | t2[0] = 10; 8 | t2[1] = 20; 9 | 10 | print(t1[0]); 11 | print(t1[1]); 12 | print(t1[2]); 13 | print(t1[3]); 14 | 15 | print(t2[0]); 16 | print(t2[1]); 17 | 18 | assert(t1[2] == 10); 19 | assert(t1[3] == 20); 20 | assert(t2[0] == 10); 21 | assert(t2[1] == 20); 22 | 23 | 0 24 | } 25 | -------------------------------------------------------------------------------- /sample/sample10.nev: -------------------------------------------------------------------------------- 1 | 2 | func mul(a : float, b : float) -> float 3 | { 4 | a * b 5 | } 6 | 7 | func funGen1(a : float, b : float) -> float 8 | { 9 | func funInt(a : float, b : float) -> float 10 | { 11 | a * b 12 | }; 13 | funInt(a, b + 2.0) 14 | } 15 | 16 | func funGen2(a : float, b : float) -> float 17 | { 18 | mul(a, b + 2.0) 19 | } 20 | 21 | func main() -> bool 22 | { 23 | assert(funGen2(10.0, 20.0) == 220.0) 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample293.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(v : int) -> [_] : int 15 | { 16 | [ y + 300 | x in [ v, 2 * v ] : int; 17 | y in [ z + x | z in [ 1, 2, 3, 4, 5 ] : int ] : int ] : int 18 | } 19 | 20 | func main() -> int 21 | { 22 | print_cl(cl(1000)) 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample415.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some{ value : int; }, None } 3 | 4 | func getF(o : Optional) -> () -> int 5 | { 6 | if let ( Optional::Some(value) = o) 7 | { 8 | let func() -> int { value } 9 | } 10 | else 11 | { 12 | let func() -> int { 1000 } 13 | } 14 | } 15 | 16 | func main() -> int 17 | { 18 | let o = Optional::Some(10); 19 | 20 | assert(getF(o)() == 10); 21 | 22 | 0 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /sample/sample646.nev: -------------------------------------------------------------------------------- 1 | 2 | enum EONE { one, two, three, four } 3 | 4 | func main() -> int 5 | { 6 | var e1 = EONE::one; 7 | var e2 = e1; 8 | 9 | e2 = e1; 10 | e2 = EONE::four; 11 | 12 | match e1 13 | { 14 | EONE::one -> prints("EONE::one\n"); 15 | EONE::two -> prints("EONE::two\n"); 16 | EONE::three -> prints("EONE::three\n"); 17 | EONE::four -> prints("EONE::four\n"); 18 | }; 19 | 20 | 0 21 | } 22 | -------------------------------------------------------------------------------- /sample/sample401.nev: -------------------------------------------------------------------------------- 1 | 2 | enum I { ONE, TWO, THREE } 3 | enum E { ONE { value : int; }, TWO } 4 | 5 | record R 6 | { 7 | e : E; 8 | } 9 | 10 | func main() -> int 11 | { 12 | let a = [ I::ONE, I::TWO, I::THREE ] : I; 13 | let b = [ E::ONE(120), E::TWO, E::TWO ] : E; 14 | let e = E::ONE(1000); 15 | 16 | match b[0] 17 | { 18 | E::ONE(value) -> print(value); 19 | E::TWO -> print(0); 20 | }; 21 | 22 | 0 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /sample/sample402.nev: -------------------------------------------------------------------------------- 1 | 2 | enum OP { ADD { x : int; y : int; }, MUL { x : int; y : int; } } 3 | 4 | func get_func(o : OP) -> () -> int 5 | { 6 | match o 7 | { 8 | OP::ADD(x, y) -> let func () -> int { x + y }; 9 | OP::MUL(x, y) -> let func () -> int { x * y }; 10 | } 11 | } 12 | 13 | func main() -> int 14 | { 15 | let o = OP::MUL(10, 20); 16 | let f = get_func(o); 17 | 18 | print(f()); 19 | 20 | 0 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /sample/sample_main_strarr.nev: -------------------------------------------------------------------------------- 1 | 2 | func test1(argv[argc] : string) -> int 3 | { 4 | for (s in argv) 5 | { 6 | prints("****\t" + s + "\n") 7 | }; 8 | 0 9 | } 10 | 11 | func test2(argv[D1, D2] : string) -> int 12 | { 13 | prints(argv[1,0] + "\n"); 14 | 0 15 | } 16 | 17 | func main(argv[argc] : string) -> int 18 | { 19 | test1( [] : string ); 20 | test1( argv ); 21 | test2( [ [ "aa" ], [ "bbb" ] ] : string ); 22 | 0 23 | } 24 | -------------------------------------------------------------------------------- /sample/sample515.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A 3 | { 4 | ZERO = 0, 5 | ONE = 1 6 | } 7 | 8 | enum E 9 | { 10 | ZERO, 11 | ONE = 1, 12 | TWO = (E::ZERO < E::ONE) ? 2 : 0, 13 | THREE = (E::ONE < E::TWO) ? 3 : 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | assert(A::ZERO == 0); 19 | assert(A::ONE == 1); 20 | 21 | assert(E::ZERO == 0); 22 | assert(E::ONE == 1); 23 | assert(E::TWO == 2); 24 | assert(E::THREE == 3); 25 | 26 | 0 27 | } 28 | -------------------------------------------------------------------------------- /sample/sample610.nev: -------------------------------------------------------------------------------- 1 | 2 | func f (s : int) -> var [D] : int 3 | { 4 | var t = [ s, s, s, s, s, s ] : int; 5 | t 6 | } 7 | 8 | func main() -> int 9 | { 10 | var s = 10; 11 | var t = f(s); 12 | 13 | assert(f(s)[0] == 10); 14 | assert(f(s)[1] == 10); 15 | 16 | s = 20; 17 | assert(f(s)[0] == 20); 18 | assert(f(s)[1] == 20); 19 | 20 | f(s)[0] = 30; 21 | assert(f(s)[0] == 30); 22 | assert(f(s)[1] == 30); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample164.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | if (i < 10) 7 | { 8 | if (i % 2 == 0) 9 | { 10 | print(i); loop(i + 1) 11 | } 12 | else 13 | { 14 | print(i); loop(i + 3) 15 | } 16 | } 17 | else 18 | { 19 | 10 20 | } 21 | }; 22 | 23 | loop(0) 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample454.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr_range( [ from .. to ] : range ) -> int 3 | { 4 | prints("range [" + from + ".." + to + "]\n"); 5 | 0 6 | } 7 | 8 | func pr_ranges( ranges[D] : [..] : range ) -> int 9 | { 10 | for (r in ranges) 11 | { 12 | pr_range(r) 13 | } 14 | } 15 | 16 | func main() -> int 17 | { 18 | let r = [ [ from .. to ] | from in [ 0 .. 10 ]; to in [ 0 .. 10 ] ] : [..] : range; 19 | 20 | pr_ranges(r); 21 | 22 | 0 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample514.nev: -------------------------------------------------------------------------------- 1 | 2 | enum A 3 | { 4 | ZERO = E::ZERO, 5 | ONE = E::ONE 6 | } 7 | 8 | enum E 9 | { 10 | ZERO, 11 | ONE = 1, 12 | TWO = (E::ZERO < E::ONE) ? 2 : 0, 13 | THREE = (E::ONE < E::TWO) ? 3 : 0 14 | } 15 | 16 | func main() -> int 17 | { 18 | assert(A::ZERO == 0); 19 | assert(A::ONE == 1); 20 | 21 | assert(E::ZERO == 0); 22 | assert(E::ONE == 1); 23 | assert(E::TWO == 2); 24 | assert(E::THREE == 3); 25 | 26 | 0 27 | } 28 | -------------------------------------------------------------------------------- /sample/sample523.nev: -------------------------------------------------------------------------------- 1 | 2 | func one() -> int 3 | { 4 | prints("one "); 5 | 1 6 | } 7 | 8 | func two() -> int 9 | { 10 | prints("two "); 11 | 2 12 | } 13 | 14 | func three() -> int 15 | { 16 | prints("three "); 17 | 3 18 | } 19 | 20 | func main() -> int 21 | { 22 | /* let i = one() = two() = three(); */ 23 | var i = 1; 24 | var j = 2; 25 | 26 | i = { two(); j } = { one(); 10 }; 27 | 28 | print(i); 29 | print(j); 30 | 31 | 0 32 | } 33 | -------------------------------------------------------------------------------- /sample/sample235.nev: -------------------------------------------------------------------------------- 1 | 2 | func three(d : int, c : int) -> int 3 | { 4 | var t = [ 1, 2, 3 ] : int; 5 | 6 | t[0] = d; 7 | 17770 / d 8 | } 9 | 10 | func two(d : int) -> int 11 | { 12 | three(d, 199); 13 | assert(false); 14 | 0 15 | } 16 | 17 | func one(d : int) -> int 18 | { 19 | two(d); 20 | assert(false); 21 | 0 22 | } 23 | 24 | func main() -> int 25 | { 26 | one(0); 27 | assert(false); 28 | 0 29 | } 30 | catch 31 | { 32 | 0 33 | } 34 | 35 | -------------------------------------------------------------------------------- /sample/sample452.nev: -------------------------------------------------------------------------------- 1 | 2 | func gr(index : int, [from .. to ] : range ) -> int 3 | { 4 | [from .. to][index][0] 5 | } 6 | catch (index_out_of_bounds) 7 | { 8 | 99 9 | } 10 | 11 | func main() -> int 12 | { 13 | let r = [ 1 .. 5 ]; 14 | 15 | assert(gr(-1, r) == 99); 16 | assert(gr(0, r) == 1); 17 | assert(gr(1, r) == 2); 18 | assert(gr(2, r) == 3); 19 | assert(gr(3, r) == 4); 20 | assert(gr(4, r) == 5); 21 | assert(gr(5, r) == 99); 22 | 23 | 0 24 | } 25 | -------------------------------------------------------------------------------- /sample/sample513.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { ONE = 1, TWO = F::TWO, THREE = E::TWO + 1 } 3 | enum F { ONE = E::ONE, TWO = F::ONE + 1, THREE = E::THREE } 4 | 5 | func getVal(e : int) -> int 6 | { 7 | e 8 | } 9 | 10 | func main() -> int 11 | { 12 | assert(getVal(E::ONE) == 1); 13 | assert(getVal(E::TWO) == 2); 14 | assert(getVal(E::THREE) == 3); 15 | 16 | assert(getVal(F::ONE) == 1); 17 | assert(getVal(F::TWO) == 2); 18 | assert(getVal(F::THREE) == 3); 19 | 20 | 0 21 | } 22 | -------------------------------------------------------------------------------- /sample/sample215.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | func loop(i : int) -> int 5 | { 6 | var f1 = let func(a : int) -> int { a * a }; 7 | var f2 = let func(b : int) -> int { b + b }; 8 | var f3 = let func(c : int) -> int { i * i }; 9 | 10 | i < 10 ? 11 | { 12 | f2 = f1; 13 | f3 = f1; 14 | loop(i + 1) 15 | } : 16 | 10 17 | }; 18 | 19 | loop(0) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample234.nev: -------------------------------------------------------------------------------- 1 | 2 | func three(d : int, c : int) -> int 3 | { 4 | var t = [ 1, 2, 3 ] : int; 5 | 6 | t[0] = d; 7 | 17770 / d 8 | } 9 | 10 | func two(d : int) -> int 11 | { 12 | three(d, 199); 13 | assert(false); 14 | 0 15 | } 16 | 17 | func one(d : int) -> int 18 | { 19 | two(d); 20 | assert(false); 21 | 0 22 | } 23 | catch (division_by_zero) 24 | { 25 | 100 + 20 + 9 26 | } 27 | 28 | func main() -> bool 29 | { 30 | assert(one(0) == 129) 31 | } 32 | 33 | -------------------------------------------------------------------------------- /sample/sample238.nev: -------------------------------------------------------------------------------- 1 | 2 | func fallback(d : int) -> int 3 | { 4 | 170 / d 5 | } 6 | 7 | func three(d : int, c : int) -> int 8 | { 9 | 170 / (d + c) 10 | } 11 | 12 | func two(d : int) -> int 13 | { 14 | three(d, 0) 15 | } 16 | catch(division_by_zero) 17 | { 18 | fallback(d) 19 | } 20 | 21 | func one(d : int) -> int 22 | { 23 | two(d) 24 | } 25 | catch (division_by_zero) 26 | { 27 | 170 28 | } 29 | 30 | func main() -> bool 31 | { 32 | assert(one(0) == 170) 33 | } 34 | 35 | 36 | -------------------------------------------------------------------------------- /sample/sample382.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four, five, six } 3 | enum F { eight, nine, ten } 4 | 5 | func main() -> int 6 | { 7 | let e = E::six; 8 | 9 | match e 10 | { 11 | E::one -> { assert(false); 1 }; 12 | E::two -> { assert(false); 2 }; 13 | E::three -> { assert(false); 3 }; 14 | E::four -> { assert(false); 4 }; 15 | E::five -> { assert(false); 5 }; 16 | else -> { assert(true); 6 }; 17 | } 18 | 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample387.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four, five, six } 3 | 4 | func getE(e : E) -> int 5 | { 6 | var v = 1; 7 | 8 | v = match e 9 | { 10 | else -> 4; 11 | }; 12 | 13 | v 14 | } 15 | 16 | func main() -> int 17 | { 18 | assert(getE(E::one) == 4); 19 | assert(getE(E::two) == 4); 20 | assert(getE(E::three) == 4); 21 | assert(getE(E::four) == 4); 22 | assert(getE(E::five) == 4); 23 | assert(getE(E::six) == 4); 24 | 25 | 0 26 | } 27 | 28 | -------------------------------------------------------------------------------- /sample/sample405.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func div(n : int, d : int) -> Result 5 | { 6 | if (d != 0) 7 | { 8 | Result::Ok(n / d) 9 | } 10 | else 11 | { 12 | Result::Err("division by zero") 13 | } 14 | } 15 | 16 | func main() -> int 17 | { 18 | match div(10, 0) 19 | { 20 | Result::Ok(value) -> print(value); 21 | Result::Err(msg) -> { prints(msg + "\n"); 0 }; 22 | }; 23 | 24 | 0 25 | } 26 | 27 | -------------------------------------------------------------------------------- /sample/sample241.nev: -------------------------------------------------------------------------------- 1 | 2 | func divisors(n : int) -> int 3 | { 4 | var i = 1; 5 | 6 | for (i = 1; i * i <= n; i = i + 1) 7 | { 8 | if (n % i == 0) 9 | { 10 | if (n / i != i) 11 | { 12 | print(n / i); 13 | print(i) 14 | } 15 | else 16 | { 17 | print(i) 18 | } 19 | } 20 | } 21 | 22 | } 23 | 24 | func main() -> int 25 | { 26 | divisors(60) 27 | } 28 | 29 | -------------------------------------------------------------------------------- /sample/sample284.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(z : int) -> [_] : int 15 | { 16 | func d(x : int) -> int 17 | { 18 | 2 * x 19 | }; 20 | 21 | [ y + z | x in [10, 20, 30, 40, 50] : int; y in [d(x + 1), d(x + 2), d(x + 3)] : int ] : int 22 | } 23 | 24 | func main() -> int 25 | { 26 | print_cl(cl(100)) 27 | } 28 | 29 | -------------------------------------------------------------------------------- /sample/sample302.nev: -------------------------------------------------------------------------------- 1 | 2 | record Tree { 3 | value : int; 4 | left : Tree; 5 | right : Tree; 6 | } 7 | 8 | func print_Tree(t1 : Tree) -> int 9 | { 10 | print(t1.value); 11 | print(t1.left.value); 12 | 13 | 0 14 | } 15 | catch (nil_pointer) 16 | { 17 | 0 18 | } 19 | 20 | func main() -> int 21 | { 22 | var t0 = Tree(30, nil, nil); 23 | var t1 = Tree(20, nil, nil); 24 | 25 | t0 = nil; 26 | t1.value = 10; 27 | 28 | print_Tree(t1); 29 | 30 | 0 31 | } 32 | 33 | -------------------------------------------------------------------------------- /sample/sample364.nev: -------------------------------------------------------------------------------- 1 | 2 | func test() -> int 3 | { 4 | var x = 10; 5 | func nested() -> int { 6 | let v1 = let func () -> int { x }(); 7 | var x = 20; 8 | let v2 = let func () -> int { x }(); 9 | 10 | print(v1); 11 | print(v2); 12 | 13 | assert(v1 == 10); 14 | assert(v2 == 20); 15 | 16 | 0 17 | }; 18 | 19 | nested(); 20 | 0 21 | } 22 | 23 | func main() -> int 24 | { 25 | test(); 26 | 27 | 0 28 | } 29 | 30 | -------------------------------------------------------------------------------- /sample/sample648.nev: -------------------------------------------------------------------------------- 1 | enum Optional { Some { value : int; }, None } 2 | 3 | func main() -> int 4 | { 5 | var a = 1000; 6 | var o1 = Optional::Some(a); 7 | let o2 = Optional::Some(a); 8 | 9 | a = 1; 10 | 11 | match o1 12 | { 13 | Optional::Some(value) -> value = 900; 14 | Optional::None -> 0; 15 | }; 16 | 17 | match o1 18 | { 19 | Optional::Some(value) -> prints(value + "\n"); 20 | Optional::None -> prints("None"); 21 | }; 22 | 23 | 0 24 | } 25 | -------------------------------------------------------------------------------- /sample/sample_fficonc.nev: -------------------------------------------------------------------------------- 1 | 2 | #extern "../dyntest/dyntest.so" func test_conc_str(a : string, b : string) -> string 3 | #extern "../dyntest/dyntest.so" func test_conc_int_str(d : int, str : string) -> string 4 | 5 | extern "host" func test_conc_str(a : string, b : string) -> string 6 | extern "host" func test_conc_int_str(d : int, str : string) -> string 7 | 8 | func main() -> int 9 | { 10 | prints(test_conc_str("one", "two") + "\n"); 11 | prints(test_conc_int_str(120, "one") + "\n"); 12 | 0 13 | } 14 | 15 | -------------------------------------------------------------------------------- /sample/sample_lcomp2.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var i = 0; 6 | var texts = [ "one", "two", "three" ] : string; 7 | var decors = [ let func () -> int 8 | { 9 | prints("###" + txt + "###\n"); 10 | 0 11 | } 12 | | txt in texts 13 | ] : () -> int; 14 | 15 | for (i = 0; i < 3; i = i + 1) 16 | { 17 | decors[i]() 18 | }; 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample451.nev: -------------------------------------------------------------------------------- 1 | 2 | func gs(index : int, s [from .. to ] : int ) -> int 3 | { 4 | s[index] 5 | } 6 | catch (index_out_of_bounds) 7 | { 8 | 99 9 | } 10 | 11 | func main() -> int 12 | { 13 | let a = [ 1, 2, 3, 4, 5, 6 ] : int; 14 | let s = a[5 .. 1]; 15 | 16 | assert(gs(-1, s) == 99); 17 | assert(gs(0, s) == 6); 18 | assert(gs(1, s) == 5); 19 | assert(gs(2, s) == 4); 20 | assert(gs(3, s) == 3); 21 | assert(gs(4, s) == 2); 22 | assert(gs(5, s) == 99); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample666.nev: -------------------------------------------------------------------------------- 1 | enum Optional { Some { let value : int; }, None } 2 | 3 | func main() -> int 4 | { 5 | var a = 1000; 6 | var o1 = Optional::Some(a); 7 | let o2 = Optional::Some(a); 8 | 9 | a = 1; 10 | 11 | match o1 12 | { 13 | Optional::Some(value) -> value = 900; 14 | Optional::None -> 0; 15 | }; 16 | 17 | match o1 18 | { 19 | Optional::Some(value) -> prints(value + "\n"); 20 | Optional::None -> prints("None"); 21 | }; 22 | 23 | 0 24 | } 25 | -------------------------------------------------------------------------------- /sample/sample161.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[row, col] : int ) -> int 3 | { 4 | func __printtab( i : int, tab[row, col] : int, val : int ) -> int 5 | { 6 | i < row * col ? 7 | __printtab( i + 1, tab, print( tab[i / col, i % col] )) : 0 8 | }; 9 | __printtab ( 0, tab, 0 ) 10 | } 11 | 12 | func main() -> int 13 | { 14 | printtab( [[ 1, 2, 3 ]] : int 15 | * 16 | [[ 3 ], 17 | [ 6 ], 18 | [ 8 ]] : int ) 19 | } 20 | 21 | -------------------------------------------------------------------------------- /sample/sample213.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> bool 3 | { 4 | assert(true == true); 5 | assert(false == false); 6 | assert((true && true) == true); 7 | assert((true && false) == false); 8 | assert((false && true) == false); 9 | assert((false && false) == false); 10 | assert((true || true) == true); 11 | assert((true || false) == true); 12 | assert((false || true) == true); 13 | assert((false || false) == false); 14 | assert((!true) == false); 15 | assert((!false) == true) 16 | } 17 | 18 | -------------------------------------------------------------------------------- /sample/sample689.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { var value : int; }, Err { msg : string; }, Wsg } 3 | 4 | func main() -> int 5 | { 6 | let r = Result::Ok(12); 7 | 8 | match (r) 9 | { 10 | Result::Ok(value) -> value = 18; 11 | Result::Err(msg) -> { prints(msg); 0 }; 12 | Result::Wsg -> print(r); 13 | }; 14 | 15 | if let (Result::Ok(value) = r) 16 | { 17 | assert(value == 18) 18 | } 19 | else 20 | { 21 | assert(false) 22 | }; 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample2.nev: -------------------------------------------------------------------------------- 1 | 2 | func min(a : float, b : float) -> float 3 | { 4 | (a < b) ? a : b 5 | } 6 | 7 | func twice(single_func(float, float) -> float) -> (float, float) -> float 8 | { 9 | func twice_func(a : float, b : float) -> float 10 | { 11 | func one_more() -> float 12 | { 13 | 10.00 14 | }; 15 | one_more() * single_func(a, b) 16 | }; 17 | twice_func 18 | } 19 | 20 | func main() -> bool 21 | { 22 | assert(twice(min)(12.0, 15.0) == 120.00) 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /sample/sample28.nev: -------------------------------------------------------------------------------- 1 | func no(n : float) -> float 2 | { 3 | (-3.0) * n 4 | } 5 | 6 | func mutrec(n : float) -> float 7 | { 8 | func A(n : float) -> float 9 | { 10 | (n == 1.0) ? B(1.0) : no(n) 11 | } 12 | 13 | func B(n : float) -> float 14 | { 15 | (n == 1.0) ? A(11.0) : 12.0 16 | } 17 | 18 | func C(n : float) -> float 19 | { 20 | A(n) 21 | }; 22 | 23 | C(n) 24 | } 25 | 26 | func main() -> bool 27 | { 28 | assert(mutrec(1.0) == -33.0) 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample309.nev: -------------------------------------------------------------------------------- 1 | 2 | func arr_test() -> int 3 | { 4 | var i = 0; 5 | var arr = {[ 10 ]} : (int) -> int; 6 | 7 | for (i = 0; i < 10; i = i + 1) 8 | { 9 | arr[i] = let func (a : int) -> int { a + i } 10 | }; 11 | 12 | for (i = 0; i < 10; i = i + 1) 13 | { 14 | prints(arr[i](10) + "\n") 15 | }; 16 | 17 | 0 18 | } 19 | catch (nil_pointer) 20 | { 21 | prints("nil_pointer\n"); 22 | 0 23 | } 24 | 25 | func main() -> int 26 | { 27 | arr_test() 28 | } 29 | 30 | -------------------------------------------------------------------------------- /sample/sample403.nev: -------------------------------------------------------------------------------- 1 | 2 | enum OP { ADD { x : int; y : int; }, MUL { x : int; y : int; } } 3 | 4 | func get_func(o : OP) -> () -> () -> int 5 | { 6 | match o 7 | { 8 | OP::ADD(x, y) -> let func () -> () -> int { let func() -> int { x + y } }; 9 | OP::MUL(x, y) -> let func () -> () -> int { let func() -> int { x * y } }; 10 | } 11 | } 12 | 13 | func main() -> int 14 | { 15 | let o = OP::MUL(10, 20); 16 | let f = get_func(o); 17 | 18 | print(f()()); 19 | 20 | 0 21 | } 22 | 23 | 24 | -------------------------------------------------------------------------------- /sample/sample464.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr_range( [from..to] : range ) -> int 3 | { 4 | prints("[" + from + ".." + to + "]\n"); 5 | 0 6 | } 7 | 8 | func pr_arr( rs[D] : [..] : range ) -> int 9 | { 10 | for (r in rs) 11 | { 12 | pr_range(r) 13 | } 14 | } 15 | 16 | func main() -> int 17 | { 18 | var rs = {[ 5 ]} : [..] : range; 19 | 20 | rs[0] = [1..10]; 21 | rs[1] = [10..20]; 22 | rs[2] = [20..30]; 23 | rs[3] = [30..40]; 24 | rs[4] = [40..50]; 25 | 26 | pr_arr(rs); 27 | 28 | 0 29 | } -------------------------------------------------------------------------------- /sample/sample_lcomp3.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func main() -> int 4 | { 5 | var i = 0; 6 | var texts = [ "one", "two", "three" ] : string; 7 | var decors = [ let func (d : string) -> int 8 | { 9 | prints(d + txt + d + "\n"); 10 | 0 11 | } 12 | | txt in texts 13 | ] : (string) -> int; 14 | 15 | for (i = 0; i < 3; i = i + 1) 16 | { 17 | decors[i]("#@#") 18 | }; 19 | 20 | 0 21 | } 22 | 23 | -------------------------------------------------------------------------------- /sample/sample307.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func arr_test() -> int 4 | { 5 | var arr = {[ 10 ]} : [_] : int; 6 | 7 | arr[0] = [ 1, 2, 3, 4, 5 ] : int; 8 | arr[1] = [ 8, 9, 10, 11, 12 ] : int; 9 | arr[2] = [ 13, 14, 15, 16, 17 ] : int; 10 | 11 | print(arr[0][0]); 12 | print(arr[1][1]); 13 | print(arr[2][2]); 14 | print(arr[2][4]); 15 | 16 | 0 17 | } 18 | catch (nil_pointer) 19 | { 20 | prints("nil_pointer\n"); 21 | 0 22 | } 23 | 24 | func main() -> int 25 | { 26 | arr_test() 27 | } 28 | 29 | -------------------------------------------------------------------------------- /sample/sample385.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four, five, six } 3 | 4 | func getE(e : E) -> int 5 | { 6 | match e 7 | { 8 | E::three -> 3; 9 | E::two -> 2; 10 | E::one -> 1; 11 | else -> 4; 12 | } 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(getE(E::one) == 1); 18 | assert(getE(E::two) == 2); 19 | assert(getE(E::three) == 3); 20 | assert(getE(E::four) == 4); 21 | assert(getE(E::five) == 4); 22 | assert(getE(E::six) == 4); 23 | 24 | 0 25 | } 26 | 27 | -------------------------------------------------------------------------------- /sample/sample619.nev: -------------------------------------------------------------------------------- 1 | 2 | enum F { ONE, TWO } 3 | 4 | func getF(f : F) -> (var int) -> int 5 | { 6 | func f1(var a : int) -> int 7 | { 8 | a = 10 9 | } 10 | 11 | func f2(var a : int) -> int 12 | { 13 | a = 20 14 | }; 15 | 16 | match f 17 | { 18 | F::ONE -> f1; 19 | F::TWO -> f2; 20 | } 21 | } 22 | 23 | func main() -> int 24 | { 25 | var i = 0; 26 | let f = getF(F::ONE); 27 | 28 | f(i); 29 | 30 | print(i); 31 | assert(i == 10); 32 | 33 | 0 34 | } 35 | -------------------------------------------------------------------------------- /sample/sample635.nev: -------------------------------------------------------------------------------- 1 | 2 | func main() -> int 3 | { 4 | var t1 = {[ 5 ]} : (int, float); 5 | t1[0] = (10, 10.0) : (int, float); 6 | 7 | assert(t1[0] != nil); 8 | assert(t1[1] == nil); 9 | assert(nil != t1[0]); 10 | assert(nil == t1[1]); 11 | 12 | var t = (20, 20.0) : (int, float); 13 | assert(t != nil); 14 | assert(nil != t); 15 | 16 | t = t1[0]; 17 | assert(t != nil); 18 | assert(nil != t); 19 | 20 | t = nil; 21 | assert(t == nil); 22 | assert(nil == t); 23 | 24 | 0 25 | } 26 | -------------------------------------------------------------------------------- /sample/sample_sum_digits.nev: -------------------------------------------------------------------------------- 1 | 2 | func sum_digits(n : int, base : int) -> int 3 | { 4 | var sum = 0; 5 | var n = n + 0; 6 | 7 | do 8 | { 9 | sum = sum + n % base; 10 | n = n / base 11 | } 12 | while (n != 0); 13 | 14 | sum 15 | } 16 | 17 | func main() -> int 18 | { 19 | print(sum_digits(1, 10)); 20 | print(sum_digits(12345, 10)); 21 | print(sum_digits(123045, 10)); 22 | print(sum_digits(0xfe, 16)); 23 | print(sum_digits(0Xf0e, 16)); 24 | 25 | 0 26 | } 27 | 28 | -------------------------------------------------------------------------------- /sample/sample_temp.nev: -------------------------------------------------------------------------------- 1 | func KtoC(k : float) -> float 2 | { 3 | k - 273.15 4 | } 5 | 6 | func KtoF(k : float) -> float 7 | { 8 | k * 1.8 - 459.67 9 | } 10 | 11 | func KtoR(k : float) -> float 12 | { 13 | k * 1.8 14 | } 15 | 16 | func convertK(k : float) -> int 17 | { 18 | prints("K " + k + "\n"); 19 | prints("C " + KtoC(k) + "\n"); 20 | prints("F " + KtoF(k) + "\n"); 21 | prints("R " + KtoR(k) + "\n"); 22 | 0 23 | } 24 | 25 | func main(k : float) -> int 26 | { 27 | convertK(k); 28 | 0 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample428.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Result { Ok { value : int; }, Err { msg : string; } } 3 | 4 | func divide(n : int, d : int) -> Result 5 | { 6 | Result::Ok(n / d) 7 | } 8 | catch (division_by_zero) 9 | { 10 | Result::Err("division by zero\n") 11 | } 12 | 13 | func main() -> int 14 | { 15 | let r = match divide(10, 0) 16 | { 17 | Result::Ok(value) -> value; 18 | Result::Err(msg) -> { prints(msg); -1 }; 19 | }; 20 | 21 | assert(r == -1); 22 | 23 | 0 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample20.nev: -------------------------------------------------------------------------------- 1 | 2 | func min(a : float, b : float) -> float 3 | { 4 | (a < b) ? a : b 5 | } 6 | 7 | func funGen(a : float, b : float, f1(a : float, b : float) -> float) -> float 8 | { 9 | 2.0 * f1(a, b) 10 | } 11 | 12 | func funGen2(f1(a : float, b : float) -> float) -> (a : float, b : float) -> float 13 | { 14 | func twice(a : float, b : float) -> float 15 | { 16 | 2.0 * f1(a, b) 17 | }; 18 | twice 19 | } 20 | 21 | func main() -> bool 22 | { 23 | assert(funGen2(min)(15.0, 20.0) == 30.0) 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /sample/sample236.nev: -------------------------------------------------------------------------------- 1 | 2 | func three(d : int, c : int) -> int 3 | { 4 | let t = 12 + 17 / d; 5 | 17 6 | } 7 | 8 | func two(d : int) -> int 9 | { 10 | three(d, 199); 11 | assert(false); 12 | 0 13 | } 14 | catch (wrong_array_size) 15 | { 16 | 0 17 | } 18 | catch (index_out_of_bounds) 19 | { 20 | d + 102 21 | } 22 | catch (division_by_zero) 23 | { 24 | 155 25 | } 26 | 27 | func one(d : int) -> int 28 | { 29 | two(d) 30 | } 31 | 32 | func main() -> bool 33 | { 34 | assert(one(0) == 155) 35 | } 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /sample/sample291.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : [_] : int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | prints("[" + cl[i][0] + ", " + cl[i][1] + "]\n") 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(v1[D1] : int, v2[D2] : int) -> [_] : [_] : int 15 | { 16 | [ [x, y] : int | x in v1; y in v2 ] : [_] : int 17 | } 18 | 19 | func main() -> int 20 | { 21 | var v1 = [1, 2, 3, 4] : int; 22 | var v2 = [1, 2, 3, 4, 5, 6] : int; 23 | 24 | print_cl(cl(v1, v2)) 25 | } 26 | 27 | -------------------------------------------------------------------------------- /sample/sample600.nev: -------------------------------------------------------------------------------- 1 | func foo(a : int, b : int) -> int 2 | { 3 | let a = 100; 4 | 5 | 10 6 | } 7 | 8 | func test(a : int, b : int) -> int 9 | { 10 | let i = 10; 11 | let j = 20; 12 | 13 | i; 14 | j; 15 | i + j; 16 | 17 | var c = 0; 18 | 19 | c = i; 20 | print(c); 21 | c = j; 22 | print(c); 23 | c = i + j; 24 | print(c); 25 | 26 | print(i); 27 | print(j); 28 | print(i + j); 29 | 30 | 0 31 | } 32 | 33 | func main() -> int 34 | { 35 | test(0, 0); 36 | 37 | 0 38 | } 39 | -------------------------------------------------------------------------------- /sample/sample141.nev: -------------------------------------------------------------------------------- 1 | 2 | func rodCut( to : int ) -> int 3 | { 4 | func from_to( i : int, to : int, val : int ) -> int 5 | { 6 | i < to ? from_to( i + 1, to, print(i) ) : to 7 | } 8 | func cuts( to : int) -> int 9 | { 10 | func __cuts( i : int, to : int, val : int ) -> int 11 | { 12 | i < to ? __cuts( i + 1, to - i - 1, from_to( 0, to, 0 ) ) : to 13 | }; 14 | __cuts( 0, to, 0 ) 15 | }; 16 | cuts( to ) 17 | } 18 | 19 | func main() -> int 20 | { 21 | rodCut( 8 ) 22 | } 23 | 24 | -------------------------------------------------------------------------------- /sample/sample237.nev: -------------------------------------------------------------------------------- 1 | 2 | func three(d : int, c : int) -> int 3 | { 4 | let f = let func(p : int) -> int { (p + 10) / p }; 5 | 6 | f(d) 7 | } 8 | 9 | func two(d : int) -> int 10 | { 11 | three(d, 199) 12 | } 13 | catch (wrong_array_size) 14 | { 15 | 0 16 | } 17 | catch (index_out_of_bounds) 18 | { 19 | d + 102 20 | } 21 | catch (division_by_zero) 22 | { 23 | 155 24 | } 25 | 26 | func one(d : int) -> int 27 | { 28 | two(d) 29 | } 30 | 31 | func main() -> bool 32 | { 33 | assert(one(0) == 155) 34 | } 35 | 36 | 37 | 38 | -------------------------------------------------------------------------------- /sample/sample340.nev: -------------------------------------------------------------------------------- 1 | 2 | enum EONE { 3 | one, 4 | two, 5 | three, 6 | four 7 | } 8 | 9 | enum ETWO { 10 | one, 11 | two, 12 | three, 13 | four 14 | } 15 | 16 | func g1() -> EONE 17 | { 18 | EONE::four 19 | } 20 | 21 | func e1(a : EONE, b : EONE) -> string 22 | { 23 | if (a == g1()) 24 | { 25 | prints("OK\n") 26 | } 27 | else 28 | { 29 | prints("NOK\n") 30 | } 31 | } 32 | 33 | func main() -> int 34 | { 35 | prints(e1(EONE::four, EONE::three)); 36 | 37 | 0 38 | } 39 | 40 | -------------------------------------------------------------------------------- /sample/sample349.nev: -------------------------------------------------------------------------------- 1 | 2 | record P { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func testRLC() -> [_] : P 8 | { 9 | [ P(x, y) | x in [ 1, 2, 3 ] : int; y in [ 10, 20, 30 ] : int ] : P 10 | } 11 | 12 | func printRLC( RLC[D] : P ) -> int 13 | { 14 | var i = 0; 15 | 16 | for (i = 0; i < D; i = i + 1) 17 | { 18 | prints(RLC[i].x + " " + RLC[i].y + "\n") 19 | }; 20 | 21 | 0 22 | } 23 | 24 | 25 | func main() -> int 26 | { 27 | let rlc = testRLC(); 28 | 29 | printRLC(rlc); 30 | 31 | 0 32 | } 33 | 34 | -------------------------------------------------------------------------------- /sample/sample416.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional { Some{ value : int; }, None } 3 | 4 | func getF(o : Optional) -> () -> () -> int 5 | { 6 | if let ( Optional::Some(value) = o) 7 | { 8 | let func() -> () -> int { let func() -> int { value } } 9 | } 10 | else 11 | { 12 | let func() -> () -> int { let func() -> int { 1000 } } 13 | } 14 | } 15 | 16 | func main() -> int 17 | { 18 | var o = Optional::Some(10); 19 | o = Optional::None; 20 | 21 | assert(getF(o)()() == 1000); 22 | 23 | 0 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /sample/sample607.nev: -------------------------------------------------------------------------------- 1 | 2 | 3 | func f1(i : int) -> int 4 | { 5 | print(i); 6 | 0 7 | } 8 | 9 | func pT( t[D] : int, [ F .. T ] : range ) -> int 10 | { 11 | print(F); 12 | print(T); 13 | 14 | F = 40; 15 | T = 60; 16 | 17 | for (a in t) 18 | print(a); 19 | 20 | 0 21 | } 22 | 23 | func main() -> int 24 | { 25 | var F = 20; 26 | var T = 30; 27 | var r = [ F .. T ]; 28 | var t = [ 100, 200, 300, 400 ] : int; 29 | 30 | pT(t, r ); 31 | 32 | print(F); 33 | print(T); 34 | 35 | 0 36 | } 37 | -------------------------------------------------------------------------------- /sample/sample615.nev: -------------------------------------------------------------------------------- 1 | record R 2 | { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func getR(i : int) -> R 8 | { 9 | var r = R(i, i); 10 | r 11 | } 12 | 13 | func main() -> int 14 | { 15 | var i = 20; 16 | let r = getR(i); 17 | 18 | func processR(r : R) -> int 19 | { 20 | printR(r); 21 | 0 22 | } 23 | func printR(r : R) -> int 24 | { 25 | prints(r.x + " " + r.y + "\n"); 26 | 0 27 | }; 28 | 29 | processR(r); 30 | 31 | assert(r.x == 20 && r.y == 20); 32 | 33 | 0 34 | } 35 | -------------------------------------------------------------------------------- /sample/sample162.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[row, col] : int ) -> int 3 | { 4 | func __printtab( i : int, tab[row, col] : int, val : int ) -> int 5 | { 6 | i < row * col ? 7 | __printtab( i + 1, tab, print( tab[i / col, i % col] )) : 0 8 | }; 9 | __printtab ( 0, tab, 0 ) 10 | } 11 | 12 | func main() -> int 13 | { 14 | printtab( [[ 1, 2, 3 ], 15 | [ 3, 4, 5 ]] : int 16 | * 17 | [[ 3, 4 ], 18 | [ 6, 7 ], 19 | [ 8, 2 ]] : int ) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample160.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[row, col] : int ) -> int 3 | { 4 | func __printtab( i : int, tab[row, col] : int, val : int ) -> int 5 | { 6 | i < row * col ? 7 | __printtab( i + 1, tab, print( tab[i / col, i % col] )) : 0 8 | }; 9 | __printtab ( 0, tab, 0 ) 10 | } 11 | 12 | func main() -> int 13 | { 14 | printtab( [[ 1, 2, 3 ], 15 | [ 3, 4, 5 ]] : int 16 | * 17 | [[ 3, 4, 1, 1 ], 18 | [ 6, 7, 1, 1 ], 19 | [ 8, 2, 1, 1 ]] : int ) 20 | } 21 | 22 | -------------------------------------------------------------------------------- /sample/sample233.nev: -------------------------------------------------------------------------------- 1 | 2 | func three(d : int, c : int) -> int 3 | { 4 | var t = [ 1, 2, 3 ] : int; 5 | 6 | t[0] = d; 7 | 17770 / d 8 | } 9 | 10 | func two(d : int) -> int 11 | { 12 | three(d, 199) 13 | } 14 | catch (wrong_array_size) 15 | { 16 | 0 17 | } 18 | catch (index_out_of_bounds) 19 | { 20 | d + 102 21 | } 22 | 23 | func one(d : int) -> int 24 | { 25 | two(d) 26 | } 27 | 28 | func main() -> int 29 | { 30 | one(0); 31 | assert(false); 32 | 0 33 | } 34 | catch (division_by_zero) 35 | { 36 | 155 37 | } 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /sample/sample289.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : (int) -> int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i](2)) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl(z : int) -> [_] : (int) -> int 15 | { 16 | [ let func(v : int) -> int 17 | { 18 | let c = z; 19 | c + v * u 20 | } 21 | 22 | | 23 | 24 | u in [ 1, 10, 100, 1000 ] : int 25 | 26 | ] : (int) -> int 27 | } 28 | 29 | func main() -> int 30 | { 31 | print_cl(cl(10000)) 32 | } 33 | 34 | -------------------------------------------------------------------------------- /sample/sample377.nev: -------------------------------------------------------------------------------- 1 | 2 | func test(a : char, b : char, c : char) -> int 3 | { 4 | var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n"; 5 | 6 | assert(a == 'A'); 7 | assert(b == 'B'); 8 | assert(c == 'C'); 9 | 10 | assert(str[0] == 'A'); 11 | assert(str[1] == 'B'); 12 | assert(str[2] == 'C'); 13 | assert(str[25] == 'Z'); 14 | 15 | /* str[0] = 'X'; */ 16 | 17 | prints(str); 18 | 19 | 0 20 | } 21 | 22 | func main() -> int 23 | { 24 | var s = "ABC"; 25 | 26 | test(s[0], s[1], s[2]); 27 | 28 | 0 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample304.nev: -------------------------------------------------------------------------------- 1 | 2 | record Tree { 3 | value : int; 4 | left : Tree; 5 | right : Tree; 6 | } 7 | 8 | func get_Tree(value : int) -> Tree 9 | { 10 | let t = Tree(value, nil, nil); 11 | t 12 | } 13 | 14 | func print_Tree(t1 : Tree) -> int 15 | { 16 | print(t1.value); 17 | 0 18 | } 19 | catch (nil_pointer) 20 | { 21 | prints("nil pointer exception\n"); 22 | 0 23 | } 24 | 25 | func main() -> int 26 | { 27 | let t = get_Tree(110); 28 | 29 | print_Tree(t); 30 | print_Tree(get_Tree(120)); 31 | 32 | 0 33 | } 34 | 35 | -------------------------------------------------------------------------------- /sample/sample320.nev: -------------------------------------------------------------------------------- 1 | 2 | record Point { 3 | x : int; 4 | y : int; 5 | } 6 | 7 | func get(var r : Point) -> int 8 | { 9 | r.x = 100; 10 | r.y = 200; 11 | 12 | 0 13 | } 14 | 15 | func printr(r : Point) -> int 16 | { 17 | prints("[" + r.x + ", " + r.y + "]\n"); 18 | 19 | 0 20 | } 21 | 22 | func test() -> int 23 | { 24 | var r = Point(0, 0); 25 | 26 | get(r); 27 | 28 | assert(r.x == 100); 29 | assert(r.y == 200); 30 | 31 | 0 32 | } 33 | 34 | func main() -> int 35 | { 36 | test(); 37 | 38 | 0 39 | } 40 | 41 | -------------------------------------------------------------------------------- /sample/sample449.nev: -------------------------------------------------------------------------------- 1 | 2 | func pr_slice( d1 : int, s[from..to] : int ) -> int 3 | { 4 | let d2 = 0; 5 | 6 | print(from); 7 | print(to); 8 | 9 | for (i in [0..to]) 10 | { 11 | print(s[i]) 12 | }; 13 | 14 | assert(from == 0); 15 | assert(to == 5); 16 | 17 | 0 18 | } 19 | 20 | func main() -> int 21 | { 22 | let i = 0; 23 | let arr = [ 10, 11, 12, 13, 14, 15 ] : int; 24 | var slice1 = arr[ 1 .. 4 ]; 25 | let slice2 = arr[ 0 .. 5 ]; 26 | 27 | slice1 = slice2; 28 | 29 | pr_slice(0, slice1); 30 | 31 | 0 32 | } 33 | -------------------------------------------------------------------------------- /appveyor.yml: -------------------------------------------------------------------------------- 1 | version: 1.0.{build} 2 | install: 3 | - cd c:\ 4 | # Install Flex / Bison 5 | - appveyor DownloadFile https://sourceforge.net/projects/winflexbison/files/old_versions/win_flex_bison-2.5.6.zip 6 | - 7z x win_flex_bison-2.5.6.zip > nul 7 | build_script: 8 | - cd c:\projects\never 9 | - mkdir build 10 | - cd build 11 | 12 | - cmake -G"Visual Studio 14" -DMSVC_RUNTIME=static -DCMAKE_BUILD_TYPE=Debug -DFLEX_EXECUTABLE:FILEPATH=c:/win_flex.exe -DBISON_EXECUTABLE:FILEPATH=c:/win_bison.exe .. 13 | - cmake --build . --config %CMAKE_BUILD_TYPE% 14 | -------------------------------------------------------------------------------- /sample/sample27.nev: -------------------------------------------------------------------------------- 1 | func g_no(n : float) -> float 2 | { 3 | -2.0 * n 4 | } 5 | 6 | func mutrec(n : float) -> float 7 | { 8 | func A(no(float) -> float, n : float) -> float 9 | { 10 | (n == 1.0) ? B(1.0, no) : no(n) 11 | } 12 | 13 | func B(n : float, no(float) -> float) -> float 14 | { 15 | (n == 1.0) ? A(no, 10.0) : 12.0 16 | } 17 | 18 | func C(n : float) -> float 19 | { 20 | A(g_no, n) 21 | }; 22 | 23 | C(n) 24 | } 25 | 26 | func main() -> bool 27 | { 28 | assert(mutrec(1.0) == -20.0) 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample290.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : (int) -> int) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | print(cl[i](2)) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl() -> [_] : (int) -> int 15 | { 16 | let z = 10000; 17 | 18 | [ let func(v : int) -> int 19 | { 20 | let c = z; 21 | c + v * u 22 | } 23 | 24 | | 25 | 26 | u in [ 1, 10, 100, 1000 ] : int 27 | 28 | ] : (int) -> int 29 | } 30 | 31 | func main() -> int 32 | { 33 | print_cl(cl()) 34 | } 35 | 36 | -------------------------------------------------------------------------------- /sample/sample383.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four, five, six } 3 | 4 | func getE(e : E) -> int 5 | { 6 | var v = 1; 7 | 8 | v = match e 9 | { 10 | E::three -> 3; 11 | E::two -> 2; 12 | E::one -> 1; 13 | else -> 4; 14 | }; 15 | 16 | v 17 | } 18 | 19 | func main() -> int 20 | { 21 | assert(getE(E::one) == 1); 22 | assert(getE(E::two) == 2); 23 | assert(getE(E::three) == 3); 24 | assert(getE(E::four) == 4); 25 | assert(getE(E::five) == 4); 26 | assert(getE(E::six) == 4); 27 | 28 | 0 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample26.nev: -------------------------------------------------------------------------------- 1 | func no(n : float) -> float 2 | { 3 | n 4 | } 5 | 6 | func mutrec(n : float, no(float) -> float) -> float 7 | { 8 | func A(no(float) -> float, n : float) -> float 9 | { 10 | (n == 1.0) ? B(1.0, no) : 87.0 11 | } 12 | 13 | func B(n : float, no(float) -> float) -> float 14 | { 15 | (n == 1.0) ? A(no, 10.0) : 12.0 16 | } 17 | 18 | func C(n : float) -> float 19 | { 20 | A(no, n) 21 | }; 22 | 23 | C(n) 24 | } 25 | 26 | func main() -> bool 27 | { 28 | assert(mutrec(1.0, no) == 87.0) 29 | } 30 | 31 | -------------------------------------------------------------------------------- /sample/sample620.nev: -------------------------------------------------------------------------------- 1 | 2 | enum U 3 | { 4 | ONE 5 | { 6 | i : int; 7 | f(var i : int) -> int; 8 | }, 9 | 10 | TWO 11 | { 12 | m : string; 13 | } 14 | } 15 | 16 | func getU() -> U 17 | { 18 | U::ONE(10, let func(var i : int) -> int { i = 10 * i }) 19 | } 20 | 21 | func getUE() -> U 22 | { 23 | U::TWO("error\n") 24 | } 25 | 26 | func main() -> int 27 | { 28 | match getUE() 29 | { 30 | U::ONE(i, f) -> { var i = 2; print(i); f(i); print(i) }; 31 | U::TWO(m) -> { prints(m); 0 }; 32 | }; 33 | 34 | 0 35 | } 36 | 37 | -------------------------------------------------------------------------------- /sample/sample14.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * loads of global variables 3 | */ 4 | func fun0(a0 : float, b0 : float) -> float 5 | { 6 | func fun1(a1 : float, b1 : float) -> float 7 | { 8 | func fun2(a2 : float, b2 : float) -> float 9 | { 10 | func fun3(a3 : float, b3 : float) -> float 11 | { 12 | a0 + a1 + a2 + a3 + b0 + b1 + b2 + b3 13 | }; 14 | fun3(a2, b2) 15 | }; 16 | fun2(a1, b1) 17 | }; 18 | fun1(a0, b0) 19 | } 20 | 21 | func main() -> bool 22 | { 23 | assert(fun0(2.0, 3.0) == 20.0) 24 | } 25 | 26 | -------------------------------------------------------------------------------- /sample/sample294.nev: -------------------------------------------------------------------------------- 1 | 2 | func print_cl(cl[D] : float) -> int 3 | { 4 | var i = 0; 5 | 6 | for (i = 0; i < D; i = i + 1) 7 | { 8 | printf(cl[i]) 9 | }; 10 | 11 | 0 12 | } 13 | 14 | func cl() -> [_] : float 15 | { 16 | func grad(d : float) -> float 17 | { 18 | d * 2.0 * 3.14159265 / 360.0 19 | }; 20 | 21 | [ f(y) | f in [ sin, cos ] : (float) -> float; 22 | y in [ grad(0.0), grad(30.0), grad(45.0), grad(60.0), grad(90.0) ] : float ] : float 23 | } 24 | 25 | func main() -> int 26 | { 27 | print_cl(cl()) 28 | } 29 | 30 | -------------------------------------------------------------------------------- /sample/sample411.nev: -------------------------------------------------------------------------------- 1 | 2 | enum Optional_Func { Some { f() -> int; }, None } 3 | 4 | func one() -> int 5 | { 6 | prints("function one\n"); 7 | 0 8 | } 9 | 10 | func exec(f : Optional_Func) -> int 11 | { 12 | match f 13 | { 14 | Optional_Func::Some(f) -> f(); 15 | Optional_Func::None -> { prints("no function\n"); 0 }; 16 | } 17 | } 18 | 19 | func main() -> int 20 | { 21 | exec(Optional_Func::Some(one)); 22 | exec(Optional_Func::Some(let func() -> int { prints("lambda zero\n"); 0 })); 23 | exec(Optional_Func::None); 24 | 25 | 0 26 | } 27 | 28 | 29 | -------------------------------------------------------------------------------- /sample/sample394.nev: -------------------------------------------------------------------------------- 1 | 2 | enum E { one, two, three, four } 3 | 4 | func test(e : E) -> () -> int 5 | { 6 | match e 7 | { 8 | E::one -> let func() -> int { 100 + 10 + 20 }; 9 | E::two -> let func() -> int { 200 + 10 + 20 }; 10 | E::three -> let func() -> int { 300 + 10 + 20 }; 11 | E::four -> let func() -> int { 400 + 10 + 20 }; 12 | } 13 | } 14 | 15 | func main() -> int 16 | { 17 | assert(test(E::one)() == 130); 18 | assert(test(E::two)() == 230); 19 | assert(test(E::three)() == 330); 20 | assert(test(E::four)() == 430); 21 | 22 | 0 23 | } 24 | 25 | -------------------------------------------------------------------------------- /sample/sample7.nev: -------------------------------------------------------------------------------- 1 | /** 2 | * Passing function and calling returned function. 3 | */ 4 | func twice(c1 : float, c2 : float) -> (float, float) -> float 5 | { 6 | func mult() -> float 7 | { 8 | c2 == 0.0 ? 0.0 : c1 / c2 9 | } 10 | 11 | func twice_func(a : float, b : float) -> float 12 | { 13 | func twice_func_nest(a : float, b : float) -> float 14 | { 15 | mult() 16 | }; 17 | twice_func_nest(a, b) 18 | }; 19 | 20 | twice_func 21 | } 22 | 23 | func main() -> float 24 | { 25 | twice(12.0, 3.0)(10.0, 20.0) 26 | } 27 | 28 | 29 | -------------------------------------------------------------------------------- /sample/lib/EN.nev: -------------------------------------------------------------------------------- 1 | 2 | module EN 3 | { 4 | use EM 5 | 6 | enum E { ZERO, 7 | ONE = E::ZERO + 1, 8 | TWO = F::TWO, 9 | THREE = E::TWO + 1 } 10 | 11 | enum F { ZERO = 0, 12 | ONE, 13 | TWO = E::ONE + 1, 14 | THREE = E::THREE } 15 | 16 | record R { i : int; j : int; } 17 | 18 | let a = 10; 19 | 20 | func two() -> int 21 | { 22 | 2 23 | } 24 | 25 | func one() -> int 26 | { 27 | EM.ONE 28 | } 29 | 30 | func three() -> int 31 | { 32 | 3 33 | } 34 | } 35 | 36 | -------------------------------------------------------------------------------- /sample/sample152.nev: -------------------------------------------------------------------------------- 1 | 2 | func printtab( tab[row, col] : float ) -> int 3 | { 4 | func __printtab( i : int, tab[row, col] : float, val : float ) -> int 5 | { 6 | i < row * col ? 7 | __printtab( i + 1, tab, printf( tab[i / col, i % col] )) : 0 8 | }; 9 | __printtab ( 0, tab, 0.0 ) 10 | } 11 | 12 | func main() -> int 13 | { 14 | printtab( [[ 1.0, 2.0 ], 15 | [ 3.0, 4.0 ], 16 | [ 5.0, 6.0 ]] : float 17 | - 18 | [[ 3.0, 3.0 ], 19 | [ 3.0, 3.0 ], 20 | [ 3.0, 3.0 ]] : float ) 21 | } 22 | 23 | --------------------------------------------------------------------------------