E | |
email, Keepalived | |
email_addr, Rx | |
empty | |
empty_c_style, Util | |
empty_element, Test_Xml.Xml | |
empty_generic, Util | |
empty1, Test_Xml | |
empty2, Test_Xml | |
empty3, Test_Xml | |
empty4, Test_Xml | |
encrypt, FAI_DiskConfig | |
entries, Syslog | |
ENTRIES | |
ENTRIES AND OPTIONS, Xorg | |
entries_re, Xorg | |
entry | |
Entry, Syslog | |
ENTRY | |
entry includes comments, IniFile | |
ENTRY LINE, Access | |
ENTRY TYPES | |
entry_ace, Test_IniFile | |
entry_acf, Test_IniFile | |
entry_ade, Test_IniFile | |
entry_adf, Test_IniFile | |
entry_bce, Test_IniFile | |
entry_bcf, Test_IniFile | |
entry_bde, Test_IniFile | |
entry_bdf, Test_IniFile | |
entry_generic, Xorg | |
entry_int, Xorg | |
entry_re | |
entry_rgb, Xorg | |
entry_sto, Mke2fs | |
entry_str, Xorg | |
entry_xy, Xorg | |
eol | |
eq, Grub | |
equal, Sep | |
Examples | |
except | |
Exclusions, Util | |
Exports |
A simple email address entry
let email = [ indent . label "email" . sto_email_addr . comment_or_eol ]
To be refined
let email_addr = /[A-Za-z0-9_+.-]+@[A-Za-z0-9_.-]+/
let empty = Util.empty
let empty = Util.empty
let empty = Util.empty
An Util.empty
let empty = Util.empty
A C-style empty line
let empty = Util.empty_c_style
let empty = Util.empty
let empty = Util.empty
let empty = Util.empty
let empty = Util.empty
Empty line, an eol subnode
let empty = [ eol ]
Map empty lines
let empty = Util.empty
let empty = IniFile.empty
let empty = Util.empty
let empty = Util.empty
let empty = Util.empty
Map empty lines, including empty asterisk comments
let empty = [ del /[ \t]*\*?[ \t]*\n/ "\n" ]
Map empty lines
let empty = [ del /[ \t]*#?[ \t]*\n/ "\n" ]
let empty = Util.empty
Map empty lines, including empty comments
let empty = empty_generic /[ \t]*#?[ \t]*/
let empty = Util.empty
Map empty lines, including C-style empty comment
let empty_c_style = empty_generic /[ \t]*((\/\/)|(\/\*[ \t]*\*\/))?[ \t]*/
test Xml.empty_element get empty1 = { "a" = "#empty" }
A generic definition of empty Map empty lines, including empty comments
let empty_generic (r:regexp) = [ del r "" . del_str "\n" ]
let empty1 = "<a/>"
let empty2 = "<a foo=\"bar\"/>"
let empty3 = "<a foo=\"bar\"></a>\n"
let empty4 = "<a foo=\"bar\" far=\"baz\"/>"
encrypt tag
let encrypt = tag "encrypt"
entries are either comments/empty lines or entries
let entries = (empty | comment | entry)*
This is a list of all patterns which have specific handlers, and should therefore not be matched by the generic handler
let entries_re = /([oO]ption|[sS]creen|[iI]nput[dD]evice|[dD]river|[sS]ub[sS]ection|[dD]isplay|[iI]dentifier|[vV]ideo[rR]am|[dD]efault[dD]epth|[dD]evice)/
let entry = IniFile.indented_entry entry_re sep comment
A valid entry line Definition:
let entry = [ access . colon . user_list . (except user_list)? . colon . origin_list . (except origin_list)? . Util.eol ]
An apt.conf entry, recursive
let rec entry_noeol = let value = Util.del_str "\"" . store /[^"\n]+/ . del /";?/ "\";" in let opt_eol = del /[ \t\n]*/ "\n" in let long_eol = del /[ \t]*\n+/ "\n" in let list_elem = [ opt_eol . label "@elem" . value ] in let eol_comment = del /([ \t\n]*\n)?/ "" . comment in [ key name_re . Sep.space . value ] | [ key name_re . del /[ \t\n]*\{/ " {" . ( (opt_eol . entry_noeol) | list_elem | eol_comment )* . del /[ \t\n]*\};?/ "\n};" ] | [ key name_re . Util.del_str "::" . entry_noeol ]
A crontab entry
let entry = [ label "entry" . indent . ( time | schedule ) . sep_spc . user . sep_spc . store Rx.space_in . eol ]
let entry = bool ("multi"|"nospoof"|"spoofalert"|"reorder") | bool_warn "spoof" | list "order" "order" | trim
let entry = [ seq "line" . daemon_list . (except daemon_list)? . colon . client_list . (except client_list)? . (colon . shell_command)? . Util.eol ]
Generic INI File entry
let entry (kw:regexp) (sep:lens) (comment:lens) = [ key kw . sep . sto_to_comment? . (comment|eol) ] | comment
A generic entry for lens lns
let entry (kw:regexp) (lns:lens) = Build.key_value_line kw sep lns
let entry = alias | options | kv_line_command /install|remove/ | blacklist | config
let entry = let alias = [ seq "alias" . store Rx.word ] in [ seq "network" . [ label "name" . store Rx.word ] . [ Sep.space . label "number" . store ipv4 ] . [ Sep.space . label "aliases" . Build.opt_list alias Sep.space ]? . (Util.eol|Util.comment) ]
let entry = [ key "allow" . Sep.space . condition_list . Sep.space . by . Util.eol ]
let entry = nameserver | domain | search | sortlist | options
An IniFile.entry, or description
let entry = IniFile.entry (IniFile.entry_re - "description") sep comment | description
an entry contains selectors and an action
let entry = [ label "entry" . selectors . sep_tab . [ label "action" . action ] . eol ]
A star condition gets mapped as direct value of the “allow” node.
test Reprepro_Uploaders.entry get "allow * by anybody\n" = { "allow" = "*" { "by" = "anybody" } }
let entry_ace = IniFile.entry IniFile.entry_re sep_ace comment_ace
let entry_acf = IniFile.entry IniFile.entry_re sep_acf comment_acf
let entry_ade = IniFile.entry IniFile.entry_re sep_ade comment_ade
let entry_adf = IniFile.entry IniFile.entry_re sep_adf comment_adf
let entry_bce = IniFile.entry IniFile.entry_re sep_bce comment_bce
let entry_bcf = IniFile.entry IniFile.entry_re sep_bcf comment_bcf
let entry_bde = IniFile.entry IniFile.entry_re sep_bde comment_bde
let entry_bdf = IniFile.entry IniFile.entry_re sep_bdf comment_bdf
An entry without a specific handler.
let entry_generic = [ indent . key generic_entry_re . sep_spc . store to_eol . eol ]
This matches an entry which takes a single integer for an argument
let entry_int (canon:string) (re:regexp) = [ indent . del re canon . label canon . sep_spc . store int . eol ]
Regexp for possible entry keyword (path, allow, deny)
let entry_re = /path|allow|deny/
Default regexp for entry keyword
let entry_re = ( /[A-Za-z][A-Za-z0-9._-]+/ )
This matches an entry which takes 3 integers as arguments representing red, green and blue components
let entry_rgb (canon:string) (re:regexp) = [ indent . del re canon . label canon . [ label "red" . sep_spc . store int ] . [ label "green" . sep_spc . store int ] . [ label "blue" . sep_spc . store int ] . eol ]
Store a regexp as entry value
let entry_sto (kw:regexp) (val:regexp) = entry kw (store val)
This matches an entry which takes a single quoted string
let entry_str (canon:string) (re:regexp) = [ indent . del re canon . label canon . sep_spc . quoted_string_val . eol ]
This matches an entry which takes 2 integers as arguments representing X and Y coordinates
let entry_xy (canon:string) (re:regexp) = [ indent . del re canon . label canon . [ label "x" . sep_spc . store int ] . [ label "y" . sep_spc . store int ] . eol ]
let eol = Util.eol
let eol = Util.eol
An Util.eol
let eol = Util.eol
And Util.eol end of line
let eol = Util.eol
let eol = Util.eol
let eol = Util.eol
let eol = Util.eol
let eol = Util.eol
End of line, inherited from Util.eol
let eol = Util.eol
let eol = Util.eol
let eol = del /[ \t]*(#)?[ \t]*\n/ "\n"
let eol = del /[ \t]*\n/ "\n"
let eol = Util.eol
Delete end of line, including optional trailing whitespace
let eol = del /[ \t]*\n/ "\n"
let eol = Util.eol
let eq = dels "="
let equal = Util.del_str "="
The except operator makes it possible to write very compact rules.
let except (lns:lens) = [ label "except" . Sep.space . del /[Ee][Xx][Cc][Ee][Pp][Tt]/ "EXCEPT" . Sep.space . lns ]
The except operator makes it possible to write very compact rules.
let except (lns:lens) = [ label "except" . Sep.space . del /except/i "EXCEPT" . Sep.space . lns ]