pulltab · pulltab · Jun 6, 2016 · Jun 16, 2016 · Jun 16, 2016
diff --git a/include/epddl_types.hrl b/include/epddl_types.hrl
@@ -16,10 +16,20 @@
                      | {bool_op(), bool_expr()}
                      | {bool_multi_op(), list(bool_expr())}.
 
+-type stringExpr() :: binary() | {binary(), [#var{}]}.
+-record(external_effect,
+    {
+      method :: binary(), %%<<"post">> | <<"get">> | <<"put">> | <<"patch">> | <<"delete">>
+      url :: stringExpr(),
+      headers :: stringExpr(),
+      body :: stringExpr()
+    }).
+
 -record(effect,
     {
      delta = true :: true
                      | #predicate{}
+                     | #external_effect{}
                      | {bool_op(), #predicate{}}
                      | {bool_multi_op(), list(#effect{})}
                      | list({float(), #effect{}}),
@@ -41,6 +51,7 @@
 
 -record(domain,
     {id :: undefined | binary(),
+     parameters = [] :: list(binary()),
      requirements = [] :: list(binary()),
      types = [] :: list(binary()),
      predicates = [] :: list(#predicate{}),

diff --git a/src/epddl.erl b/src/epddl.erl
@@ -17,8 +17,32 @@ tokens(Binary) when is_binary(Binary) ->
 
 parse(String) ->
     {ok, Tokens, _} = epddl_tokenizer:string(String),
-    {ok, AST} = epddl_parser:parse(Tokens),
-    AST.
+    Self = self(),
+
+    %% Parsing requires use of global state (ETS).
+    %% As such, we parse within a separate thread to
+    %% ensure this global state is cleaned up properly.
+    ParseFN =
+        fun()->
+            Res =
+                try
+                    epddl_parser:parse(Tokens)
+                catch
+                    _:Reason ->
+                        {error, Reason}
+                end,
+            Self ! {'$epddl_parse', Res}
+        end,
+    Pid = spawn(ParseFN),
+    Ref = erlang:monitor(process, Pid),
+
+    receive
+        {'$epddl_parse', Res} ->
+            Res;
+
+        {_, Ref, process, _, Info} ->
+            {error, {parsing_failed, Info}}
+    end.
 
 parse_file(Filename) ->
 	{ok, FileContents} = read_lines(Filename),

diff --git a/src/epddl_parser.yrl b/src/epddl_parser.yrl
@@ -1,10 +1,10 @@
 Nonterminals    definition
                 domainExpr domainPropList domainProp
-                typesExpr predicatesExpr
                 predicate predicateDef predicateDefList
                 actionDefList actionDef
                 actionPropList actionProp
                 effectExpr effectExprList
+                stringExpr
                 probabilisticEffect probabilisticEffectList
                 timeSpecifier durationConstraints durationConstraint durationConstraintOp
                 varDef varDefList
@@ -27,7 +27,8 @@ Terminals       '(' ')' '-' '=' '<' '>'
                 probabilistic
                 duration
                 number
-                name.
+                name
+                string.
 
 Rootsymbol definition.
 
@@ -39,23 +40,25 @@ domainExpr ->
 domainExpr ->
     '(' domain id ')' domainPropList : to_domain('$3', '$5').
 
-domainProp ->
-    typesExpr : {types, '$1'}.
-domainProp ->
-    predicatesExpr : {predicates, '$1'}.
-domainProp ->
-    actionDefList : {actions, '$1'}.
-
 domainPropList ->
     domainProp : ['$1'].
 domainPropList ->
     domainProp domainPropList : ['$1'|'$2'].
 
-typesExpr ->
-    '(' types idList ')' : require(typing), '$3'.
-
-predicatesExpr ->
-    '(' predicates predicateDefList ')' : '$3'.
+domainProp ->
+    '(' types idList ')' :
+        require(typing),
+        {types, '$3'}.
+domainProp ->
+    '(' predicates predicateDefList ')' :
+        {predicates, '$3'}.
+domainProp ->
+    '(' parameters idList ')' :
+        require('parameterized-domains'),
+        {parameters, '$3'}.
+domainProp ->
+    actionDefList :
+        {actions, '$1'}.
 
 predicateDef ->
     '(' id varDefList ')' : #predicate{id='$2', vars='$3'}.
@@ -136,35 +139,31 @@ effectExpr ->
     '(' boolMultiOp effectExprList ')' : #effect{delta={'$2', '$3'}}.
 effectExpr ->
     '(' probabilistic probabilisticEffectList ')' :
-            require('probabilistic-effects'),
-            ProbEffects = '$3',
-            Sum = fun({Val, _}, Acc) -> Val + Acc end,
-            Total = lists:foldl(Sum, 0, ProbEffects),
-            NewProbEffects =
-                if
-                    Total > 1 ->
-                        %% Constraint violation
-                        error(bad_probabilistic);
-
-                    Total < 1 ->
-                        Diff = 1.0 - Total,
-                        RoundedDiff = round(Diff * math:pow(10, 2)) / math:pow(10, 2),
-                        [{RoundedDiff, #effect{delta=true}}|ProbEffects];
-
-                    true ->
-                        ProbEffects
-                end,
-            #effect{delta=NewProbEffects}.
+        to_probabilistic_effect('$3').
 effectExpr ->
     '(' 'at' timeSpecifier effectExpr ')' :
         Effect = '$4',
         Effect#effect{time = '$3'}.
+effectExpr ->
+    '(' name stringExpr stringExpr stringExpr ')' :
+        to_external_effect(extract('$2'), '$3', '$4', '$5').
 
 effectExprList ->
     effectExpr : ['$1'].
 effectExprList ->
     effectExpr effectExprList : ['$1'|'$2'].
 
+stringExpr ->
+    string : extract('$1').
+stringExpr ->
+    '(' ')' : <<"">>.
+stringExpr ->
+    '(' string ')' :
+        extract('$2').
+stringExpr ->
+    '(' string idList ')' :
+        {extract('$2'), '$3'}.
+
 probabilisticEffect ->
     number effectExpr : {extract('$1'), '$2'}.
 
@@ -265,28 +264,60 @@ require(Req) ->
     ensure_table(?REQUIREMENTS_TID),
     ets:insert(?REQUIREMENTS_TID, {atom_to_binary(Req, utf8), true}).
 
-cleanup() ->
-    try
-        true = ets:delete(?REQUIREMENTS_TID)
-    catch
-        _:_ ->
-            true
-    end.
-
 to_domain(ID, []) ->
-    Domain = #domain{id=ID},
-    cleanup(),
-    Domain;
+    #domain{id=ID};
 to_domain(ID, PropList) ->
     DomainMap = maps:from_list(PropList),
     Requirements = [Req || {Req, true} <- tab2list(?REQUIREMENTS_TID)],
-    Domain =
-        #domain{
-            id = ID,
-            requirements = Requirements,
-            types = maps:get(types, DomainMap, []),
-            predicates = maps:get(predicates, DomainMap, []),
-            actions = maps:get(actions, DomainMap, [])
-        },
-    cleanup(),
-    Domain.
+    #domain{
+        id = ID,
+        requirements = Requirements,
+        parameters = maps:get(parameters, DomainMap, []),
+        types = maps:get(types, DomainMap, []),
+        predicates = maps:get(predicates, DomainMap, []),
+        actions = maps:get(actions, DomainMap, [])
+    }.
+
+to_probabilistic_effect(ProbEffects) ->
+    require('probabilistic-effects'),
+    Sum = fun({Val, _}, Acc) -> Val + Acc end,
+    Total = lists:foldl(Sum, 0, ProbEffects),
+    NewProbEffects =
+        if
+            Total > 1 ->
+                %% Constraint violation
+                error(bad_probabilistic);
+
+            Total < 1 ->
+                Diff = 1.0 - Total,
+                RoundedDiff = round(Diff * math:pow(10, 2)) / math:pow(10, 2),
+                [{RoundedDiff, #effect{delta=true}}|ProbEffects];
+
+            true ->
+                ProbEffects
+        end,
+    #effect{delta=NewProbEffects}.
+
+to_external_effect(Method, URL, Headers, Body) ->
+    require('external-effects'),
+    ValidMethods =
+        [<<"post">>,
+         <<"put">>,
+         <<"patch">>,
+         <<"get">>,
+         <<"delete">>
+        ],
+
+    case lists:member(Method, ValidMethods) of
+        true ->
+            Delta = #external_effect{
+                method=Method,
+                url = URL,
+                headers=Headers,
+                body=Body
+            },
+            #effect{delta=Delta};
+
+        false ->
+            erlang:error({invalid_method, Method})
+    end.
diff --git a/src/epddl_tokenizer.xrl b/src/epddl_tokenizer.xrl
@@ -8,6 +8,7 @@ INT         =   {DIGIT}+
 NUMBER      =   {INT}(\.{INT}+)?
 NAME        =   {LETTER}{CHAR}*
 IDENTIFIER  =   \?{NAME}
+STRING      =   \"(\\.|[^"])*\"
 
 DEFINE          =   define
 DOMAIN          =   domain
@@ -65,6 +66,8 @@ Rules.
 {NUMBER}        : {token, {number, TokenLine, list_to_float(TokenChars)}}.
 {NAME}          : {token, {name, TokenLine, list_to_binary(TokenChars)}}.
 {IDENTIFIER}    : [$?|ID] = TokenChars, {token, {name, TokenLine, list_to_binary(ID)}}.
+{STRING}        : Guts = string:strip(TokenChars, both, $\"),
+                  {token, {string, TokenLine, list_to_binary(Guts)}}.
 
 {WHITESPACE}+   : skip_token.
 

diff --git a/test/epddl_domain_test.erl → test/domain.erl b/test/epddl_domain_test.erl → test/domain.erl
@@ -1,19 +1,19 @@
--module(epddl_domain_test).
+-module(domain).
 
 -include("../include/epddl_types.hrl").
 
 -include_lib("eunit/include/eunit.hrl").
 
 empty_domain_test() ->
     SimpleDomain = "(define (domain foo))",
-    DomainDef = epddl:parse(SimpleDomain),
+    {ok, DomainDef} = epddl:parse(SimpleDomain),
     ?assert(is_record(DomainDef, domain)),
     ?assert(DomainDef#domain.id /= undefined),
     ?assert(DomainDef#domain.id == <<"foo">>).
 
 simple_action_test() ->
     DomainStr = "(define (domain foo) (:action bar :effect ()))",
-    Domain = epddl:parse(DomainStr),
+    {ok, Domain} = epddl:parse(DomainStr),
 
     ?assert(length(Domain#domain.actions) == 1),
     [Bar] = Domain#domain.actions,
@@ -26,7 +26,7 @@ simple_action_test() ->
 
 action_effect_test() ->
     DomainStr = "(define (domain foo) (:action bar :effect (and (loc ?v) (loc ?b) (not (loc ?c ?d)))))",
-    Domain = epddl:parse(DomainStr),
+    {ok, Domain} = epddl:parse(DomainStr),
 
     [Bar] = Domain#domain.actions,
     ?assert(Bar#action.effect /= undefined),
@@ -42,7 +42,7 @@ action_effect_test() ->
 
 action_parameters_test() ->
     DomainStr = "(define (domain foo) (:action bar :parameters (?a ?b ?c)))",
-    Domain = epddl:parse(DomainStr),
+    {ok, Domain} = epddl:parse(DomainStr),
 
     [Bar] = Domain#domain.actions,
 
@@ -53,9 +53,20 @@ action_parameters_test() ->
 
 simple_action_precondition_test() ->
     DomainStr = "(define (domain foo) (:action bar :precondition (and (loc ?x ?y) (isCar ?y))))",
-    Domain = epddl:parse(DomainStr),
+    {ok, Domain} = epddl:parse(DomainStr),
 
     [Bar] = Domain#domain.actions,
     {'and', [Loc, IsCar]} = Bar#action.precondition,
     {predicate, <<"loc">>, [<<"x">>, <<"y">>]} = Loc,
     {predicate, <<"isCar">>, [<<"y">>]} = IsCar.
+
+parameters_test() ->
+    DomainStr = "(define (domain foo) (:parameters ?host ?port) (:action bar :precondition (and (loc ?x ?y) (isCar ?y))))",
+    {ok, Domain} = epddl:parse(DomainStr),
+
+    ?assertMatch([<<"parameterized-domains">>], Domain#domain.requirements),
+
+    Params = Domain#domain.parameters,
+    ?assert(is_list(Params)),
+    ?assert(length(Params) == 2),
+    ?assertMatch([], [<<"host">>, <<"port">>] -- Params).