lucette

const (
	BooleAnd BooleOp = iota
	BooleOr
)

const (
	ComparatorLT  ComparatorKind = iota // Comparator is `LT'.
	ComparatorLTE                       // Comparator is `LTE'.
	ComparatorGT                        // Comparator is `GT'.
	ComparatorGTE                       // Comparator is `GTE'.
	ComparatorEQ                        // Comparator is `EQ'.
	ComparatorNEQ                       // Comparator is `NEQ'.
)

const (
	FTKeyword FieldType = iota
	FTText
	FTNumeric
	FTDateTime
	FTIP
)

const (
	LString    LiteralKind = iota // Literal is a string.
	LNumber                       // Literal is a number.
	LUnbounded                    // Literal has no value bound to it.
)

const (
	// This modifier will mark the predicate to which it is attached as
	// having a required value.  If the value is not present, then the
	// predicate will fail.
	ModRequire ModifierKind = iota

	// This modifier will mark the predicate to which it is attached as
	// having a prohibited value.  If the value is present, then the
	// predicate will fail.
	ModProhibit
)

const (

	// No operation.
	OpNoOp OpCode = iota

	// Return the contents of the accumulator.
	//
	// `RET: <- ACC`
	OpReturn

	// Special instruction used by the code generator to mark a
	// program location as a label for use by the jump instructions.
	//
	// This instruction is not part of the bytecode.  It is removed
	// when the label resolver processes code for jump addresses.
	//
	// Should it be included in a bytecode instruction stream, it will
	// equate to a NOP.
	OpLabel

	// Jump to label.
	//
	// `JMP lbl: (jump)`
	OpJump

	// Jump to label if accumulator is zero.
	//
	// `JZ lbl: (jump if ACC == 0)`
	OpJumpZ

	// Jump to label if accumulator is non-zero.
	//
	// `JNZ lbl: (jump if ACC > 0)`
	OpJumpNZ

	// Negate the value in the accumulator.
	//
	// `NOT: `ACC <- !ACC`
	OpNot

	// Load an immediate into accumulator.
	//
	// `LDA imm: ACC <- imm`
	OpLoadA

	// Load a field ID into the field register.
	//
	// `LDFLD fid: `FIELD <- fid`
	OpLoadField

	// Load a value into the boost register.
	//
	// `LDBST imm: `BOOST <- imm`
	OpLoadBoost

	// Load a value into the fuzzy register.
	//
	// `LDFZY imm: `FUZZY <- imm`
	OpLoadFuzzy

	// Compare the current field to the given string constant for
	// equality.
	//
	// Stores the result in the accumulator.
	//
	// `EQ.S sIdx: ACC <- field[FIELD} == string[sIdx]`
	OpStringEQ

	// Compare the current field to the given string constant for
	// inequality.
	//
	// Stores the result in the accumulator.
	//
	// `EQ.S sIdx: ACC <- field[FIELD} != string[sIdx]`
	OpStringNEQ

	// Test whether the current field has the given string constant as
	// a prefix.
	//
	// Stores the result in the accumulator.
	//
	// `PFX.S sIdx: ACC <- HasPrefix(field[FIELD], string[sIdx])`
	OpPrefix

	// Test whether the current field matches the given glob pattern.
	//
	// Stores the result in the accumulator.
	//
	// `GLB.S sIdx: ACC <- MatchesGlob(field[FIELD], string[sIdx])`
	OpGlob

	// Perform a regular expression match of the current field against
	// the given regular expression constant.
	//
	// Stores the result in the accumulator.
	//
	// `REX.S rIdx: ACC <- MatchesRexeg(field[FIELD], regex[rIdx])`
	OpRegex

	// Test whether the current field contains the given string constant
	// as a phrase.
	//
	// If non-zero, the `prox` argument specifies maximum Levenshtein
	// distance (proximity) allowed for a match.
	//
	// Stores the result in the accumulator.
	//
	// `PHR.S sIdx: ACC <- MatchesPhrase(field[FIELD], string[sIdx])`
	OpPhrase

	// Test whether the current field has any value at all.
	//
	// Stores the result in the accumulator.
	//
	// `ANY: ACC <- HasAnyValue(field[FIELD])`
	OpAny

	// Test whether the current field has equality with the given
	// number constant.
	//
	// Stores the result in the accumulator.
	//
	// `EQ.N nIdx: ACC <- (field[FIELD] == number[nIdx])`
	OpNumberEQ

	// Test whether the current field has inequality with the given
	// number constant.
	//
	// Stores the result in the accumulator.
	//
	// `NEQ.N nIdx: ACC <- (field[FIELD] != number[nIdx])`
	OpNumberNEQ

	// Test whether the current field has a value that is lesser than
	// the given number constant.
	//
	// Stores the result in the accumulator.
	//
	// `LT.N nIdx: ACC <- (field[FIELD] < number[nIdx])
	OpNumberLT

	// Test whether the current field has a value that is lesser than or
	// equal to the given number constant.
	//
	// Stores the result in the accumulator.
	//
	// `LTE.N nIdx: ACC <- (field[FIELD] <= number[nIdx])
	OpNumberLTE

	// Test whether the current field has a value that is greater than
	// the given number constant.
	//
	// Stores the result in the accumulator.
	//
	// `GT.N nIdx: ACC <- (field[FIELD] > number[nIdx])
	OpNumberGT

	// Test whether the current field has a value that is greater than or
	// equal to the given number constant.
	//
	// Stores the result in the accumulator.
	//
	// `GTE.N nIdx: ACC <- (field[FIELD] >= number[nIdx])
	OpNumberGTE

	// Test whether the current field has a value that falls within the
	// given range.
	//
	// `loIdx` is the starting number in the range.
	// `hiIdx` is the ending number in the range.
	// `incL` is non-zero if the range is to be inclusive at the lowest.
	// `incH' is non-zero if the range is to be inclusive at the highest.
	//
	// Stores the results in the accumulator.
	//
	// RNG.N loIdx hiIdx incL incH: ACC <- inRange(field[field]...)`
	OpNumberRange

	// Test whether the current field has equality with the given
	// date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `EQ.T tIdx: ACC <- (field[FIELD] == time[tIdx])`
	OpTimeEQ

	// Test whether the current field has inequality with the given
	// date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `NEQ.T tIdx: ACC <- (field[FIELD] != time[tIdx])`
	OpTimeNEQ

	// Test whether the current field has a value that is lesser than
	// the given date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `LT.T tIdx: ACC <- (field[FIELD] < time[tIdx])
	OpTimeLT

	// Test whether the current field has a value that is lesser than or
	// equal to the given date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `LTE.T tIdx: ACC <- (field[FIELD] <= time[tIdx])
	OpTimeLTE

	// Test whether the current field has a value that is greater than
	// the given date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `GT.T nIdx: ACC <- (field[FIELD] > time[tIdx])
	OpTimeGT

	// Test whether the current field has a value that is greater than or
	// equal to the given date/time constant.
	//
	// Stores the result in the accumulator.
	//
	// `GTE.T tIdx: ACC <- (field[FIELD] >= timer[tIdx])
	OpTimeGTE

	// Test whether the current field has a value that falls within the
	// given range.
	//
	// `loIdx` is the starting date/time in the range.
	// `hiIdx` is the ending date/time in the range.
	// `incL` is non-zero if the range is to be inclusive at the lowest.
	// `incH' is non-zero if the range is to be inclusive at the highest.
	//
	// Stores the results in the accumulator.
	//
	// RNG.T loIdx hiIdx incL incH: ACC <- inRange(field[field]...)`
	OpTimeRange

	// Test whether the current field has equality with the given
	// IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `EQ.IP ipIdx: ACC <- (field[FIELD] == address[ipIdx])`
	OpIPEQ

	// Test whether the current field has inequality with the given
	// IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `NEQ.IP ipIdx: ACC <- (field[FIELD] != address[ipIdx])`
	OpIPNEQ

	// Test whether the current field has a value that is lesser than
	// the given IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `LT.IP ipIdx: ACC <- (field[FIELD] < address[ipIdx])
	OpIPLT

	// Test whether the current field has a value that is lesser than or
	// equal to the given IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `LTE.IP ipIdx: ACC <- (field[FIELD] <= address[ipIdx])
	OpIPLTE

	// Test whether the current field has a value that is greater than
	// the given IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `GT.IP ipIdx: ACC <- (field[FIELD] > address[ipIdx])
	OpIPGT

	// Test whether the current field has a value that is greater than or
	// equal to the given IP address constant.
	//
	// Stores the result in the accumulator.
	//
	// `GTE.IP ipIdx: ACC <- (field[FIELD] >= address[ipIdx])
	OpIPGTE

	// Test whether the current field has a value that falls within the
	// given range.
	//
	// `loIdx` is the starting IP address in the range.
	// `hiIdx` is the ending IP address in the range.
	// `incL` is non-zero if the range is to be inclusive at the lowest.
	// `incH' is non-zero if the range is to be inclusive at the highest.
	//
	// Stores the results in the accumulator.
	//
	// RNG.IP loIdx hiIdx incL incH: ACC <- inRange(field[field]...)`
	OpIPRange

	// Test whether the current field is within a CIDR range.
	//
	// `IN.CIDR ipIdx, prefix: ACC <- (field[FIELD] = cidr[ipIdx,prefix])`
	OpInCIDR

	// Maximum number of opcode currently supported.
	OpMaximum
)

const (
	PredicateCMP    PredicateKind = iota // Predicate is a comparator.
	PredicateEQS                         // Predicate is `EQ.S'.
	PredicateANY                         // Predicate is `ANY'.
	PredicateGLOB                        // Predicate is `GLOB'.
	PredicateNEQS                        // Predicate is `NEQ.S'.
	PredicatePHRASE                      // Predicate is `PHRASE'.
	PredicatePREFIX                      // Predicate is `PREFIX'.
	PredicateRANGE                       // Predicate is `RANGE'.
	PredicateREGEX                       // Predicate is `REGEX'.
)

const (
	TokenEOF Token = iota // End of file.

	TokenNumber // Numeric value.
	TokenPhrase // String phrase value.
	TokenField  // Field name.
	TokenRegex  // Regular expression.

	TokenPlus     // '+'
	TokenMinus    // '-'
	TokenStar     // '*'
	TokenQuestion // '?'
	TokenLParen   // '('
	TokenLBracket // '['
	TokenLCurly   // '{'
	TokenRParen   // ')'
	TokenRBracket // ']'
	TokenRCurly   // '}'
	TokenColon    // ':'
	TokenTilde    // '~'
	TokenCaret    // '^'

	TokenTo  // 'TO'.
	TokenAnd // 'AND'/'&&'.
	TokenOr  // 'OR'/'||'.
	TokenNot // 'NOT'/'!'.
	TokenLT  // '<'.
	TokenLTE // '<='.
	TokenGT  // '>'
	TokenGTE // '>='

	TokenIllegal // Illegal token.
	TokenUnknown // Unknown token.
)