Native OCaml Rego/OPA policy engine
rego: add ast.mli and lexer.mli (merlint E505)
Lexer state is abstract — added positions accessor for callers.
+120
-1
+101
lib/ast.mli
+101
lib/ast.mli
···
1
+
(** Rego AST.
2
+
3
+
From the OPA Policy Reference grammar. *)
4
+
5
+
type span = { offset : int; line : int; col : int; len : int }
6
+
(** Source location for error reporting. *)
7
+
8
+
val dummy_span : span
9
+
(** [dummy_span] is the empty source location. *)
10
+
11
+
(** {1 Operators} *)
12
+
13
+
type arith_op = Add | Sub | Mul | Div | Mod
14
+
type bool_op = Lt | Le | Eq | Ge | Gt | Ne
15
+
type bin_op = Intersection | Union
16
+
type assign_op = Assign | ColonEq
17
+
18
+
(** {1 Expressions} *)
19
+
20
+
type expr =
21
+
| Null of span
22
+
| Bool of span * bool
23
+
| Number of span * float
24
+
| String of span * string
25
+
| RawString of span * string
26
+
| Var of span * string
27
+
| Array of span * expr list
28
+
| Set of span * expr list
29
+
| Object of span * (expr * expr) list
30
+
| ArrayCompr of span * expr * query
31
+
| SetCompr of span * expr * query
32
+
| ObjectCompr of span * expr * expr * query
33
+
| Call of span * expr * expr list
34
+
| UnaryExpr of span * expr
35
+
| RefDot of span * expr * string
36
+
| RefBrack of span * expr * expr
37
+
| ArithExpr of span * arith_op * expr * expr
38
+
| BoolExpr of span * bool_op * expr * expr
39
+
| BinExpr of span * bin_op * expr * expr
40
+
| AssignExpr of span * assign_op * expr * expr
41
+
| Membership of span * expr option * expr * expr
42
+
43
+
and literal =
44
+
| SomeVars of span * string list
45
+
| SomeIn of span * expr option * expr * expr
46
+
| Expr of span * expr
47
+
| NotExpr of span * expr
48
+
| Every of span * string option * string * expr * query
49
+
50
+
and with_modifier = { wm_span : span; wm_ref : expr; wm_as : expr }
51
+
52
+
and literal_stmt = {
53
+
ls_span : span;
54
+
ls_literal : literal;
55
+
ls_with_mods : with_modifier list;
56
+
}
57
+
58
+
and query = { q_span : span; q_stmts : literal_stmt list }
59
+
60
+
type rule_assign = { ra_span : span; ra_op : assign_op; ra_value : expr }
61
+
62
+
type rule_body = {
63
+
rb_span : span;
64
+
rb_assign : rule_assign option;
65
+
rb_query : query;
66
+
}
67
+
68
+
type rule_head =
69
+
| RuleHeadCompr of span * expr * rule_assign option
70
+
| RuleHeadSet of span * expr * expr option
71
+
| RuleHeadFunc of span * expr * expr list * rule_assign option
72
+
73
+
type rule =
74
+
| RuleSpec of span * rule_head * rule_body list
75
+
| RuleDefault of span * expr * expr list * assign_op * expr
76
+
77
+
type import = { imp_span : span; imp_ref : expr; imp_as : string option }
78
+
type package = { pkg_span : span; pkg_ref : expr }
79
+
80
+
type rego_module = {
81
+
mod_package : package;
82
+
mod_imports : import list;
83
+
mod_rules : rule list;
84
+
}
85
+
86
+
(** {1 Pretty-printers} *)
87
+
88
+
val pp_arith_op : arith_op Fmt.t
89
+
(** [pp_arith_op] formats an arithmetic operator. *)
90
+
91
+
val pp_bool_op : bool_op Fmt.t
92
+
(** [pp_bool_op] formats a boolean operator. *)
93
+
94
+
val pp_bin_op : bin_op Fmt.t
95
+
(** [pp_bin_op] formats a binary set operator. *)
96
+
97
+
val pp_assign_op : assign_op Fmt.t
98
+
(** [pp_assign_op] formats an assignment operator. *)
99
+
100
+
val pp_span : span Fmt.t
101
+
(** [pp_span] formats a source span as [line:col]. *)
+1
lib/lexer.ml
+1
lib/lexer.ml
···
96
96
type state = { lexbuf : Sedlexing.lexbuf; mutable prev : Parser.token }
97
97
98
98
let v src = { lexbuf = Sedlexing.Utf8.from_string src; prev = Parser.EOF }
99
+
let positions st = Sedlexing.lexing_positions st.lexbuf
99
100
100
101
let rec raw_token lexbuf =
101
102
match%sedlex lexbuf with
+17
lib/lexer.mli
+17
lib/lexer.mli
···
1
+
(** Rego lexer using sedlex. *)
2
+
3
+
exception Error of string
4
+
(** Raised on unrecognized input. *)
5
+
6
+
type state
7
+
(** Lexer state, threading through the previous token for automatic
8
+
semicolon insertion. *)
9
+
10
+
val v : string -> state
11
+
(** [v src] creates a fresh lexer state from a source string. *)
12
+
13
+
val token : state -> Parser.token
14
+
(** [token st] returns the next token. *)
15
+
16
+
val positions : state -> Lexing.position * Lexing.position
17
+
(** [positions st] returns the start and end positions of the current token. *)