ast

Documentation

Overview

Package ast holds ast related files

Index

• type ArithmeticElement
• type ArithmeticOperation
• type Array
• type ArrayComparison
• type BitOperation
• type BooleanExpression
• type CIDRMember
• type Comparison
• type Expression
• type Macro
• type ParsingContext
  • func NewParsingContext() *ParsingContext
  • func (pc *ParsingContext) ParseMacro(expr string) (*Macro, error)
  • func (pc *ParsingContext) ParseRule(expr string) (*Rule, error)
• type Primary
• type Rule
• type ScalarComparison
• type StringMember
• type Unary

Types

type ArithmeticElement

type ArithmeticElement struct {
	Op      string        `parser:"@( \"+\" | \"-\" )"`
	Operand *BitOperation `parser:"@@"`
}

ArithmeticElement defines an arithmetic element

type ArithmeticOperation

type ArithmeticOperation struct {
	Pos lexer.Position

	First *BitOperation        `parser:"@@"`
	Rest  []*ArithmeticElement `parser:"[ @@ { @@ } ]"`
}

ArithmeticOperation describes an arithmetic operation

type Array

type Array struct {
	Pos lexer.Position

	CIDR          *string        `parser:"@CIDR"`
	Variable      *string        `parser:"| @Variable"`
	Ident         *string        `parser:"| @Ident"`
	StringMembers []StringMember `parser:"| \"[\" @@ { \",\" @@ } \"]\""`
	CIDRMembers   []CIDRMember   `parser:"| \"[\" @@ { \",\" @@ } \"]\""`
	Numbers       []int          `parser:"| \"[\" @Int { \",\" @Int } \"]\""`
}

Array describes an array of values

type ArrayComparison

type ArrayComparison struct {
	Pos lexer.Position

	Op    *string `parser:"( @( \"in\" | \"not\" \"in\" | \"allin\" )"`
	Array *Array  `parser:"@@ )"`
}

ArrayComparison describes an operation that tests membership in an array

type BitOperation

type BitOperation struct {
	Pos lexer.Position

	Unary *Unary        `parser:"@@"`
	Op    *string       `parser:"[ @( \"&\" | \"|\" | \"^\" )"`
	Next  *BitOperation `parser:"@@ ]"`
}

BitOperation describes an operation on bits

type BooleanExpression

type BooleanExpression struct {
	Pos lexer.Position

	Expression *Expression `parser:"@@"`
}

BooleanExpression describes a boolean expression

type CIDRMember

type CIDRMember struct {
	Pos lexer.Position

	IP   *string `parser:"@IP"`
	CIDR *string `parser:"| @CIDR"`
}

CIDRMember describes a CIDR based array member

type Comparison

type Comparison struct {
	Pos lexer.Position

	ArithmeticOperation *ArithmeticOperation `parser:"@@"`
	ScalarComparison    *ScalarComparison    `parser:"[ @@"`
	ArrayComparison     *ArrayComparison     `parser:"| @@ ]"`
}

Comparison describes a comparison

type Expression

type Expression struct {
	Pos lexer.Position

	Comparison *Comparison        `parser:"@@"`
	Op         *string            `parser:"[ @( \"|\" \"|\" | \"or\" | \"&\" \"&\" | \"and\" )"`
	Next       *BooleanExpression `parser:"@@ ]"`
}

Expression describes an expression

type Macro

type Macro struct {
	Pos lexer.Position

	Expression *Expression `parser:"@@"`
	Array      *Array      `parser:"| @@"`
	Primary    *Primary    `parser:"| @@"`
}

Macro describes a SECL macro

type ParsingContext

type ParsingContext struct {
	// contains filtered or unexported fields
}

ParsingContext defines a parsing context

func NewParsingContext

func NewParsingContext() *ParsingContext

NewParsingContext returns a new parsing context

func (*ParsingContext) ParseMacro

func (pc *ParsingContext) ParseMacro(expr string) (*Macro, error)

ParseMacro parses a SECL macro

func (*ParsingContext) ParseRule

func (pc *ParsingContext) ParseRule(expr string) (*Rule, error)

ParseRule parses a SECL rule.

type Primary

type Primary struct {
	Pos lexer.Position

	Ident         *string     `parser:"@Ident"`
	CIDR          *string     `parser:"| @CIDR"`
	IP            *string     `parser:"| @IP"`
	Number        *int        `parser:"| @Int"`
	Variable      *string     `parser:"| @Variable"`
	String        *string     `parser:"| @String"`
	Pattern       *string     `parser:"| @Pattern"`
	Regexp        *string     `parser:"| @Regexp"`
	Duration      *int        `parser:"| @Duration"`
	SubExpression *Expression `parser:"| \"(\" @@ \")\""`
}

Primary describes a single operand. It can be a simple identifier, a number, a string or a full expression in parenthesis

type Rule

type Rule struct {
	Pos  lexer.Position
	Expr string

	BooleanExpression *BooleanExpression `parser:"@@"`
}

Rule describes a SECL rule

type ScalarComparison

type ScalarComparison struct {
	Pos lexer.Position

	Op   *string     `parser:"@( \">\" \"=\" | \">\" | \"<\" \"=\" | \"<\" | \"!\" \"=\" | \"=\" \"=\" | \"=\" \"~\" | \"!\" \"~\" )"`
	Next *Comparison `parser:"@@"`
}

ScalarComparison describes a scalar comparison : the operator with the right operand

type StringMember

type StringMember struct {
	Pos lexer.Position

	String  *string `parser:"@String"`
	Pattern *string `parser:"| @Pattern"`
	Regexp  *string `parser:"| @Regexp"`
}

StringMember describes a String based array member

type Unary

type Unary struct {
	Pos lexer.Position

	Op      *string  `parser:"( @( \"!\" | \"not\" | \"-\" | \"^\" )"`
	Unary   *Unary   `parser:"@@ )"`
	Primary *Primary `parser:"| @@"`
}

Unary describes an unary operation like logical not, binary not, minus