module token

// Token lists token values used by token.
pub enum Token {
	amp        // &
	and        // &&
	and_assign // &=
	arrow      // <-
	assign     // =
	attribute
	bit_not // ~
	char    // `A` - rune
	colon   // :
	comma   // ,
	comment
	dec         // --
	decl_assign // :=
	div         // /
	div_assign  // /=
	dollar      // $
	dot         // .
	dotdot      // ..
	ellipsis    // ...
	eof
	eq   // ==
	ge   // >=
	gt   // >
	hash // #
	inc  // ++
	key_as
	key_asm
	key_assert
	key_atomic
	key_break
	key_const
	key_continue
	key_defer
	key_dump
	key_else
	key_enum
	key_false
	key_fn
	key_for
	key_global
	key_go
	key_goto
	key_if
	key_import
	key_in
	key_interface
	key_is
	key_isreftype
	key_likely
	key_lock
	key_match
	key_module
	key_mut
	key_nil
	key_none
	key_offsetof
	key_or
	key_pub
	key_return
	key_rlock
	key_select
	key_shared
	key_sizeof
	key_spawn
	key_static
	key_struct
	key_true
	key_type
	key_typeof
	key_union
	key_unlikely
	key_unsafe
	key_volatile
	lcbr                        // {
	le                          // <=
	left_shift                  // <<
	left_shift_assign           // >>=
	logical_or                  // ||
	lpar                        // (
	lsbr                        // [
	lt                          // <
	minus                       // -
	minus_assign                // -=
	mod                         // %
	mod_assign                  // %=
	mul                         // *
	mul_assign                  // *=
	name                        // user
	ne                          // !=
	not                         // !
	not_in                      // !in
	not_is                      // !is
	number                      // 123
	or_assign                   // |=
	pipe                        // |
	plus                        // +
	plus_assign                 // +=
	question                    // ?
	rcbr                        // }
	right_shift                 // >>
	right_shift_assign          // <<=
	right_shift_unsigned        // >>>
	right_shift_unsigned_assign // >>>=
	rpar                        // )
	rsbr                        // ]
	semicolon                   // ;
	str_dollar
	string // 'foo'
	unknown
	xor        // ^
	xor_assign // ^=
}

// BindingPower lists binding power values used by token.
pub enum BindingPower {
	lowest
	logical_or  // ||
	logical_and // &&
	compare     // ==, !=, <, <=, >, >=, in, !in, is, !is
	bit_or      // |
	bit_xor     // ^
	shift       // <<, >>, >>>
	add         // +, -
	product     // *, /, %, &
	highest
}

const token_and_id = 1
const token_arrow_id = 3
const token_assign_id = 4
const token_bit_not_id = 6
const token_dec_id = 11
const token_decl_assign_id = 12
const token_div_id = 13
const token_div_assign_id = 14
const token_eq_id = 20
const token_ge_id = 21
const token_gt_id = 22
const token_inc_id = 24
const token_key_in_id = 44
const token_key_is_id = 46
const token_le_id = 74
const token_left_shift_id = 75
const token_left_shift_assign_id = 76
const token_logical_or_id = 77
const token_lt_id = 80
const token_minus_id = 81
const token_minus_assign_id = 82
const token_mod_id = 83
const token_mod_assign_id = 84
const token_mul_id = 85
const token_mul_assign_id = 86
const token_ne_id = 88
const token_not_id = 89
const token_not_in_id = 90
const token_not_is_id = 91
const token_or_assign_id = 93
const token_pipe_id = 94
const token_plus_id = 95
const token_plus_assign_id = 96
const token_right_shift_id = 99
const token_right_shift_assign_id = 100
const token_right_shift_unsigned_id = 101
const token_right_shift_unsigned_assign_id = 102
const token_xor_id = 109
const token_xor_assign_id = 110

// left_binding_power supports left binding power handling for Token.
@[inline]
pub fn (t Token) left_binding_power() BindingPower {
	tv := int(t)
	if tv == token_logical_or_id {
		return BindingPower.logical_or
	}
	if tv == token_and_id {
		return BindingPower.logical_and
	}
	if tv == token_eq_id || tv == token_ne_id || tv == token_lt_id || tv == token_le_id
		|| tv == token_gt_id || tv == token_ge_id || tv == token_key_in_id || tv == token_not_in_id
		|| tv == token_key_is_id || tv == token_not_is_id {
		return BindingPower.compare
	}
	if tv == token_pipe_id {
		return BindingPower.bit_or
	}
	if tv == token_xor_id {
		return BindingPower.bit_xor
	}
	if tv == token_left_shift_id || tv == token_right_shift_id
		|| tv == token_right_shift_unsigned_id {
		return BindingPower.shift
	}
	if tv == token_plus_id || tv == token_minus_id {
		return BindingPower.add
	}
	if tv == token_mul_id || tv == token_div_id || tv == token_mod_id || tv == 0 {
		return BindingPower.product
	}
	return BindingPower.lowest
}

// right_binding_power supports right binding power handling for Token.
@[inline]
pub fn (t Token) right_binding_power() BindingPower {
	return unsafe { BindingPower((int(t.left_binding_power()) + 1)) }
}

// is_keyword reports whether is keyword applies in token.
@[inline]
pub fn (t Token) is_keyword() bool {
	return int(t) >= int(Token.key_as) && int(t) <= int(Token.key_volatile)
}

// is_prefix reports whether is prefix applies in token.
@[inline]
pub fn (t Token) is_prefix() bool {
	tv := int(t)
	return tv == token_minus_id || tv == 0 || tv == token_and_id || tv == token_mul_id
		|| tv == token_not_id || tv == token_bit_not_id || tv == token_arrow_id
}

// is_infix reports whether is infix applies in token.
@[inline]
pub fn (t Token) is_infix() bool {
	tv := int(t)
	return tv == 0 || tv == token_and_id || tv == token_arrow_id || tv == token_div_id
		|| tv == token_eq_id || tv == token_ge_id || tv == token_gt_id || tv == token_key_in_id
		|| tv == token_key_is_id || tv == token_le_id || tv == token_left_shift_id
		|| tv == token_logical_or_id || tv == token_lt_id || tv == token_minus_id
		|| tv == token_mod_id || tv == token_mul_id || tv == token_ne_id || tv == token_not_in_id
		|| tv == token_not_is_id || tv == token_pipe_id || tv == token_plus_id
		|| tv == token_right_shift_id || tv == token_right_shift_unsigned_id || tv == token_xor_id
}

// is_postfix reports whether is postfix applies in token.
@[inline]
pub fn (t Token) is_postfix() bool {
	tv := int(t)
	return tv == token_dec_id || tv == token_inc_id
}

// is_assignment reports whether is assignment applies in token.
@[inline]
pub fn (t Token) is_assignment() bool {
	tv := int(t)
	return tv == 2 || tv == token_assign_id || tv == token_decl_assign_id
		|| tv == token_div_assign_id || tv == token_left_shift_assign_id
		|| tv == token_minus_assign_id || tv == token_mod_assign_id || tv == token_mul_assign_id
		|| tv == token_or_assign_id || tv == token_plus_assign_id
		|| tv == token_right_shift_assign_id || tv == token_right_shift_unsigned_assign_id
		|| tv == token_xor_assign_id
}

// is_overloadable reports whether is overloadable applies in token.
@[inline]
pub fn (t Token) is_overloadable() bool {
	tv := int(t)
	return tv == token_div_id || tv == token_eq_id || tv == token_ge_id || tv == token_gt_id
		|| tv == token_le_id || tv == token_lt_id || tv == token_minus_id || tv == token_mod_id
		|| tv == token_mul_id || tv == token_ne_id || tv == token_pipe_id || tv == token_plus_id
		|| tv == token_xor_id
}

// is_comparison reports whether is comparison applies in token.
@[inline]
pub fn (t Token) is_comparison() bool {
	tv := int(t)
	return tv == token_eq_id || tv == token_ge_id || tv == token_gt_id || tv == token_key_in_id
		|| tv == token_key_is_id || tv == token_le_id || tv == token_lt_id || tv == token_ne_id
		|| tv == token_not_in_id || tv == token_not_is_id
}

// str returns the string form for Token.
pub fn (t Token) str() string {
	return match t {
		.amp { '&' }
		.and { '&&' }
		.and_assign { '&=' }
		.arrow { '<-' }
		.assign { '=' }
		.attribute { '@[' }
		.bit_not { '~' }
		.char { 'char' }
		.colon { ':' }
		.comma { ',' }
		.comment { '// comment' }
		.dec { '--' }
		.decl_assign { ':=' }
		.div { '/' }
		.div_assign { '/=' }
		.dollar { '$' }
		.dot { '.' }
		.dotdot { '..' }
		.ellipsis { '...' }
		.eof { 'eof' }
		.eq { '==' }
		.ge { '>=' }
		.gt { '>' }
		.hash { '#' }
		.inc { '++' }
		.key_as { 'as' }
		.key_asm { 'asm' }
		.key_assert { 'assert' }
		.key_atomic { 'atomic' }
		.key_break { 'break' }
		.key_const { 'const' }
		.key_continue { 'continue' }
		.key_defer { 'defer' }
		.key_dump { 'dump' }
		.key_else { 'else' }
		.key_enum { 'enum' }
		.key_false { 'false' }
		.key_fn { 'fn' }
		.key_for { 'for' }
		.key_global { '__global' }
		.key_go { 'go' }
		.key_goto { 'goto' }
		.key_if { 'if' }
		.key_import { 'import' }
		.key_in { 'in' }
		.key_interface { 'interface' }
		.key_is { 'is' }
		.key_isreftype { 'isreftype' }
		.key_likely { '_likely_' }
		.key_lock { 'lock' }
		.key_match { 'match' }
		.key_module { 'module' }
		.key_mut { 'mut' }
		.key_nil { 'nil' }
		.key_none { 'none' }
		.key_offsetof { '__offsetof' }
		.key_or { 'or' }
		.key_pub { 'pub' }
		.key_return { 'return' }
		.key_rlock { 'rlock' }
		.key_select { 'select' }
		.key_shared { 'shared' }
		.key_sizeof { 'sizeof' }
		.key_spawn { 'spawn' }
		.key_static { 'static' }
		.key_struct { 'struct' }
		.key_true { 'true' }
		.key_type { 'type' }
		.key_typeof { 'typeof' }
		.key_union { 'union' }
		.key_unlikely { '_unlikely_' }
		.key_unsafe { 'unsafe' }
		.key_volatile { 'volatile' }
		.lcbr { '{' }
		.le { '<=' }
		.left_shift { '<<' }
		.left_shift_assign { '<<=' }
		.logical_or { '||' }
		.lpar { '(' }
		.lsbr { '[' }
		.lt { '<' }
		.minus { '-' }
		.minus_assign { '-=' }
		.mod { '%' }
		.mod_assign { '%=' }
		.mul { '*' }
		.mul_assign { '*=' }
		.name { 'name' }
		.ne { '!=' }
		.not { '!' }
		.not_in { '!in' }
		.not_is { '!is' }
		.number { 'number' }
		.or_assign { '|=' }
		.pipe { '|' }
		.plus { '+' }
		.plus_assign { '+=' }
		.question { '?' }
		.rcbr { '}' }
		.right_shift { '>>' }
		.right_shift_assign { '>>=' }
		.right_shift_unsigned { '>>>' }
		.right_shift_unsigned_assign { '>>>=' }
		.rpar { ')' }
		.rsbr { ']' }
		.semicolon { ';' }
		.str_dollar { '\${' }
		.string { 'string' }
		.unknown { 'unknown' }
		.xor { '^' }
		.xor_assign { '^=' }
	}
}