Hojun-Cho
d456263f7e
The r-prefixed waves absorb the runtime, reject, and byte-compare rows of the migrated native carriers; each fixture is one directory with one case.ww and a //ww:error, //ww:compile, //ww:run, or //ww:run-exit directive covering both frontends.
189 lines
8.4 KiB
Plaintext
189 lines
8.4 KiB
Plaintext
//ww:run
|
|
package main;
|
|
|
|
type p2t = struct { x: i64, y: i64 };
|
|
type s6 = struct { a: i64, b: i64, c: i64, d: i64, e: i64, f: i64 };
|
|
type cell = (s6 | bool);
|
|
type inst_lit = rune;
|
|
type inst_split = i64;
|
|
type inst = (inst_lit | inst_split);
|
|
type un_size_void = (size | void);
|
|
type un_void_size = (void | size);
|
|
type un_str_void = (str | void);
|
|
type minrep_split = size;
|
|
type minrep_un = (minrep_split | void);
|
|
|
|
fn i64_front() i32 = {
|
|
let xs: []i64 = []; append(xs, 7); append(xs, 11); append(xs, 13);
|
|
insert(xs[0], 5); return (xs[0] + xs[1]*10): i32 + len(xs)*10;
|
|
};
|
|
fn i64_middle() i32 = {
|
|
let xs: []i64 = []; append(xs, 7); append(xs, 11); append(xs, 13);
|
|
insert(xs[1], 5); return (xs[0] + xs[1]*10): i32 + len(xs)*10;
|
|
};
|
|
fn i64_end() i32 = {
|
|
let xs: []i64 = []; append(xs, 7); append(xs, 11); append(xs, 13);
|
|
insert(xs[3], 5); return (xs[0] + xs[1]*10): i32 + len(xs)*10;
|
|
};
|
|
fn end_insert_len() i32 = {
|
|
let xs: []i64 = []; append(xs, 7); append(xs, 11); insert(xs[len(xs)], 13);
|
|
if (len(xs) != 3) { return 1; }; return xs[2]: i32;
|
|
};
|
|
fn pregrow_len_idx() i32 = {
|
|
let xs: []i64 = []; append(xs, 7); append(xs, 11); insert(xs[len(xs)-1], 13);
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0] != 7) { return 2; }; if (xs[1] != 13) { return 3; };
|
|
if (xs[2] != 11) { return 4; }; return 48;
|
|
};
|
|
fn i32_narrow() i32 = {
|
|
let xs: []i32 = []; append(xs, 4i32); append(xs, 2i32); insert(xs[1], 9i32);
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0] != 4i32) { return 2; }; if (xs[1] != 9i32) { return 3; };
|
|
if (xs[2] != 2i32) { return 4; }; return 42;
|
|
};
|
|
fn u16_narrow() i32 = {
|
|
let xs: []u16 = []; append(xs, 4u16); append(xs, 2u16); insert(xs[1], 9u16);
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0] != 4u16) { return 2; }; if (xs[1] != 9u16) { return 3; };
|
|
if (xs[2] != 2u16) { return 4; }; return 43;
|
|
};
|
|
fn u8_narrow() i32 = {
|
|
let xs: []u8 = []; append(xs, 5u8); append(xs, 3u8); insert(xs[0], 2u8);
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0] != 2u8) { return 2; }; if (xs[1] != 5u8) { return 3; };
|
|
if (xs[2] != 3u8) { return 4; }; return 44;
|
|
};
|
|
fn empty_insert() i32 = {
|
|
let xs: []i64 = []; insert(xs[0], 5); return xs[0]: i32 + len(xs)*10;
|
|
};
|
|
fn str_elem() i32 = {
|
|
let xs: []str = []; let a: str = "abc"; let g: str = "fghi";
|
|
append(xs, a); append(xs, g); let b: str = "de"; insert(xs[1], b);
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0].len != 3) { return 2; }; if (xs[1].len != 2) { return 3; };
|
|
if (xs[2].len != 4) { return 4; }; return 45;
|
|
};
|
|
fn struct_elem() i32 = {
|
|
let xs: []p2t = [];
|
|
append(xs, p2t { x = 1, y = 2 }); append(xs, p2t { x = 5, y = 6 });
|
|
insert(xs[1], p2t { x = 3, y = 4 });
|
|
if (len(xs) != 3) { return 1; };
|
|
if (xs[0].x != 1 || xs[0].y != 2) { return 2; };
|
|
if (xs[1].x != 3 || xs[1].y != 4) { return 3; };
|
|
if (xs[2].x != 5 || xs[2].y != 6) { return 4; }; return 46;
|
|
};
|
|
fn tagged_56b() i32 = {
|
|
let xs: []cell = [];
|
|
let p0: s6 = s6 { a = 1, b = 2, c = 3, d = 4, e = 5, f = 6 };
|
|
let p2: s6 = s6 { a = 13, b = 14, c = 15, d = 16, e = 17, f = 18 };
|
|
append(xs, p0); append(xs, p2);
|
|
let p1: cell = (s6 { a = 7, b = 8, c = 9, d = 10, e = 11, f = 12 });
|
|
insert(xs[1], p1); let r: i32 = 0;
|
|
match (xs[1]) { case let s: s6 => r = s.a: i32; case bool => r = 99; };
|
|
let bp: *u8 = xs.ptr: *u8; r += (bp[160]: i32) * 10;
|
|
return r + len(xs)*10;
|
|
};
|
|
fn tagged_cast() i32 = {
|
|
let insts: []inst = []; append(insts, ('a': inst_lit)); append(insts, ('b': inst_lit));
|
|
insert(insts[1], (7: inst_split)); if (len(insts) != 3) { return 1; };
|
|
let r: i32 = 0;
|
|
match (insts[1]) { case let z: inst_split => r += z: i32; case => return 2; };
|
|
match (insts[2]) {
|
|
case let l: inst_lit => { if ((l: rune) == 'b') { r += 20; }; };
|
|
case => return 3;
|
|
}; return r;
|
|
};
|
|
fn ins_at(i: i64, p: *[]i64, v: i64) void = { insert((*p)[i], v); };
|
|
fn regex_shape() i32 = {
|
|
let xs: []i64 = []; append(xs, 1); append(xs, 3); ins_at(1, &xs, 2);
|
|
if (len(xs) != 3) { return 1; }; return (xs[0] + xs[1]*10 + xs[2]*50): i32;
|
|
};
|
|
fn insert_in_loop() i32 = {
|
|
let xs: []i64 = []; let v: i64 = 1;
|
|
for (v <= 4) { insert(xs[0], v); v += 1; };
|
|
if (len(xs) != 4) { return 1; }; let k: i32 = 0;
|
|
for (k < 4) { if (xs[k] != (4-k): i64) { return 2+k; }; k += 1; };
|
|
return 47;
|
|
};
|
|
fn tagged_pregrow_val() i32 = {
|
|
let xs: []un_size_void = [];
|
|
append(xs, 10: size); append(xs, 20: size); insert(xs[1], (xs.len: size)+2);
|
|
match (xs[1]) { case let v: size => { if (v != 4) { return (v: i32)+10; }; }; case void => return 2; };
|
|
if (len(xs) != 3) { return 3; }; return 50;
|
|
};
|
|
fn scalar_pregrow_val() i32 = {
|
|
let xs: []size = []; append(xs, 10: size); append(xs, 20: size);
|
|
insert(xs[1], len(xs): size); if (xs[1] != 2) { return 1; };
|
|
if (len(xs) != 3) { return 2; }; return 55;
|
|
};
|
|
fn tagged_selfref_val() i32 = {
|
|
let xs: []un_size_void = [];
|
|
append(xs, 10: size); append(xs, 20: size); insert(xs[0], xs[1]);
|
|
match (xs[0]) { case let v: size => { if (v != 20) { return 1; }; }; case void => return 2; };
|
|
match (xs[1]) { case let v: size => { if (v != 10) { return 3; }; }; case void => return 4; };
|
|
match (xs[2]) { case let v: size => { if (v != 20) { return 5; }; }; case void => return 6; };
|
|
if (len(xs) != 3) { return 7; }; return 51;
|
|
};
|
|
fn tagged_str_payload() i32 = {
|
|
let ss: []un_str_void = []; append(ss, "aa"); insert(ss[0], "bb");
|
|
match (ss[0]) { case let s: str => { if (s.len != 2) { return 1; }; if (s[0] != 'b') { return 2; }; }; case void => return 3; };
|
|
match (ss[1]) { case let s: str => { if (s[0] != 'a') { return 4; }; }; case void => return 5; };
|
|
return 52;
|
|
};
|
|
fn tagged_regex_minrep() i32 = {
|
|
let xs: []minrep_un = [];
|
|
append(xs, 7: minrep_split); append(xs, 8: minrep_split); insert(xs[0], ((xs.len: size)+2): minrep_split);
|
|
match (xs[0]) { case let v: minrep_split => { if (v != 4) { return (v: i32)+10; }; }; case void => return 2; };
|
|
if (len(xs) != 3) { return 3; }; return 53;
|
|
};
|
|
fn tagged_realloc_selfref_loop() i32 = {
|
|
let xs: []un_void_size = []; append(xs, 100: size); let i: size = 0;
|
|
for (i < 30) { append(xs, (xs[0] as size)+i); i += 1; };
|
|
if (len(xs) != 31) { return 1; }; let k: size = 1;
|
|
for (k < 31) {
|
|
match (xs[k]) { case let v: size => { if (v != 100+(k-1)) { return 2; }; }; case void => return 3; };
|
|
k += 1;
|
|
}; return 56;
|
|
};
|
|
fn tagged_append_pregrow_val() i32 = {
|
|
let xs: []un_size_void = [];
|
|
append(xs, 10: size); append(xs, 20: size); append(xs, (xs.len: size)+2);
|
|
match (xs[2]) { case let v: size => { if (v != 4) { return (v: i32)+10; }; }; case void => return 2; };
|
|
if (len(xs) != 3) { return 3; }; return 54;
|
|
};
|
|
fn tagged_seq_positions() i32 = {
|
|
let xs: []un_void_size = [];
|
|
append(xs, 10: size); append(xs, 20: size); insert(xs[0], (xs.len: size)*100);
|
|
match (xs[0]) { case let v: size => { if (v != 200) { return 1; }; }; case void => return 2; };
|
|
insert(xs[2], (xs.len: size)+1);
|
|
match (xs[2]) { case let v: size => { if (v != 4) { return 3; }; }; case void => return 4; };
|
|
match (xs[1]) { case let v: size => { if (v != 10) { return 5; }; }; case void => return 6; };
|
|
match (xs[3]) { case let v: size => { if (v != 20) { return 7; }; }; case void => return 8; };
|
|
if (len(xs) != 4) { return 9; }; return 57;
|
|
};
|
|
fn tagged_void_variant() i32 = {
|
|
let xs: []un_void_size = []; append(xs, 5: size); insert(xs[0], void);
|
|
if (!(xs[0] is void)) { return 1; };
|
|
match (xs[1]) { case let v: size => { if (v != 5) { return 2; }; }; case void => return 3; };
|
|
insert(xs[1], xs.len: size);
|
|
match (xs[1]) { case let v: size => { if (v != 2) { return 4; }; }; case void => return 5; };
|
|
if (len(xs) != 3) { return 6; }; return 58;
|
|
};
|
|
|
|
export fn main() i32 = {
|
|
if (i64_front() != 115) { return 1; }; if (i64_middle() != 97) { return 2; };
|
|
if (i64_end() != 157) { return 3; }; if (end_insert_len() != 13) { return 4; };
|
|
if (pregrow_len_idx() != 48) { return 5; }; if (i32_narrow() != 42) { return 6; };
|
|
if (u16_narrow() != 43) { return 7; }; if (u8_narrow() != 44) { return 8; };
|
|
if (empty_insert() != 15) { return 9; }; if (str_elem() != 45) { return 10; };
|
|
if (struct_elem() != 46) { return 11; }; if (tagged_56b() != 217) { return 12; };
|
|
if (tagged_cast() != 27) { return 13; }; if (regex_shape() != 171) { return 14; };
|
|
if (insert_in_loop() != 47) { return 15; }; if (tagged_pregrow_val() != 50) { return 16; };
|
|
if (scalar_pregrow_val() != 55) { return 17; }; if (tagged_selfref_val() != 51) { return 18; };
|
|
if (tagged_str_payload() != 52) { return 19; }; if (tagged_regex_minrep() != 53) { return 20; };
|
|
if (tagged_realloc_selfref_loop() != 56) { return 21; };
|
|
if (tagged_append_pregrow_val() != 54) { return 22; };
|
|
if (tagged_seq_positions() != 57) { return 23; }; if (tagged_void_variant() != 58) { return 24; };
|
|
return 0;
|
|
};
|