← Back to branch summary

~eda-qa/leaflang/misc

« back to all changes in this revision

Viewing changes to share/exe_tests/_libs/sys/args.leaf

  • Committer: edA-qa mort-ora-y
  • Date: 2017-05-13 04:00:12 UTC
  • mfrom: (96.1.42 sortfile)
  • Revision ID: eda-qa@disemia.com-20170513040012-ieshuqv2vkjt0xc3
merging sortfile

Show diffs side-by-side

added added

removed removed

Lines of Context:
share/exe_tests/_libs/sys/args.leaf
1
 
alias cstr : array｢abi_char｣ raw
2
 
alias argv_type : array｢cstr｣ raw
 
1
alias cstr : raw_array｢abi_char｣
 
2
alias argv_type : raw_array｢cstr｣
3
3
 
4
4
@import_data("__leaf_argc") var argc : abi_int
5
5
@import_data("__leaf_argv") var argv : argv_type
12
12
        return argv
13
13
}
14
14
 
15
 
import std
16
15
@export var get_args = ()->(r:array｢array｢char｣｣) {
17
 
        r = type｢array｢array｢char｣｣｣(argc-1)
 
16
        r = array｢array｢char｣｣(argc-1)
18
17
        for at in std.range(0,argc-1) {
19
18
                r#at = decode_u8(argv#(at+1))
20
19
        }
24
23
        var len = cstrlen(u8)
25
24
        var out = 0
26
25
        var at = 0
27
 
        str = type｢array｢char｣｣(len)
 
26
        str = array｢char｣(len)
28
27
        loop u8#at != 0 ? {
29
28
                //TODO: will fail with invalid utf-8 (unsafe now, but with safe arrays will be fine)
30
29
                var c = u8#at
31
30
                var val : integer
32
31
                do select(
33
 
                        bit_and( c, 0b1000_0000 ) == 0b0000_0000 ? {
34
 
                                val = bit_and( c, 0b0111_1111 )
 
32
                        (c and 0b1000_0000) == 0b0000_0000 ? {
 
33
                                val = c and 0b0111_1111
35
34
                                at = at + 1
36
35
                        },
37
 
                        bit_and( c, 0b1110_0000 ) == 0b1100_0000 ? {
38
 
                                val = bit_or(
39
 
                                        bit_shl( bit_and( c : binary 32bit, 0b0001_1111 ), 6 ),
40
 
                                        bit_and( 0b0011_1111  : binary 32bit, u8#(at+1) )
 
36
                        (c and 0b1110_0000) == 0b1100_0000 ? {
 
37
                                val = (bit_shl( (c : binary 32bit) and 0b0001_1111, 6 ) or
 
38
                                        ( (0b0011_1111 : binary 32bit) and u8#(at+1) )
41
39
                                )
42
40
                                at = at + 2
43
41
                        },
44
 
                        bit_and( c, 0b1111_0000 ) == 0b1110_0000 ? {
 
42
                        (c and 0b1111_0000) == 0b1110_0000 ? {
45
43
                                at = at + 3
46
44
                        },
47
 
                        bit_and( c, 0b1111_1000 ) == 0b1111_0000 ? {
 
45
                        (c and 0b1111_1000) == 0b1111_0000 ? {
48
46
                                at = at + 4
49
47
                        },
50
48
                )
66
64
defn u8_charlen = (r: binary 8bit)->(:integer) {
67
65
        //TODO: invalid should throw?
68
66
        return select(
69
 
                bit_and( r, 0b1000_0000 ) == 0b0000_0000 ? 1,
70
 
                bit_and( r, 0b1110_0000 ) == 0b1100_0000 ? 2,
71
 
                bit_and( r, 0b1111_0000 ) == 0b1110_0000 ? 3,
72
 
                bit_and( r, 0b1111_1000 ) == 0b1111_0000 ? 4,
 
67
                (r and 0b1000_0000) == 0b0000_0000 ? 1,
 
68
                (r and 0b1110_0000) == 0b1100_0000 ? 2,
 
69
                (r and 0b1111_0000) == 0b1110_0000 ? 3,
 
70
                (r and 0b1111_1000) == 0b1111_0000 ? 4,
73
71
                1
74
72
        )
75
73
}