291 lines
9.3 KiB
Plaintext
291 lines
9.3 KiB
Plaintext
/*
|
|
# Tiger Regex Sampling
|
|
|
|
Program to generate examples from the given regexes.
|
|
*/
|
|
|
|
let /* Utility */
|
|
type bool = int
|
|
var true := 1 = 1
|
|
var false := 1 = 0
|
|
|
|
function read_all_input (): string =
|
|
let var str := ""
|
|
in while true
|
|
do let var char := getchar()
|
|
in str := concat(str, char)
|
|
; if char = ""
|
|
then break
|
|
end
|
|
; str
|
|
end
|
|
|
|
function min (a: int, b: int): int =
|
|
if a < b
|
|
then a
|
|
else b
|
|
|
|
function max (a: int, b: int): int =
|
|
if a > b
|
|
then a
|
|
else b
|
|
|
|
function mod (a: int, b: int): int =
|
|
a - (a / b) * b
|
|
|
|
function i2s (i: int): string =
|
|
/* Negative numbers */
|
|
if i < 0
|
|
then concat("-", i2s(-i))
|
|
|
|
/* Positive numbers */
|
|
else let var digit := chr(ord("0") + mod(i, 10))
|
|
in if i <= 9
|
|
then digit
|
|
else concat(i2s(i/10), digit)
|
|
end
|
|
|
|
function repeat (s: string, n: int): string =
|
|
if 0 < n
|
|
then concat(s, repeat(s, n - 1))
|
|
else ""
|
|
|
|
/* Utility: Random *****/
|
|
|
|
var rand_state := 2^63-1
|
|
|
|
function random (): int =
|
|
/* Generates numbers in the range [0, 2^32[ */
|
|
( rand_state := mod(134775813 * rand_state + 1, 2^32)
|
|
; print("New state: ")
|
|
; print(i2s(rand_state))
|
|
; print("\n")
|
|
; rand_state )
|
|
|
|
function add_entropy (c: int) =
|
|
/* We do not have a lot of entropy in Tiger, so this function
|
|
* adds a little taken as argument */
|
|
( rand_state := rand_state + c
|
|
; random ()
|
|
; () )
|
|
|
|
function rand_in_range (a: int, b: int): int =
|
|
/* TODO: Fix very slight bias towards lower numbers */
|
|
let var r := a + mod(random(), b - a + 1)
|
|
in print("Derp: ")
|
|
; print(i2s(r))
|
|
; print(" in [")
|
|
; print(i2s(a))
|
|
; print("-")
|
|
; print(i2s(b))
|
|
; print("]\n")
|
|
; r
|
|
end
|
|
|
|
/* Regex ******************************************************************/
|
|
|
|
type regex_comp = { typ: int
|
|
, char_first : int
|
|
, char_last : int
|
|
, subexp_1 : regex_comp
|
|
, subexp_2 : regex_comp }
|
|
var REGEX_CHAR_RANGE := 0
|
|
var REGEX_REPEAT := 1
|
|
var REGEX_CONCAT := 2
|
|
|
|
function is_well_formed_regex (r: regex_comp): bool =
|
|
/* Char ranges */
|
|
if r.typ = REGEX_CHAR_RANGE
|
|
then r.char_first <= r.char_last
|
|
& 0 <= r.char_first & r.char_last <= 255
|
|
& r.subexp_1 = nil
|
|
& r.subexp_2 = nil
|
|
|
|
/* Repeating */
|
|
else if r.typ = REGEX_REPEAT
|
|
then 0 <= r.char_first
|
|
& -1 <= r.char_last
|
|
& (r.char_first <= r.char_last | r.char_last = -1)
|
|
& r.subexp_1 <> nil
|
|
& r.subexp_2 = nil
|
|
|
|
/* Concatting */
|
|
else if r.typ = REGEX_CONCAT
|
|
then r.char_first = 0
|
|
& r.char_last = 0
|
|
& r.subexp_1 <> nil
|
|
& r.subexp_2 <> nil
|
|
|
|
/* Unknown regex_comp type */
|
|
else false
|
|
|
|
function format_regex (r: regex_comp): string =
|
|
/* Char ranges */
|
|
if r.typ = REGEX_CHAR_RANGE & r.char_first = r.char_last
|
|
then chr(r.char_first)
|
|
else if r.typ = REGEX_CHAR_RANGE
|
|
then concat("[", concat(chr(r.char_first), concat("-", concat(chr(r.char_last), "]"))))
|
|
|
|
/* Repeating expressions */
|
|
else if r.typ = REGEX_REPEAT
|
|
then let var base_exp_str := concat( "(", concat( format_regex(r.subexp_1), ")"))
|
|
var rep_str :=
|
|
if r.char_first = 0
|
|
& r.char_last = 1
|
|
then "?"
|
|
else if r.char_first = 0
|
|
& r.char_last = -1
|
|
then "*"
|
|
else if r.char_first = 1
|
|
& r.char_last = -1
|
|
then "+"
|
|
|
|
else
|
|
concat( "{",
|
|
concat( i2s(r.char_first),
|
|
concat( if r.char_first <> r.char_last
|
|
then ","
|
|
else "",
|
|
concat( if r.char_last = -1 | r.char_first = r.char_last
|
|
then ""
|
|
else i2s(r.char_last)
|
|
, "}"))))
|
|
|
|
in concat(base_exp_str, rep_str)
|
|
end
|
|
|
|
/* Concat expressions */
|
|
else if r.typ = REGEX_CONCAT
|
|
then let var subexp_1 := format_regex(r.subexp_1)
|
|
var subexp_2 := format_regex(r.subexp_2)
|
|
in concat(subexp_1, subexp_2)
|
|
end
|
|
|
|
/* Unknown range */
|
|
else "%&!"
|
|
|
|
function parse_regex (s: string): regex_comp =
|
|
regex_comp { typ = REGEX_CHAR_RANGE
|
|
, char_first = ord(s)
|
|
, char_last = ord(s)
|
|
, subexp_1 = nil
|
|
, subexp_2 = nil }
|
|
|
|
/** Regex Sampling *********/
|
|
|
|
type strings = array of string
|
|
type samples = { num_samples: int, samples: strings }
|
|
function num_samples(s: samples): int = s.num_samples
|
|
function get_sample(s: samples, i: int): string = s.samples[i]
|
|
function rand_sample(s: samples): string =
|
|
get_sample(s, rand_in_range(0, num_samples(s)-1))
|
|
|
|
function gen_samples (r: regex_comp): samples =
|
|
/* Char ranges */
|
|
if r.typ = REGEX_CHAR_RANGE
|
|
then let var num_samples := min(4, r.char_last - r.char_first + 1)
|
|
var samples := strings[num_samples] of ""
|
|
in for i := 0 to num_samples - 1
|
|
do samples[i] := chr(rand_in_range(r.char_first, r.char_last))
|
|
|
|
; samples { num_samples = num_samples
|
|
, samples = samples }
|
|
end
|
|
|
|
/* Repeating expressions */
|
|
else if r.typ = REGEX_REPEAT
|
|
then let var subsamples := gen_samples(r.subexp_1)
|
|
var max_derps := if r.char_last = -1
|
|
then 8
|
|
else max(r.char_first, min(8, r.char_last))
|
|
var num_samples := min(4, num_samples(subsamples)
|
|
* (max_derps - r.char_first + 1))
|
|
var samples := strings[num_samples] of ""
|
|
in for i := 0 to num_samples - 1
|
|
do ( samples[i] := ""
|
|
; for rep_i := 0 to rand_in_range(r.char_first, min(r.char_last, max_derps)) - 1
|
|
do samples[i] := concat( samples[i]
|
|
, rand_sample(subsamples))
|
|
)
|
|
|
|
; samples { num_samples = num_samples
|
|
, samples = samples }
|
|
end
|
|
|
|
/* Concat expressions */
|
|
else if r.typ = REGEX_CONCAT
|
|
then let var subsamples_1 := gen_samples(r.subexp_1)
|
|
var subsamples_2 := gen_samples(r.subexp_2)
|
|
var num_samples := min(4, num_samples(subsamples_1)
|
|
* num_samples(subsamples_2))
|
|
var samples := strings[num_samples] of ""
|
|
in for i := 0 to num_samples - 1
|
|
do samples[i] := concat( rand_sample(subsamples_1)
|
|
, rand_sample(subsamples_2) )
|
|
|
|
; samples { num_samples = num_samples
|
|
, samples = samples }
|
|
end
|
|
|
|
/* Unknown type */
|
|
else samples { num_samples = -1
|
|
, samples = strings[0] of "" }
|
|
|
|
/** Main program ***********/
|
|
|
|
/* Read input string */
|
|
/*
|
|
var input := read_all_input()
|
|
|
|
/* Parse input as regex */
|
|
var regex := parse_regex(input)
|
|
*/
|
|
var regex := regex_comp { typ = REGEX_CHAR_RANGE
|
|
, char_first = 65
|
|
, char_last = 80
|
|
, subexp_1 = nil
|
|
, subexp_2 = nil }
|
|
|
|
var regex := regex_comp { typ = REGEX_REPEAT
|
|
, char_first = 3
|
|
, char_last = 3
|
|
, subexp_1 = regex
|
|
, subexp_2 = nil }
|
|
/*
|
|
|
|
var regex := regex_comp { typ = REGEX_CONCAT
|
|
, char_first = 0
|
|
, char_last = 0
|
|
, subexp_1 = regex
|
|
, subexp_2 = regex_comp { typ =
|
|
REGEX_CHAR_RANGE, char_first = ord("0"),
|
|
char_last = ord("9"), subexp_1 = nil,
|
|
subexp_2 = nil } }
|
|
|
|
var regex := regex_comp { typ = REGEX_REPEAT
|
|
, char_first = 2
|
|
, char_last = 2
|
|
, subexp_1 = regex
|
|
, subexp_2 = nil }
|
|
*/
|
|
|
|
in /* Add entropy based on input */
|
|
/*
|
|
for i := 0 to size(input)-1
|
|
do add_entropy(ord(substring(input, i, 1)))
|
|
*/
|
|
|
|
/* Generate and print examples */
|
|
let var samples := gen_samples(regex)
|
|
in print("Examples for ")
|
|
; print(format_regex(regex))
|
|
; print(":\n")
|
|
; for i := 0 to num_samples(samples)-1
|
|
do ( print(" - ")
|
|
; print(get_sample(samples, i))
|
|
; print("\n") )
|
|
; 0
|
|
end
|
|
end
|
|
|