struct Struct {
  ~uint8 name,
  ~Module methods,
  utils.Vector members,
  int size,

  ~parse.Node _up
}

~uint8 PRIMITIVE_1 = "bool,uint8,int8\0"
~uint8 PRIMITIVE_2 = "uint16,int16\0"
~uint8 PRIMITIVE_4 = "uint32,int32,float32\0"
~uint8 PRIMITIVE_8 = "uint64,int64,float64,int,uint,float,void\0"

/; is_primitive (~parse.Node tn) [int]
	/; if (tn`.sub.count < 1)
		return 0
	;/

	~parse.Node n = tn`.sub.get(0)

	# Check for pointer, array
	/; if (n`._type == parse.NTYPE_PRE_OP)
		return 8
	;/
	
	# Check for ref
	n = tn`.sub.get(tn`.sub.count - 1)
	/; if (n`._type == parse.NTYPE_POST_OP)
		return 8
	;/

	return 0
;/

/; _print_type(~parse.Node tn)
	~parse.Node n
	/; loop (int i = 0; i < tn`.sub.count) [i++]
		/; if (i > 0)
			_printf(".\0")
		;/

		n = tn`.sub.get(i)
		
		/; if (n`._type == parse.NTYPE_ID)
			_printf(n`.data)
		;; else
			return
		;/
	;/
;/

/; method Struct
  
	/; init (~parse.Node node)
		self._up = node
		self.size = 0
		self.methods = NULL
		self.name = utils.strcpy(node`.data)
		Var v
		self.members.init(len v)
	;/

	/; _print (int idt)
		_indent(idt)
		_printf("{ Struct : \0")
		_printf(self.name)
		_printf("\n\0")
		
		_indent(idt)
		_print_num(" size: %d\n\0", self.size)

		_indent(idt)
		_printf(" members:\n\0")

		~Var v
		/; loop (int i = 0; i < self.members.count) [i++]
			v = self.members.get(i)
			v`._print(idt + 1)
		;/

		_indent(idt)
		_printf("}\n\0")
	;/

	/; add_member(~Module parent, ~parse.Node tn, ~parse.Node id)
		Var v
		v.init(tn, id)
		v._resolve_type(parent)
		self.members.push(~v)
	;/

	/; get_member(~uint8 name) [~Var]
		~Var out = NULL

		~Var v
		/; loop (int i = 0; i < self.members.count) [i++]
			v = self.members.get(i)
			/; if (utils.strcmp(v`.name, name) == true)
				return v
			;/
		;/

		return out
	;/

	/; _dlist [~parse.Node]
		~parse.Node up = self._up
		~parse.Node n
		/; loop (int i = 0; i < up`.sub.count) [i++]
			n = up`.sub.get(i)
			/; if (n`._type == parse.NTYPE_DLIST)
				return n
			;/
		;/
		return NULL
	;/

	/; _compute_size (~Module parent)
		/; if (self.size !== 0)
			return
		;/

		self.size = self.size - 1

		int total = 0
		~parse.Node up = self._dlist()
		~parse.Node tn = NULL
		~parse.Node n = NULL
		int add_size = 0
		/; loop (int i = 0; i < up`.sub.count) [i++]
			n = up`.sub.get(i)
			
			/; if (n`._type == parse.NTYPE_TYPE)
				# Store for generating new variables
				tn = n

				# Find type, compute size, set add_size to type size
				~Struct ft = self._find_type(parent, n)
				
				/; if (ft == NULL)
					# Type not found
					_printf("ERROR: Unable to find type '\0")
					_print_type(n)
					_printf("' for use in struct '\0")
					_printf(self.name)
					_printf("'\n\0")
					return
				;/

				/; if (ft`.size == 0)
					# Recurse
					ft`._compute_size(parent)
				;/

				/; if (ft`.size < 0)
					# Cyclical dependency
					return
				;/

				add_size = ft`.size
			;; else if (n`._type == parse.NTYPE_ID)
				/; if (tn == NULL)
					_printf("ERROR: Unable to find type when trying to create member for struct '\0")
					_printf(self.name)
					_printf("\n\0")
					return
				;/
				self.add_member(parent, tn, n)
				total = total + add_size
			;/
		;/

		self.size = total
	;/

	/; _find_type (~Module parent, ~parse.Node tn) [~Struct]
		
		# Init vector of strings
		utils.Vector sv
		sv.init(8)

		~uint8 str
		~parse.Node n
		bool seen_id = false

		/; loop (int i = 0; i < tn`.sub.count) [i++]
			n = tn`.sub.get(i)
			/; if (n`._type == parse.NTYPE_ID)
				str = n`.data
				sv.push(str)
				seen_id = true
			;; else if (seen_id == true)
				i = tn`.sub.count
			;/
		;/

		# Find struct and compute its size
		~Struct out = parent`.find(SEARCH_STRUCT, ~sv)
		sv.pop()
		~Module outp = parent
		/; if (sv.count !== 0)
			outp = parent`.find(SEARCH_SUB, ~sv)
		;/
		sv.end()
		return out
	;/

	/; end
		_delete(self.name)
		~Var v
		/; loop (int i = 0; i < self.members.count) [i++]
			v = self.members.get(i)
			v`.end()
		;/
		self.members.end()
	;/

;/