118 lines
4.6 KiB
OCaml
118 lines
4.6 KiB
OCaml
open Utilities.Aliases
|
|
(*
|
|
1. read file at $XDG_CONFIG_DIR/tori/tori.conf
|
|
2. Parse the line 'su_command = doas' and:
|
|
2.1. if this line is not found, su_command MUST default to 'su -c'
|
|
2.2. if it is found, the su_command used MUST be whatever was specified
|
|
5. Whatever su_command MUST be validated for:
|
|
5.1. presence at the path provided or obtained from $PATH
|
|
5.2. executability
|
|
*)
|
|
type key = SuCommand | Unknown
|
|
type token =
|
|
| Key of key
|
|
| Equal
|
|
| Value of string
|
|
| Space
|
|
| LineBreak
|
|
| Unknown of char
|
|
| End
|
|
|
|
let lex_keyword (chars: char list) (next_index: int): token * int =
|
|
let stop = match List.find_index ((==) '=') chars with
|
|
| Some i -> i
|
|
| None -> assert false (* TODO: Exception 'line has no equals sign' *)
|
|
in
|
|
let literal = String.trim @@ str_chars (List.filteri (fun i _ -> i >= 0 && i < stop) chars) in
|
|
match literal with
|
|
| "su_command" -> Key SuCommand, next_index
|
|
| _ -> Key Unknown, next_index
|
|
|
|
let lex_keyvalue (chars: char list): token * int =
|
|
let length = List.length chars in
|
|
let start = match List.find_index ((==) '=') chars with
|
|
| Some i -> i
|
|
| None -> assert false (* TODO: Exception 'line has no equals sign' *)
|
|
in
|
|
let literal = String.trim @@ str_chars
|
|
(List.filteri (fun i _ -> i >= start + 1 && i < length - 1) chars) in
|
|
Value literal, length - 1
|
|
|
|
let lex_keypair (chars: char list) (index: int): token * int =
|
|
|
|
let boundary =
|
|
match List.find_index ((==) '=') chars with
|
|
| Some b -> b - 1
|
|
| None -> assert false (* TODO: Exception 'line has no equals sign' *)
|
|
in
|
|
let next_index = if index < boundary then boundary else index + 1 in
|
|
let literal = str_chars (List.filteri (fun i _ -> i >= index && i < next_index) chars) in
|
|
elog @@ "[lex_keypair] Index " ^ str_int index ^
|
|
": Found literal '" ^ literal ^
|
|
"', boundary " ^ (str_int boundary) ^
|
|
" next index " ^ (str_int next_index);
|
|
|
|
if index < boundary then
|
|
lex_keyword chars next_index
|
|
else
|
|
lex_keyvalue chars
|
|
|
|
let lex (chars: char list) (index: int): token * int =
|
|
elog @@ "[lex] Index " ^ (str_int index);
|
|
match List.nth chars index with
|
|
| '=' -> Equal, index + 1
|
|
| ' '|'\t' -> Space, index + 1
|
|
| '\n' -> LineBreak, index + 1
|
|
| 'a'..'z'|'~'|'/' -> lex_keypair chars index
|
|
| c -> Unknown c, index + 1
|
|
|
|
let read (path: string): char list list =
|
|
let contents = (System.File.read path) in
|
|
let lines = String.split_on_char '\n' contents in
|
|
let lines = List.mapi (fun i s -> if i+1 < List.length lines then s ^ "\n" else s) lines in
|
|
let rec split (strings: string list) (index: int) (char_lists: char list list) =
|
|
if index == List.length strings then char_lists
|
|
else split strings (index + 1)
|
|
(chars_str (List.nth strings index) :: char_lists)
|
|
in
|
|
List.rev (split lines 0 [])
|
|
|
|
let scan_line (input: char list): token list =
|
|
elog @@ "[scan_line] At " ^ (String.trim @@ str_chars input);
|
|
let rec traverse (chars: char list) (index: int) (tokens: token list) =
|
|
if index == List.length chars then tokens
|
|
else let token, next_index = lex chars index in
|
|
traverse chars next_index (token :: tokens)
|
|
in List.rev (traverse input 0 [])
|
|
|
|
let scan (char_lists: char list list): token list list =
|
|
let rec scan' (char_lists': char list list) (index: int) (token_lists: token list list) =
|
|
if index == List.length char_lists' then [End] :: token_lists
|
|
else scan' char_lists' (index + 1) (scan_line (List.nth char_lists' index) :: token_lists)
|
|
in
|
|
List.rev (scan' char_lists 0 [])
|
|
|
|
let string_of_tokens (tokens: token list list): string =
|
|
let extract (token: token): string =
|
|
match token with
|
|
| Key k -> (match k with
|
|
| SuCommand -> "[ KEY: su_command ]"
|
|
| Unknown -> "[ UNKNOWN KEY ]")
|
|
| Equal -> "[ OP: equal ]"
|
|
| Value v -> "[ VAL: " ^ v ^ " ]"
|
|
| Space -> "{ Space }"
|
|
| LineBreak -> "{ LineBreak }\n"
|
|
| End -> "{ End of File }\n"
|
|
| Unknown s -> (String.make 1 s)
|
|
in
|
|
let rec assemble (tokens: token list) index (output: string) =
|
|
if index == List.length tokens then output
|
|
else assemble tokens (index + 1) (output ^ " " ^ extract (List.nth tokens index))
|
|
in
|
|
let rec traverse (token_lists: token list list) index output: string =
|
|
if index == List.length token_lists then output
|
|
else traverse token_lists (index + 1)
|
|
(assemble (List.nth token_lists index) 0 output)
|
|
in
|
|
traverse tokens 0 " { Start of File }\n"
|
|
|