Skip to content

Commit 835d858

Browse files
pwochnerpwochner
authored
Merge pull request #97 from Herb-AI/utils-grammartags
Remove redundant get_relevant_tags implementations
2 parents 5acf71e + 5c085ed commit 835d858

File tree

8 files changed

+392
-462
lines changed

8 files changed

+392
-462
lines changed

‎src/data/Pixels_2020/pixels_primitives.jl‎

Lines changed: 4 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,10 @@ end
1515
1616
Interprets a program (in form of an AbstractRuleNode) on a given grammar and `IOExample`.
1717
Serves as an entry point that prepares the necessary grammar tags and initial state before
18-
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)`.
18+
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)`.
1919
2020
---
21-
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)
21+
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)
2222
2323
Interprets a program (`prog`) based on a set of grammar tags (`grammartags`) and the current state (`state`).
2424
The functions handles the execution of a program by matching grammar tags to the corresponding functionality.
@@ -27,7 +27,7 @@ function interpret(prog::AbstractRuleNode, grammar::ContextSensitiveGrammar, exa
2727
interpret(prog, get_relevant_tags(grammar), example.in[:in])
2828
end
2929

30-
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::PixelState)
30+
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::PixelState)
3131
rule_node = get_rule(prog)
3232

3333
@match grammartags[rule_node] begin
@@ -52,30 +52,13 @@ function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state:
5252
end
5353
end
5454

55-
"""
56-
Gets relevant symbol to easily match grammar rules to operations in `interpret` function
57-
"""
58-
function get_relevant_tags(grammar::ContextSensitiveGrammar)
59-
tags = Dict{Int,Symbol}()
60-
for (ind, r) in pairs(grammar.rules)
61-
tags[ind] = if typeof(r) == Symbol
62-
r
63-
else
64-
@match r.head begin
65-
:block => :OpSeq
66-
:call => r.args[1]
67-
end
68-
end
69-
end
70-
return tags
71-
end
7255

7356
"""
7457
Custom implementation of a while loop with a condition and a body.
7558
7659
Loop is terminated either when condition is false or when `max_steps` is reached.
7760
"""
78-
function command_while(condition::RuleNode, body::RuleNode, grammartags::Dict{Int,Symbol}, state::PixelState, max_steps::Int=1000)
61+
function command_while(condition::RuleNode, body::RuleNode, grammartags::Dict{Int,Any}, state::PixelState, max_steps::Int=1000)
7962
counter = max_steps
8063
while interpret(condition, grammartags, state) && counter > 0
8164
state = interpret(body, grammartags, state)

‎src/data/Robots_2020/robots_primitives.jl‎

Lines changed: 4 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -17,10 +17,10 @@ end
1717
1818
Interprets a program (in form of an AbstractRuleNode) on a given grammar and `IOExample`.
1919
Serves as an entry point that prepares the necessary grammar tags and initial state before
20-
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)`.
20+
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)`.
2121
2222
---
23-
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)
23+
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)
2424
2525
Interprets a program (`prog`) based on a set of grammar tags (`grammartags`) and the current state (`state`).
2626
The functions handles the execution of a program by matching grammar tags to the corresponding functionality.
@@ -29,7 +29,7 @@ function interpret(prog::AbstractRuleNode, grammar::ContextSensitiveGrammar, exa
2929
interpret(prog, get_relevant_tags(grammar), example.in[:in])
3030
end
3131

32-
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::RobotState)
32+
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::RobotState)
3333
rule_node = get_rule(prog)
3434

3535
@match grammartags[rule_node] begin
@@ -54,32 +54,14 @@ function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state:
5454
end
5555
end
5656

57-
"""
58-
Gets relevant symbol to easily match grammar rules to operations in `interpret` function
59-
"""
60-
function get_relevant_tags(grammar::ContextSensitiveGrammar)
61-
tags = Dict{Int,Symbol}()
62-
for (ind, r) in pairs(grammar.rules)
63-
tags[ind] = if typeof(r) == Symbol
64-
r
65-
else
66-
@match r.head begin
67-
:block => :OpSeq
68-
:call => r.args[1]
69-
end
70-
end
71-
end
72-
return tags
73-
end
74-
7557
can_pickup(state::RobotState) = state.holds_ball == 0 && state.robot_x == state.ball_x && state.robot_y == state.ball_y
7658

7759
"""
7860
Custom implementation of a while loop with a condition and a body.
7961
8062
Loop is terminated either when condition is false or when `max_steps` is reached.
8163
"""
82-
function command_while(condition::RuleNode, body::RuleNode, grammartags::Dict{Int,Symbol}, state::RobotState, max_steps::Int=1000)
64+
function command_while(condition::RuleNode, body::RuleNode, grammartags::Dict{Int,Any}, state::RobotState, max_steps::Int=1000)
8365
counter = max_steps
8466
while interpret(condition, grammartags, state) && counter > 0
8567
tag = grammartags[get_rule(body)]

‎src/data/String_transformations_2020/string_primitives.jl‎

Lines changed: 4 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -18,10 +18,10 @@ Base.length(st::StringState) = length(st.str)
1818
1919
Interprets a program (in form of an AbstractRuleNode) on a given grammar and `IOExample`.
2020
Serves as an entry point that prepares the necessary grammar tags and initial state before
21-
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)`.
21+
calling `interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)`.
2222
2323
---
24-
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)
24+
interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)
2525
2626
Interprets a program (`prog`) based on a set of grammar tags (`grammartags`) and the current state (`state`).
2727
The functions handles the execution of a program by matching grammar tags to the corresponding functionality.
@@ -30,7 +30,7 @@ function interpret(prog::AbstractRuleNode, grammar::ContextSensitiveGrammar, exa
3030
interpret(prog, get_relevant_tags(grammar), example.in[:_arg_1])
3131
end
3232

33-
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState)
33+
function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState)
3434
rule_node = get_rule(prog)
3535

3636
@match grammartags[rule_node] begin
@@ -61,30 +61,13 @@ function interpret(prog::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state:
6161

6262
end
6363

64-
"""
65-
Gets relevant symbol to easily match grammar rules to operations in `interpret` function
66-
"""
67-
function get_relevant_tags(grammar::ContextSensitiveGrammar)
68-
tags = Dict{Int,Symbol}()
69-
for (ind, r) in pairs(grammar.rules)
70-
tags[ind] = if typeof(r) == Symbol
71-
r
72-
else
73-
@match r.head begin
74-
:block => :OpSeq
75-
:call => r.args[1]
76-
end
77-
end
78-
end
79-
return tags
80-
end
8164

8265
"""
8366
Custom implementation of a while loop with a condition and a body.
8467
8568
Loop is terminated either when condition is false or when `max_steps` is reached.
8669
"""
87-
function command_while(condition::AbstractRuleNode, body::AbstractRuleNode, grammartags::Dict{Int,Symbol}, state::StringState, max_steps::Int=1000)
70+
function command_while(condition::AbstractRuleNode, body::AbstractRuleNode, grammartags::Dict{Int,Any}, state::StringState, max_steps::Int=1000)
8871
counter = max_steps
8972
while interpret(condition, grammartags, state) && counter > 0
9073
state = interpret(body, grammartags, state)

‎src/data/SyGuS/PBE_SLIA_Track_2019/string_functions.jl‎

Lines changed: 24 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -32,48 +32,29 @@ leq_cvc(str1::String, str2::String) = cmp(str1, str2) <= 0
3232

3333
isdigit_cvc(str::String) = tryparse(Int, str) !== nothing
3434

35-
"""
36-
Gets relevant symbol to easily match grammar rules to operations in `interpret` function
37-
"""
38-
function get_relevant_tags(grammar::ContextSensitiveGrammar)
39-
tags = Dict{Int,Any}()
40-
for (ind, r) in pairs(grammar.rules)
41-
tags[ind] = if typeof(r) != Expr
42-
r
43-
else
44-
@match r.head begin
45-
:block => :OpSeq
46-
:call => r.args[1]
47-
:if => :IF
48-
end
49-
end
50-
end
51-
return tags
52-
end
53-
5435
function interpret_sygus(prog::AbstractRuleNode, grammar_tags::Dict{Int,Any})
55-
r = get_rule(prog)
56-
c = get_children(prog)
57-
58-
MLStyle.@match grammar_tags[r] begin
59-
:concat_cvc => concat_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
60-
:replace_cvc => replace_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
61-
:at_cvc => at_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
62-
:int_to_str_cvc => int_to_str_cvc(interpret_sygus(c[1], grammar_tags))
63-
:substr_cvc => substr_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
64-
:len_cvc => len_cvc(interpret_sygus(c[1], grammar_tags))
65-
:str_to_int_cvc => str_to_int_cvc(interpret_sygus(c[1], grammar_tags))
66-
:indexof_cvc => indexof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
67-
:prefixof_cvc => prefixof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
68-
:suffixof_cvc => suffixof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
69-
:contains_cvc => contains_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
70-
71-
:+ => interpret_sygus(c[1], grammar_tags) + interpret_sygus(c[2], grammar_tags)
72-
:- => interpret_sygus(c[1], grammar_tags) - interpret_sygus(c[2], grammar_tags)
73-
:(==) => interpret_sygus(c[1], grammar_tags) == interpret_sygus(c[2], grammar_tags)
74-
75-
:IF => interpret_sygus(c[1], grammar_tags) ? interpret_sygus(c[2], grammar_tags) : interpret_sygus(c[3], grammar_tags)
76-
77-
_ => grammar_tags[r]
78-
end
36+
r = get_rule(prog)
37+
c = get_children(prog)
38+
39+
MLStyle.@match grammar_tags[r] begin
40+
:concat_cvc => concat_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
41+
:replace_cvc => replace_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
42+
:at_cvc => at_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
43+
:int_to_str_cvc => int_to_str_cvc(interpret_sygus(c[1], grammar_tags))
44+
:substr_cvc => substr_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
45+
:len_cvc => len_cvc(interpret_sygus(c[1], grammar_tags))
46+
:str_to_int_cvc => str_to_int_cvc(interpret_sygus(c[1], grammar_tags))
47+
:indexof_cvc => indexof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags), interpret_sygus(c[3], grammar_tags))
48+
:prefixof_cvc => prefixof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
49+
:suffixof_cvc => suffixof_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
50+
:contains_cvc => contains_cvc(interpret_sygus(c[1], grammar_tags), interpret_sygus(c[2], grammar_tags))
51+
52+
:+ => interpret_sygus(c[1], grammar_tags) + interpret_sygus(c[2], grammar_tags)
53+
:- => interpret_sygus(c[1], grammar_tags) - interpret_sygus(c[2], grammar_tags)
54+
:(==) => interpret_sygus(c[1], grammar_tags) == interpret_sygus(c[2], grammar_tags)
55+
56+
:IF => interpret_sygus(c[1], grammar_tags) ? interpret_sygus(c[2], grammar_tags) : interpret_sygus(c[3], grammar_tags)
57+
58+
_ => grammar_tags[r]
59+
end
7960
end

‎test/runtests.jl‎

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -4,11 +4,12 @@ using HerbSpecification
44
using Test
55

66
@testset "HerbBenchmarks.jl" verbose = true begin
7-
include("test_general.jl")
8-
include("test_string_transformations_2020.jl")
9-
include("test_robots_2020.jl")
10-
include("test_pixels_2020.jl")
11-
include("test_abstract_reasoning_2019.jl")
12-
include("test_problem_fetcher.jl")
13-
include("test_sexpression_parsing.jl")
7+
include("test_general.jl")
8+
include("test_string_transformations_2020.jl")
9+
include("test_robots_2020.jl")
10+
include("test_pixels_2020.jl")
11+
include("test_abstract_reasoning_2019.jl")
12+
include("test_problem_fetcher.jl")
13+
include("test_sexpression_parsing.jl")
1414
end
15+
#

0 commit comments

Comments
 (0)