bad_syntax.sus

// A file for bad or old syntaxes. 
// This is there to check for ICEs


module multiply {
    interface multiply : int a, int b -> int r 
	r = a * b
}

// test
module contains_submodule {
    interface contains_submodule : int a, int b, int c -> int r 
    int tmp = multiply(a, b)
	reg r = tmp + c
}

template<int Size>     
module ExactlyOne {
    interface ExactlyOne : bool[Size] inputs -> bool exactlyOne 
	if Size == 0 {
		exactlyOne = false
	} else if Size == 1 {
	    exactlyOne = inputs[0]
	} else {
	    bool[Size] atLeastOnes
		bool[Size] atLeastTwos
		atLeastOnes[0] = inputs[0]
		atLeastTwos[0] = false
		for i in 1:Size {
			atLeastOnes[i] = atLeastOnes[i-1] | inputs[i]
			atLeastTwos[i] = atLeastTwos[i-1] | atLeastOnes[i-1] & inputs[i]
		}
		exactlyOne = atLeastOnes & !atLeastTwos
	}
}


module parallel_mul_add_reg {
    interface parallel_mul_add_reg : int a, int b -> int p, int q 
    reg int a2 = a * a
	reg int a3 = a * a2 + 3
	reg p = a * a3

	reg int b2 = b + b
	reg int b3 = b + b2
	reg q = b + b3

	// UTF-8 Characters support
	Lööwe 老虎

	
}


/*
    a
	b
	c
	    tmp
	    result
*/

timeline (v v _ -> _) .. (_ _ v -> v)
module mul_add {
    interface mul_add : int a, int b, int c -> int result 
	reg int tmp = a * b
	result = tmp + c
}




/* a module to test the syntax */
module MultiplyAdd {
    interface MultiplyAdd : i32 a, i32 b, i32 c -> i32 result 
	// temporary variable
	i32 tmp = a * b
	result = tmp + cooo * 30 + 5
	array_subscript = tmp
	{
		//[
		beep boop
	}
	@
	int[5] myVar
	myVar[0] = 0
	myVar[1] = 1
	myVar[2] = 2
	myVar[3] = 3
	myVar[4] = 4
	@
}

module beep {
    interface beep : i32 a 
	state i32 beep

	beep = 5
	# 
	beep = a
	
}

timeline (a -> r) .. (/ -> r)
module dwiogo {
    interface dwiogo : bool[512] data -> bool[256] out 
    state bool[256] save = data[256:511]
	out = data[0:255]
	#
	out = save
}



timeline (v, true -> v) .. (/, false -> v) .. (/, false -> v) .. (/, false -> v)
module packer {
    interface packer : bool[256] data /* v _ _ _ */, bool valid -> bool[64] o  /* v v v v */
    state bool[192] save = data[64:256]
	state int part
	initial part = 3
	if valid {
		part = 0
		o = data[0:64]
	} else {
		o = save[part*64 - 64:part*64]
		if part < 3 {
			part = part + 1
		}
	}
}


module multiply_add_old {
    interface multiply_add_old : i32 a, i32 b, i32 c -> i32 result, double double_result 
	i32 tmp = a * b
	reg result = tmp + c
	reg double_result = cvt_to_double(result)
}

module exists {
    interface exists : hello a -> int result 

}

module hello {
    interface hello : int a -> int b }

module test_exists {
    interface test_exists : -> int result 
	int x = exists(5)
	int b = doesnt_exist(3)
}

module exists {
    interface exists : duplicate a 
	// Should be a duplicate of previous exists
}

module use_other_file {
    interface use_other_file : int a -> int r 
	r = hello_from_the_other_side(a)
}


interface maemory_read : int addr -> bool[16] data

//HandShake hs = hs_0

module test_hs {
	state int st = 5

	gen if HA_HANDSHAKE {}
	interface hs {

		interface boop {

		}
	}
	interface process : int[10] data -> int[9] data {
	
	}
}