Current section
Files
Jump to
Current section
Files
src/ephp_parser_expr.erl
-module(ephp_parser_expr).
-author('manuel@altenwald.com').
-export([expression/3, add_op/2, precedence/1]).
-include("ephp.hrl").
-include("ephp_parser.hrl").
-import(ephp_parser,
[add_pos/2,
new_line/1,
copy_rowcol/2,
add_line/2,
remove_spaces/2,
throw_error/3,
inc_pos/1,
get_line/1,
array_def_level/1,
code_statement_level/1,
arg_level/1,
enclosed_level/1,
variable/3,
comment_line/3,
comment_block/3,
constant/3]).
array_def_54_level(Parser) ->
Parser#parser{level = array_def, array_type = php54}.
add_op('end', []) ->
[];
add_op('end', [{op, [#constant{name = Name, line = RowCol} = Constant]}]) ->
Op = case Name of
<<I:8, N:8, T:8>> when ?OR(I, $i, $I) andalso ?OR(N, $n, $N) andalso ?OR(T, $t, $T) ->
OpL = <<"(int)">>,
{OpL, precedence(OpL), RowCol};
<<I:8, N:8, T:8, E:8, G:8, E:8, R:8>>
when ?OR(I, $i, $I)
andalso ?OR(N, $n, $N)
andalso ?OR(T, $t, $T)
andalso ?OR(E, $e, $E)
andalso ?OR(G, $g, $G)
andalso ?OR(R, $r, $R) ->
OpL = <<"(int)">>,
{OpL, precedence(OpL), RowCol};
<<F:8, L:8, O:8, A:8, T:8>>
when ?OR(F, $F, $f)
andalso ?OR(L, $L, $l)
andalso ?OR(O, $O, $o)
andalso ?OR(A, $A, $a)
andalso ?OR(T, $T, $t) ->
OpL = <<"(float)">>,
{OpL, precedence(OpL), RowCol};
<<D:8, O:8, U:8, B:8, L:8, E:8>>
when ?OR(D, $D, $d)
andalso ?OR(O, $O, $o)
andalso ?OR(U, $U, $u)
andalso ?OR(B, $B, $b)
andalso ?OR(L, $L, $l)
andalso ?OR(E, $E, $e) ->
OpL = <<"(float)">>,
{OpL, precedence(OpL), RowCol};
<<S:8, T:8, R:8, I:8, N:8, G:8>>
when ?OR(S, $S, $s)
andalso ?OR(T, $T, $t)
andalso ?OR(R, $R, $r)
andalso ?OR(I, $I, $i)
andalso ?OR(N, $N, $n)
andalso ?OR(G, $G, $g) ->
OpL = <<"(string)">>,
{OpL, precedence(OpL), RowCol};
% array will be captured in the array() part
<<O:8, B:8, J:8, E:8, C:8, T:8>>
when ?OR(O, $O, $o)
andalso ?OR(B, $B, $b)
andalso ?OR(J, $J, $j)
andalso ?OR(E, $E, $e)
andalso ?OR(C, $C, $c)
andalso ?OR(T, $T, $t) ->
OpL = <<"(object)">>,
{OpL, precedence(OpL), RowCol};
<<B:8, O:8, O:8, L:8, E:8, A:8, N:8>>
when ?OR(B, $B, $b)
andalso ?OR(O, $O, $o)
andalso ?OR(L, $L, $l)
andalso ?OR(E, $E, $e)
andalso ?OR(A, $A, $a)
andalso ?OR(N, $N, $n) ->
OpL = <<"(bool)">>,
{OpL, precedence(OpL), RowCol};
<<B:8, O:8, O:8, L:8>>
when ?OR(B, $B, $b) andalso ?OR(O, $O, $o) andalso ?OR(L, $L, $l) ->
OpL = <<"(bool)">>,
{OpL, precedence(OpL), RowCol};
<<U:8, N:8, S:8, E:8, T:8>>
when ?OR(U, $U, $u)
andalso ?OR(N, $N, $n)
andalso ?OR(S, $S, $s)
andalso ?OR(E, $E, $e)
andalso ?OR(T, $T, $t) ->
OpL = <<"(unset)">>,
{OpL, precedence(OpL), RowCol};
_ ->
Constant
end,
solve([Op]);
add_op('end', [{op, Content}]) ->
solve(process_incr_decr(Content));
add_op(Add, [{op, Content} | Parsed]) when is_list(Add) ->
[{op, Content ++ Add} | Parsed];
add_op(Add, [{op, Content} | Parsed]) ->
[{op, Content ++ [Add]} | Parsed];
add_op(Add, Parsed) ->
[{op, [Add]} | Parsed].
process_incr_decr(Content) ->
process_incr_decr(Content, []).
process_incr_decr([], Processed) ->
Processed;
process_incr_decr([{<<"++">>, _, RowCol}, #variable{} = V | Rest], Processed) ->
process_incr_decr(Rest, Processed ++ [{pre_incr, V, RowCol}]);
process_incr_decr([{<<"--">>, _, RowCol}, #variable{} = V | Rest], Processed) ->
process_incr_decr(Rest, Processed ++ [{pre_decr, V, RowCol}]);
process_incr_decr([#variable{} = V, {<<"++">>, _, RowCol} | Rest], Processed) ->
process_incr_decr(Rest, Processed ++ [{post_incr, V, RowCol}]);
process_incr_decr([#variable{} = V, {<<"--">>, _, RowCol} | Rest], Processed) ->
process_incr_decr(Rest, Processed ++ [{post_decr, V, RowCol}]);
process_incr_decr([A | Rest], Processed) ->
process_incr_decr(Rest, Processed ++ [A]).
number(<<"0", X:8, Rest/binary>>, Parser, []) when ?OR(X, $X, $x) ->
hexa(Rest, add_pos(Parser, 2), []);
number(<<"0", N:8, Rest/binary>>, Parser, []) when ?IS_OCT(N) ->
octa(<<N:8, Rest/binary>>, add_pos(Parser, 2), []);
number(<<A:8, Rest/binary>>, Parser, []) when ?IS_NUMBER(A) orelse A =:= $- ->
number(Rest, inc_pos(Parser), [add_line(#php_n{n = <<A:8>>}, Parser)]);
number(<<A:8, Rest/binary>>, Parser, [#php_n{n = N} = I]) when ?IS_NUMBER(A) ->
number(Rest, inc_pos(Parser), [I#php_n{n = <<N/binary, A:8>>}]);
number(<<".", Rest/binary>>, Parser, []) ->
Exp = add_line(#php_n{n = <<"0.">>, type = float}, Parser),
number(Rest, inc_pos(Parser), [Exp]);
number(<<".", Rest/binary>>, Parser, [#php_n{n = N} = Exp0]) ->
Exp = Exp0#php_n{n = <<N/binary, ".">>, type = float},
number(Rest, inc_pos(Parser), [Exp]);
number(Rest,
Parser,
[#php_n{n = N,
type = int,
line = L}]) ->
{Rest, Parser, [#int{int = binary_to_integer(N), line = L}]};
number(Rest,
Parser,
[#php_n{n = N,
type = float,
line = L}]) ->
{Rest, Parser, [#float{float = binary_to_float(N), line = L}]}.
hexa(<<A:8, Rest/binary>>, Parser, []) when ?IS_HEX(A) ->
hexa(Rest, inc_pos(Parser), [add_line(#php_n{n = <<A:8>>}, Parser)]);
hexa(<<A:8, Rest/binary>>, Parser, [#php_n{n = N} = I]) when ?IS_HEX(A) ->
hexa(Rest, inc_pos(Parser), [I#php_n{n = <<N/binary, A:8>>}]);
hexa(Rest, Parser, [#php_n{n = N, line = L}]) ->
{Rest, Parser, [#int{int = binary_to_integer(N, 16), line = L}]}.
octa(<<A:8, Rest/binary>>, Parser, []) when ?IS_OCT(A) ->
octa(Rest, inc_pos(Parser), [add_line(#php_n{n = <<A:8>>}, Parser)]);
octa(<<A:8, Rest/binary>>, Parser, [#php_n{n = N} = I]) when ?IS_OCT(A) ->
octa(Rest, inc_pos(Parser), [I#php_n{n = <<N/binary, A:8>>}]);
octa(Rest, Parser, [#php_n{n = N, line = L}]) ->
{Rest, Parser, [#int{int = binary_to_integer(N, 8), line = L}]}.
array_def(<<SP:8, Rest/binary>>, Parser, Args) when ?IS_SPACE(SP) ->
array_def(Rest, inc_pos(Parser), Args);
array_def(<<SP:8, Rest/binary>>, Parser, Args) when ?IS_NEWLINE(SP) ->
array_def(Rest, new_line(Parser), Args);
array_def(<<")", Rest/binary>>,
#parser{level = array_def, array_type = old} = Parser,
Args) ->
{Rest, inc_pos(Parser), Args};
array_def(<<"]", Rest/binary>>,
#parser{level = array_def, array_type = php54} = Parser,
Args) ->
{Rest, inc_pos(Parser), Args};
%% TODO add error missing closing params
array_def(Rest, Parser, Args) when Rest =/= <<>> ->
case expression(Rest, Parser, []) of
{<<")", Rest0/binary>>,
#parser{level = array_def, array_type = old} = Parser0,
[Idx, Arg]} ->
NewArg = add_line(#array_element{idx = Idx, element = Arg}, Parser),
{Rest0, inc_pos(Parser0), Args ++ [NewArg]};
{<<")", Rest0/binary>>,
#parser{level = array_def, array_type = old} = Parser0,
undefined} ->
{Rest0, inc_pos(Parser0), Args};
{<<")", Rest0/binary>>, #parser{level = array_def, array_type = old} = Parser0, Arg} ->
NewArg = add_line(#array_element{element = Arg}, Parser),
{Rest0, inc_pos(Parser0), Args ++ [NewArg]};
{<<"]", Rest0/binary>>,
#parser{level = array_def, array_type = php54} = Parser0,
[Idx, Arg]} ->
NewArg = add_line(#array_element{idx = Idx, element = Arg}, Parser),
{Rest0, inc_pos(Parser0), Args ++ [NewArg]};
{<<"]", Rest0/binary>>,
#parser{level = array_def, array_type = php54} = Parser0,
undefined} ->
{Rest0, inc_pos(Parser0), Args};
{<<"]", Rest0/binary>>, #parser{level = array_def, array_type = php54} = Parser0, Arg} ->
NewArg = add_line(#array_element{element = Arg}, Parser),
{Rest0, inc_pos(Parser0), Args ++ [NewArg]};
{<<",", Rest0/binary>>, Parser0, [Idx, Arg]} ->
NewArg = add_line(#array_element{idx = Idx, element = Arg}, Parser),
array_def(Rest0, inc_pos(Parser0), Args ++ [NewArg]);
{<<",", Rest0/binary>>, Parser0, Arg} ->
NewArg = add_line(#array_element{element = Arg}, Parser),
array_def(Rest0, inc_pos(Parser0), Args ++ [NewArg])
end.
-spec expression(Text :: binary(), parser(), [expression()]) ->
{binary(), parser(), [expression()] | expression()}.
% CONSTANT / FUNCTION when -> is used
expression(<<A:8, _/binary>> = Rest, Parser, [{op, [_, {<<"->">>, _, _}]} | _] = Parsed)
when ?IS_ALPHA(A) orelse A =:= $_ ->
{Rest0, Parser0, [Constant]} = constant(Rest, Parser, []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Constant, Parsed));
% ARRAY(...) -old-
expression(<<A:8, R:8, R:8, A:8, Y:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(A, $a, $A)
andalso ?OR(R, $r, $R)
andalso ?OR(Y, $y, $Y)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 5)) of
{<<")", _/binary>> = Rest0, Parser0} ->
%% (array) cast
OpL = <<"(array)">>,
NewParsed = add_op({OpL, precedence(OpL), Parser}, Parsed),
expression(Rest0, Parser0, NewParsed);
{<<"(", Rest0/binary>>, Parser0} ->
NewParser = array_def_level(inc_pos(Parser0)),
{Rest1, Parser1, Content} = array_def(Rest0, NewParser, []),
NewParsed = add_op(add_line(#array{elements = Content}, Parser), Parsed),
expression(Rest1, copy_rowcol(Parser1, Parser), NewParsed)
end;
% [...] -array new-
expression(<<"[", Rest/binary>>, Parser, []) ->
NewParser = array_def_54_level(inc_pos(Parser)),
{Rest1, Parser1, Content} = array_def(Rest, NewParser, []),
NewParsed = add_op(add_line(#array{elements = Content}, Parser), []),
expression(Rest1, copy_rowcol(Parser1, Parser), NewParsed);
expression(<<"[", Rest/binary>>, Parser, [{op, []} | _] = Parsed) ->
% ARRAY DEF
NewParser = array_def_54_level(inc_pos(Parser)),
{Rest1, Parser1, Content} = array_def(Rest, NewParser, []),
NewParsed = add_op(add_line(#array{elements = Content}, Parser), Parsed),
expression(Rest1, copy_rowcol(Parser1, Parser), NewParsed);
expression(<<"[", Rest/binary>>, Parser, [{op, Op} | LastParsed] = Parsed) ->
case lists:last(Op) of
{_, {RightOrLeft, _}, _} when RightOrLeft =:= right orelse RightOrLeft =:= left ->
% ARRAY DEF
NewParser = array_def_54_level(inc_pos(Parser)),
{Rest1, Parser1, Content} = array_def(Rest, NewParser, []),
NewParsed = add_op(add_line(#array{elements = Content}, Parser), Parsed),
expression(Rest1, copy_rowcol(Parser1, Parser), NewParsed);
_ ->
% ARRAY INDEX
case Op of
[_] ->
NewParsed = [#variable{name = add_op('end', Parsed)}],
{Rest0, Parser0, [Parsed0]} = variable(<<"[", Rest/binary>>, Parser, NewParsed),
expression(Rest0, Parser0, add_op(Parsed0, []));
_ ->
{PrevOp, [LastOp]} = lists:split(length(Op) - 1, Op),
NewLastOp = [#variable{name = LastOp}],
{Rest0, Parser0, Parsed0} = variable(<<"[", Rest/binary>>, Parser, NewLastOp),
NewOp = [{op, PrevOp ++ Parsed0} | LastParsed],
expression(Rest0, Parser0, NewOp)
end
end;
% NULL
expression(<<N:8, U:8, L:8, L:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(N, $N, $n)
andalso ?OR(U, $U, $u)
andalso ?OR(L, $L, $l)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
expression(<<SP:8, Rest/binary>>, add_pos(Parser, 4), add_op(undefined, Parsed));
% TRUE
expression(<<T:8, R:8, U:8, E:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(T, $t, $T)
andalso ?OR(R, $r, $R)
andalso ?OR(U, $u, $U)
andalso ?OR(E, $e, $E)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
expression(<<SP:8, Rest/binary>>, add_pos(Parser, 4), add_op(true, Parsed));
% FALSE
expression(<<F:8, A:8, L:8, S:8, E:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(F, $f, $F)
andalso ?OR(A, $a, $A)
andalso ?OR(L, $l, $L)
andalso ?OR(S, $s, $S)
andalso ?OR(E, $e, $E)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
expression(<<SP:8, Rest/binary>>, add_pos(Parser, 5), add_op(false, Parsed));
% FUNCTION(...) -closure-
expression(<<F:8, U:8, N:8, C:8, T:8, I:8, O:8, N:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(F, $F, $f)
andalso ?OR(U, $U, $u)
andalso ?OR(N, $N, $n)
andalso ?OR(C, $C, $c)
andalso ?OR(T, $T, $t)
andalso ?OR(I, $I, $i)
andalso ?OR(O, $O, $o)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
{<<"(", Rest0/binary>>, Parser0} =
remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 9)),
{Rest1, Parser1, Args} = ephp_parser_func:funct_args(Rest0, Parser0, []),
BaseFunction = add_line(#function{args = Args}, Parser),
{Rest2, Parser2, Function} =
ephp_parser_func:st_use_or_block(Rest1, Parser1, BaseFunction),
expression(Rest2, copy_rowcol(Parser2, Parser), add_op(Function, Parsed));
% INSTANCEOF
expression(<<I:8, N:8, S:8, T:8, A:8, N:8, C:8, E:8, O:8, F:8, SP:8, Rest/binary>>,
Parser,
Parsed)
when ?OR(I, $I, $i)
andalso ?OR(N, $N, $n)
andalso ?OR(S, $S, $s)
andalso ?OR(T, $T, $t)
andalso ?OR(A, $A, $a)
andalso ?OR(C, $C, $c)
andalso ?OR(E, $E, $e)
andalso ?OR(O, $O, $o)
andalso ?OR(F, $F, $f)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Parser0} = remove_spaces(<<SP:8, Rest/binary>>, Parser),
OpL = <<"instanceof">>,
expression(Rest0,
Parser0,
add_op({instanceof, precedence(OpL), get_line(Parser)}, Parsed));
% NEW ...
expression(<<N:8, E:8, W:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(N, $N, $n)
andalso ?OR(E, $E, $e)
andalso ?OR(W, $W, $w)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
{Rest1, Parser1, {NS, ObjName}} =
case remove_spaces(<<SP:8, Rest/binary>>, Parser) of
{<<"$", _/binary>> = Rest0, Parser0} ->
{RestEx, ParserEx, Exp} = expression(Rest0, Parser0, []),
{RestEx, ParserEx, {Parser#parser.namespace, Exp}};
{<<A:8, _/binary>> = Rest0, Parser0}
when ?IS_ALPHA(A) orelse A =:= $_ orelse A =:= $\\ ->
ephp_parser_class:class_name(Rest0, Parser0, [])
end,
Instance =
case remove_spaces(Rest1, Parser1) of
{<<"(", Rest2/binary>>, Parser2} ->
{Rest3, Parser3, Args} = ephp_parser_func:call_args(Rest2, Parser2, []),
add_line(#instance{name = ObjName,
namespace = NS,
args = Args},
Parser);
{Rest3, Parser3} ->
add_line(#instance{name = ObjName, namespace = NS}, Parser)
end,
expression(Rest3, copy_rowcol(Parser3, Parser), add_op(Instance, Parsed));
% CLONE ...
expression(<<C:8, L:8, O:8, N:8, E:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(C, $C, $c)
andalso ?OR(L, $L, $l)
andalso ?OR(O, $O, $o)
andalso ?OR(N, $N, $n)
andalso ?OR(E, $E, $e)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
OpL = <<"clone">>,
Parser1 = add_pos(Parser, 5),
Rest1 = <<SP:8, Rest/binary>>,
expression(Rest1, Parser1, add_op({OpL, precedence(OpL), get_line(Parser)}, Parsed));
% FINAL -enclosed-
expression(<<"}", Rest/binary>>, #parser{level = enclosed} = Parser, [Exp]) ->
{Rest, inc_pos(Parser), add_op('end', [Exp])};
% FINAL -unclosed-
expression(<<SP:8, _/binary>> = Rest, #parser{level = unclosed} = Parser, [Exp])
when ?IS_SPACE(SP) orelse SP =:= $" ->
{Rest, Parser, add_op('end', [Exp])};
% SPACE -all-
expression(<<SP:8, Rest/binary>>, Parser, Parsed) when ?IS_SPACE(SP) ->
expression(Rest, inc_pos(Parser), Parsed);
% NEWLINE -all-
expression(<<SP:8, Rest/binary>>, Parser, Parsed) when ?IS_NEWLINE(SP) ->
expression(Rest, new_line(Parser), Parsed);
% COMMENTS...
expression(<<"//", Rest/binary>>, Parser, Parsed) ->
{Rest0, Parser0, _} = comment_line(Rest, Parser, Parsed),
expression(Rest0, Parser0, Parsed);
expression(<<"#", Rest/binary>>, Parser, Parsed) ->
{Rest0, Parser0, _} = comment_line(Rest, Parser, Parsed),
expression(Rest0, Parser0, Parsed);
expression(<<"/*", Rest/binary>>, Parser, Parsed) ->
{Rest0, Parser0, _} = comment_block(Rest, Parser, Parsed),
expression(Rest0, Parser0, Parsed);
% FUNCTION CALL / PARENS
expression(<<"(", Rest/binary>>, Parser, [{op, Op} | Parsed]) ->
{Op1, Op2} =
case length(Op) of
0 ->
{[], []};
1 ->
{[], Op};
Size ->
lists:split(Size - 1, Op)
end,
case Op2 of
[#variable{} = V] ->
% FUNCTION CALL
Call = #call{name = V, line = V#variable.line},
{Rest0, Parser0, [Function]} =
ephp_parser_func:function(Rest, inc_pos(Parser), [Call | Parsed]),
NewOp = {op, Op1 ++ [Function]},
expression(Rest0, copy_rowcol(Parser0, Parser), [NewOp | Parsed]);
_ ->
% NORMAL PARENS
exp_parens(Rest, inc_pos(Parser), [{op, Op} | Parsed])
end;
% PARENS
expression(<<"(", Rest/binary>>, Parser, Parsed) ->
% FIXME: this is inconsistent, sometimes is expecting to remove ")"
% and sometimes is not.
exp_parens(Rest, inc_pos(Parser), Parsed);
% FINAL -arg-
expression(<<",", _/binary>> = Rest,
#parser{level = Level, access = Access} = Parser,
Parsed)
when Level =:= array
orelse Level =:= array_curly
orelse Level =:= normal
andalso (Access =:= public orelse Access =:= protected orelse Access =:= private) ->
{Rest, Parser, add_op('end', Parsed)};
expression(<<A:8, _/binary>> = Rest,
#parser{level = arg} = Parser,
[{op, _}, #if_block{} | _])
when A =:= $, orelse A =:= $) ->
throw_error(eparse, Parser, Rest);
expression(<<A:8, _/binary>> = Rest, #parser{level = arg} = Parser, Parsed)
when A =:= $, orelse A =:= $) ->
case add_op('end', Parsed) of
#operation{type = <<"?">>, line = {{_, R}, {_, C}}} ->
throw_error(eparse, Parser#parser{row = R, col = C}, Rest);
Op ->
{Rest, Parser, Op}
end;
% FINAL -array definition array(...)-
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = old} = Parser,
[{op, _}, #if_block{} | _])
when A =:= $, orelse A =:= $) ->
throw_error(eparse, Parser, Rest);
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = old} = Parser,
[Parsed])
when A =:= $, orelse A =:= $) ->
{Rest, Parser, add_op('end', [Parsed])};
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = old} = Parser,
Parsed)
when A =:= $, orelse A =:= $) ->
case Parsed of
[Arg, Idx] ->
{Rest, Parser, [Idx, add_op('end', [Arg])]};
[] ->
{Rest, Parser, undefined}
end;
% FINAL -array definition [...]-
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = php54} = Parser,
[{op, _}, #if_block{} | _])
when A =:= $, orelse A =:= $] ->
throw_error(eparse, Parser, Rest);
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = php54} = Parser,
[Parsed])
when A =:= $, orelse A =:= $] ->
{Rest, Parser, add_op('end', [Parsed])};
expression(<<A:8, _/binary>> = Rest,
#parser{level = array_def, array_type = php54} = Parser,
Parsed)
when A =:= $, orelse A =:= $] ->
case Parsed of
[Arg, Idx] ->
{Rest, Parser, [Idx, add_op('end', [Arg])]};
[] ->
{Rest, Parser, undefined}
end;
% KEY & VALUE -array_def old and new-
expression(<<"=>", Rest/binary>>,
#parser{level = array_def} = Parser,
[{op, _} = Op | Parsed]) ->
expression(Rest, add_pos(Parser, 2), [{op, []}, add_op('end', [Op]) | Parsed]);
% FINAL -all but parens-
expression(<<A:8, _/binary>> = Rest,
#parser{level = L} = Parser,
[{op, _}, #if_block{} | _])
when not is_number(L) andalso (A =:= $) orelse A =:= $;) ->
throw_error(eparse, Parser, Rest);
expression(<<A:8, _/binary>> = Rest, #parser{level = L} = Parser, Parsed)
when not is_number(L) andalso (A =:= $) orelse A =:= $;) ->
{Rest, Parser, add_op('end', Parsed)};
% FOREACH DATA
expression(<<A:8, S:8, SP:8, _/binary>> = Rest,
#parser{level = foreach_block} = Parser,
[{op, _}, #if_block{} | _])
when ?OR(A, $a, $A)
andalso ?OR(S, $s, $S)
andalso not (?IS_ALPHANUM(SP) orelse SP =:= $_ orelse SP =:= $() ->
throw_error(eparse, Parser, Rest);
expression(<<A:8, S:8, SP:8, _/binary>> = Rest,
#parser{level = foreach_block} = Parser,
Parsed)
when ?OR(A, $a, $A)
andalso ?OR(S, $s, $S)
andalso not (?IS_ALPHANUM(SP) orelse SP =:= $_ orelse SP =:= $() ->
{Rest, Parser, add_op('end', Parsed)};
% FINAL -parens-
expression(<<")", _/binary>> = Rest,
#parser{level = L} = Parser,
[{op, _}, #if_block{} | _])
when is_number(L) ->
throw_error(eparse, Parser, Rest);
expression(<<")", Rest/binary>>, #parser{level = L} = Parser, Parsed) when is_number(L) ->
{Rest, inc_pos(Parser), add_op('end', Parsed)};
% FINAL -array-
expression(<<"]", _/binary>> = Rest,
#parser{level = array} = Parser,
[{op, _}, #if_block{} | _]) ->
throw_error(eparse, Parser, Rest);
expression(<<"]", Rest/binary>>, #parser{level = array} = Parser, Parsed) ->
{Rest, inc_pos(Parser), add_op('end', Parsed)};
expression(<<"}", _/binary>> = Rest,
#parser{level = array_curly} = Parser,
[{op, _}, #if_block{} | _]) ->
throw_error(eparse, Parser, Rest);
expression(<<"}", Rest/binary>>, #parser{level = array_curly} = Parser, Parsed) ->
{Rest, inc_pos(Parser), add_op('end', Parsed)};
% FINAL -all but parens-
expression(<<"?>\n", _/binary>> = Rest,
#parser{level = L} = Parser,
[{op, _}, #if_block{} | _])
when not is_number(L) ->
throw_error(eparse, Parser, Rest);
expression(<<"?>\n", _/binary>> = Rest, #parser{level = L} = Parser, Parsed)
when not is_number(L) ->
case add_op('end', Parsed) of
#operation{type = <<"?">>, line = {{_, R}, {_, C}}} ->
throw_error(eparse, Parser#parser{row = R, col = C}, Rest);
Op ->
{Rest, Parser, Op}
end;
expression(<<"?>", _/binary>> = Rest,
#parser{level = L} = Parser,
[{op, _}, #if_block{} | _])
when not is_number(L) ->
throw_error(eparse, Parser, Rest);
expression(<<"?>", _/binary>> = Rest, #parser{level = L} = Parser, Parsed)
when not is_number(L) ->
{Rest, Parser, add_op('end', Parsed)};
% VARIABLE
expression(<<"$", Rest/binary>>, Parser, Parsed) ->
{Rest0, Parser0, [Var]} = variable(Rest, inc_pos(Parser), []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Var, Parsed));
% NUMBER
expression(<<A:8, _/binary>> = Rest, Parser, Parsed) when ?IS_NUMBER(A) ->
{Rest0, Parser0, [Number]} = number(Rest, Parser, []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Number, Parsed));
expression(<<".", A:8, _/binary>> = Rest, Parser, Parsed) when ?IS_NUMBER(A) ->
{Rest0, Parser0, [Number]} = number(Rest, Parser, []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Number, Parsed));
% STRING
expression(<<A:8, _/binary>> = Rest, Parser, Parsed)
when A =:= $" orelse A =:= $' orelse A =:= $` ->
{Rest0, Parser0, String} = ephp_parser_string:string(Rest, Parser, []),
expression(Rest0, Parser0, add_op(String, Parsed));
% HEREDOC & NOWDOC
expression(<<"<<<", _/binary>> = Rest, Parser, Parsed) ->
{Rest0, Parser0, String} = ephp_parser_string:string(Rest, Parser, []),
expression(Rest0, Parser0, add_op(String, Parsed));
% INCLUDE
expression(<<I:8, N:8, C:8, L:8, U:8, D:8, E:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(I, $I, $i)
andalso ?OR(N, $N, $n)
andalso ?OR(C, $C, $c)
andalso ?OR(L, $L, $l)
andalso ?OR(U, $U, $u)
andalso ?OR(D, $D, $d)
andalso ?OR(E, $E, $e)
andalso (SP =:= $) orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Parser0} =
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 7)) of
{<<"(", R0/binary>>, P0} ->
{R0, inc_pos(P0)};
{R0, P0} ->
{R0, P0}
end,
{Rest1, Parser1, Exp} = expression(Rest0, Parser0, []),
Include = add_line(#call{name = <<"include">>, args = [Exp]}, Parser),
expression(Rest1, Parser1, add_op(Include, Parsed));
% INCLUDE_ONCE
expression(<<I:8,
N:8,
C:8,
L:8,
U:8,
D:8,
E:8,
$_,
O:8,
N:8,
C:8,
E:8,
SP:8,
Rest/binary>>,
Parser,
Parsed)
when ?OR(I, $I, $i)
andalso ?OR(N, $N, $n)
andalso ?OR(C, $C, $c)
andalso ?OR(L, $L, $l)
andalso ?OR(U, $U, $u)
andalso ?OR(D, $D, $d)
andalso ?OR(E, $E, $e)
andalso ?OR(O, $O, $o)
andalso (SP =:= $) orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Parser0} =
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 12)) of
{<<"(", R0/binary>>, P0} ->
{R0, inc_pos(P0)};
{R0, P0} ->
{R0, P0}
end,
{Rest1, Parser1, Exp} = expression(Rest0, Parser0, []),
Include = add_line(#call{name = <<"include_once">>, args = [Exp]}, Parser),
expression(Rest1, Parser1, add_op(Include, Parsed));
% REQUIRE
expression(<<R:8, E:8, Q:8, U:8, I:8, R:8, E:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(R, $R, $r)
andalso ?OR(E, $E, $e)
andalso ?OR(Q, $Q, $q)
andalso ?OR(U, $U, $u)
andalso ?OR(I, $I, $i)
andalso (SP =:= $) orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Parser0} =
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 7)) of
{<<"(", R0/binary>>, P0} ->
{R0, inc_pos(P0)};
{R0, P0} ->
{R0, P0}
end,
{Rest1, Parser1, Exp} = expression(Rest0, Parser0, []),
Include = add_line(#call{name = <<"require">>, args = [Exp]}, Parser),
expression(Rest1, Parser1, add_op(Include, Parsed));
% REQUIRE_ONCE
expression(<<R:8,
E:8,
Q:8,
U:8,
I:8,
R:8,
E:8,
$_,
O:8,
N:8,
C:8,
E:8,
SP:8,
Rest/binary>>,
Parser,
Parsed)
when ?OR(R, $R, $r)
andalso ?OR(E, $E, $e)
andalso ?OR(Q, $Q, $q)
andalso ?OR(U, $U, $u)
andalso ?OR(I, $I, $i)
andalso ?OR(O, $O, $o)
andalso ?OR(N, $N, $n)
andalso ?OR(C, $C, $c)
andalso (SP =:= $) orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Parser0} =
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 12)) of
{<<"(", R0/binary>>, P0} ->
{R0, inc_pos(P0)};
{R0, P0} ->
{R0, P0}
end,
{Rest1, Parser1, Exp} = expression(Rest0, Parser0, []),
Include = add_line(#call{name = <<"require_once">>, args = [Exp]}, Parser),
expression(Rest1, Parser1, add_op(Include, Parsed));
% AND
expression(<<A:8, N:8, D:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(A, $a, $A)
andalso ?OR(N, $n, $N)
andalso ?OR(D, $d, $D)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
OpL = <<"and">>,
expression(Rest, add_pos(Parser, 3), add_op({OpL, precedence(OpL), Parser}, Parsed));
% XOR
expression(<<X:8, O:8, R:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(X, $x, $X)
andalso ?OR(O, $o, $O)
andalso ?OR(R, $r, $R)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
OpL = <<"xor">>,
expression(Rest, add_pos(Parser, 3), add_op({OpL, precedence(OpL), Parser}, Parsed));
% OPERATOR 3 LETTERS
expression(<<Op:3/binary, Rest/binary>>, Parser, Parsed) when ?IS_OP3(Op) ->
expression(Rest, add_pos(Parser, 3), add_op({Op, precedence(Op), Parser}, Parsed));
% OR
expression(<<O:8, R:8, SP:8, Rest/binary>>, Parser, Parsed)
when ?OR(O, $o, $O)
andalso ?OR(R, $r, $R)
andalso not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_) ->
OpL = <<"or">>,
expression(Rest, add_pos(Parser, 2), add_op({OpL, precedence(OpL), Parser}, Parsed));
% OPERATORS 2 LETTERS
expression(<<Op:2/binary, Rest/binary>>, Parser, Parsed) when ?IS_OP2(Op) ->
expression(Rest, add_pos(Parser, 2), add_op({Op, precedence(Op), Parser}, Parsed));
% OPERATORS 1 LETTER
expression(<<Op:1/binary, Rest/binary>>, Parser, Parsed) when ?IS_OP1(Op) ->
expression(Rest, inc_pos(Parser), add_op({Op, precedence(Op), Parser}, Parsed));
% CONSTANT / FUNCTION
expression(<<A:8, _/binary>> = Rest, Parser, [{op, []} | _] = Parsed)
when ?IS_ALPHA(A) orelse A =:= $_ orelse A =:= $\\ ->
{Rest0, NewParser, [Constant]} = constant(Rest, Parser, []),
expression(Rest0, copy_rowcol(NewParser, Parser), add_op(Constant, Parsed));
expression(<<A:8, _/binary>> = Rest, Parser, [{op, Ops} | _] = Parsed)
when ?IS_ALPHA(A) orelse A =:= $_ orelse A =:= $\\ ->
{Rest0, Parser0, [Constant]} = constant(Rest, Parser, []),
case lists:last(Ops) of
#constant{} ->
throw_error(eparse, Parser, {Constant#constant.name, <<"T_STRING">>});
_ ->
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Constant, Parsed))
end;
expression(<<A:8, _/binary>> = Rest, Parser, Parsed)
when ?IS_ALPHA(A) orelse A =:= $_ orelse A =:= $\\ ->
case constant(Rest, Parser, []) of
{Rest0, Parser0, [Constant]} ->
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Constant, Parsed));
{<<>>, _Parser0, []} ->
{<<>>, Parser, []}
end;
% FINAL -switch-
expression(<<":", _/binary>> = Rest, #parser{level = switch_label} = Parser, [Exp]) ->
{Rest, Parser, add_op('end', [Exp])};
% TERNARY OPERATOR
expression(<<"?", Rest/binary>>, Parser, Parsed) ->
Op = <<"?">>,
NewParser = inc_pos(Parser),
QParsed = add_op({Op, precedence(Op), Parser}, Parsed),
case expression(Rest, NewParser, []) of
{<<":", Rest0/binary>>, Parser0, Parsed0} ->
Op0 = <<":">>,
{Rest1, Parser1, Parsed1} = expression(Rest0, inc_pos(Parser0), []),
ToAdd = [Parsed0, [{Op0, precedence(Op0), Parser0}], Parsed1],
XParsed = lists:foldl(fun add_op/2, QParsed, ToAdd),
{Rest1, Parser1, add_op('end', XParsed)};
{Rest0, _Parser0, _Parsed0} ->
throw_error(eparse, Parser, Rest0)
end;
expression(<<":", Rest/binary>>, Parser, Parsed) ->
case lists:keyfind(<<"?">>, 1, Parsed) of
{<<"?">>, _, _} ->
Op = <<":">>,
expression(Rest, inc_pos(Parser), add_op({Op, precedence(Op), Parser}, Parsed));
false ->
{<<":", Rest/binary>>, Parser, add_op('end', Parsed)}
end;
% FINAL -unclosed-
expression(Rest, #parser{level = unclosed} = Parser, [Exp]) ->
{Rest, Parser, add_op('end', [Exp])};
% PARSE ERROR
expression(<<",", _/binary>>, #parser{level = code} = Parser, _Parsed) ->
throw_error(eparse, Parser, {unexpected, <<",">>});
expression(<<"{", _/binary>>, Parser, _Parsed) ->
throw_error(eparse, Parser, {unexpected, <<"{">>});
expression(<<>>, Parser, _Parsed) ->
throw_error(eparse, Parser, <<>>).
exp_parens(Rest, #parser{level = L} = Parser, Parsed) when not is_number(L) ->
{Rest0, Parser0, Op} = expression(Rest, Parser#parser{level = 1}, []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Op, Parsed));
exp_parens(Rest, #parser{level = L} = Parser, Parsed) ->
{Rest0, Parser0, Op} = expression(Rest, Parser#parser{level = L + 1}, []),
expression(Rest0, copy_rowcol(Parser0, Parser), add_op(Op, Parsed)).
-type associativity() :: no_assoc | left | right.
-spec precedence(binary()) -> {associativity(), pos_integer()} | false.
%% took from http://php.net/manual/en/language.operators.precedence.php
precedence(<<"clone">>) ->
{no_assoc, 1};
precedence(<<"new">>) ->
{no_assoc, 1};
precedence(<<"[">>) ->
{left, 2}; %% array
precedence(<<"->">>) ->
{left, 2}; %% object
precedence(<<"::">>) ->
{left, 2}; %% class
precedence(<<"**">>) ->
{right, 3}; %% arith
precedence(<<"++">>) ->
{right, 4};
precedence(<<"--">>) ->
{right, 4};
precedence(<<126>>) ->
{right, 4}; %% ~ (types and increment/decrement)
precedence(<<"(int)">>) ->
{right, 4};
precedence(<<"(float)">>) ->
{right, 4};
precedence(<<"(string)">>) ->
{right, 4};
precedence(<<"(array)">>) ->
{right, 4};
precedence(<<"(object)">>) ->
{right, 4};
precedence(<<"(bool)">>) ->
{right, 4};
precedence(<<"(unset)">>) ->
{right, 4};
precedence(<<"@">>) ->
{right, 1};
precedence(<<"instanceof">>) ->
{no_assoc, 5};
precedence(<<"!">>) ->
{right, 6}; %% logic
precedence(<<"*">>) ->
{left, 7};
precedence(<<"/">>) ->
{left, 7};
precedence(<<"%">>) ->
{left, 7};
precedence(<<"+">>) ->
{left, 8};
precedence(<<"-">>) ->
{left, 8};
precedence(<<".">>) ->
{left, 8}; %% concat
precedence(<<"<<">>) ->
{left, 9}; %% bit by bit
precedence(<<">>">>) ->
{left, 9}; %% bit by bit
precedence(<<"<">>) ->
{no_assoc, 10};
precedence(<<"<=">>) ->
{no_assoc, 10};
precedence(<<">">>) ->
{no_assoc, 10};
precedence(<<">=">>) ->
{no_assoc, 10};
precedence(<<"==">>) ->
{no_assoc, 11};
precedence(<<"!=">>) ->
{no_assoc, 11};
precedence(<<"===">>) ->
{no_assoc, 11};
precedence(<<"!==">>) ->
{no_assoc, 11};
precedence(<<"<>">>) ->
{no_assoc, 11};
precedence(<<"<=>">>) ->
{no_assoc, 11};
precedence(<<"&">>) ->
{left, 12}; %% bit by bit & references
precedence(<<"^">>) ->
{left, 13}; %% bit by bit
precedence(<<"|">>) ->
{left, 14}; %% bit by bit
precedence(<<"&&">>) ->
{left, 15}; %% logic
precedence(<<"||">>) ->
{left, 16}; %% logic
precedence(<<"??">>) ->
{right, 17}; %% comparison
precedence(<<"?">>) ->
{left, 18}; %% ternary
precedence(<<":">>) ->
{left, 17}; %% ternary
precedence(<<"=">>) ->
{right, 19}; %% assign
precedence(<<"+=">>) ->
{right, 19};
precedence(<<"-=">>) ->
{right, 19};
precedence(<<"*=">>) ->
{right, 19};
precedence(<<"**=">>) ->
{right, 19};
precedence(<<"/=">>) ->
{right, 19};
precedence(<<".=">>) ->
{right, 19};
precedence(<<"%=">>) ->
{right, 19};
precedence(<<"&=">>) ->
{right, 19};
precedence(<<"|=">>) ->
{right, 19};
precedence(<<"^=">>) ->
{right, 19};
precedence(<<"<<=">>) ->
{right, 19};
precedence(<<">>=">>) ->
{right, 19};
precedence(<<"and">>) ->
{left, 20};
precedence(<<"xor">>) ->
{left, 21};
precedence(<<"or">>) ->
{left, 22};
precedence(_) ->
false.
operator(<<":">> = Op, Left, Right) ->
#operation{type = Op,
expression_left = Left,
expression_right = Right};
operator(<<"?">> = Op, Left, Right) ->
#operation{type = Op,
expression_left = Left,
expression_right = Right};
operator(<<"and">>, Left, Right) ->
operator('and', Left, Right);
operator(<<"or">>, Left, Right) ->
operator('or', Left, Right);
operator(<<"xor">>, Left, Right) ->
operator('xor', Left, Right);
operator(<<"&&">>, Left, Right) ->
operator('and', Left, Right);
operator(<<"||">>, Left, Right) ->
operator('or', Left, Right);
operator(<<"^^">>, Left, Right) ->
operator('xor', Left, Right);
operator(<<"<=">>, Left, Right) ->
operator(<<"=<">>, Left, Right);
operator(Op, R1, R2) when is_boolean(R1) andalso is_boolean(R2) ->
case Op of
'and' ->
R1 and R2;
'or' ->
R1 or R2;
'xor' ->
R1 xor R2;
_ ->
#operation{type = Op,
expression_left = R1,
expression_right = R2}
end;
operator(<<"/">>, R1, R2)
when (is_record(R1, int) orelse is_record(R1, float))
andalso (is_record(R2, int) orelse is_record(R2, float)) ->
N2 = element(2, R2),
case N2 == 0 of
true ->
#operation{type = <<"/">>,
expression_left = R1,
expression_right = R2};
false ->
N1 = element(2, R1),
if N1 rem N2 =:= 0 ->
#int{int = N1 div N2};
true ->
#float{float = N1 / N2}
end
end;
operator(Op, R1, R2)
when (is_record(R1, int) orelse is_record(R1, float))
andalso (is_record(R2, int) orelse is_record(R2, float)) ->
N1 = element(2, R1),
N2 = element(2, R2),
Res = case Op of
<<"+">> ->
N1 + N2;
<<"-">> ->
N1 - N2;
<<"*">> ->
N1 * N2;
<<"**">> ->
ephp_data:pow(N1, N2);
<<"%">> ->
N1 rem N2;
<<">">> ->
N1 > N2;
<<"<">> ->
N1 < N2;
<<"==">> ->
N1 == N2;
<<"===">> ->
N1 =:= N2;
<<"=<">> ->
N1 =< N2;
<<">=">> ->
N1 >= N2;
<<"^">> ->
N1 bxor N2;
<<"&">> ->
N1 band N2;
<<"|">> ->
N1 bor N2;
<<"<<">> ->
N1 bsl N2;
<<">>">> ->
N1 bsr N2;
'xor' ->
ephp_data:to_bool(N1) xor ephp_data:to_bool(N2);
'or' ->
ephp_data:to_bool(N1) or ephp_data:to_bool(N2);
'and' ->
ephp_data:to_bool(N1) and ephp_data:to_bool(N2)
end,
if is_integer(Res) ->
#int{int = Res};
is_float(Res) ->
#float{float = Res};
is_boolean(Res) ->
Res
end;
operator(<<".">>, #text{text = T1}, #text{text = T2}) ->
#text{text = <<T1/binary, T2/binary>>};
operator(<<".">>, Left, Right) ->
ProcessedLeft = concat(Left),
ProcessedRight = concat(Right),
#concat{texts = ProcessedLeft ++ ProcessedRight};
operator(Op, Left, Right) ->
#operation{type = Op,
expression_left = Left,
expression_right = Right}.
concat(#concat{texts = T}) ->
T;
concat(T) ->
[T].
solve(Expression) ->
Postfix = shunting_yard(parse_negative(Expression), [], []),
case gen_op(Postfix, []) of
[Operation] ->
Operation;
[{UnExpected, _, Pos} | _] ->
throw_error(eparse, Pos, {unexpected, UnExpected})
end.
gen_op([], Stack) ->
Stack;
gen_op([{<<"=">>, {_, _}, Parser} | Rest], [B, {operation_not, A, Line} | Stack]) ->
Assign = add_line(#assign{variable = A, expression = B}, Parser),
gen_op(Rest, [{operation_not, Assign, Line} | Stack]);
gen_op([{<<"=">>, {_, _}, Parser} | Rest], [B, A | Stack]) ->
Assign = add_line(#assign{variable = A, expression = B}, Parser),
gen_op(Rest, [Assign | Stack]);
gen_op([{<<O:1/binary, "=">>, {_, _}, Parser} | Rest], [B, A | Stack])
when ?IS_OP1_ARITH(O) ->
Op = add_line(operator(O, A, B), Parser),
Assign = add_line(#assign{variable = A, expression = Op}, Parser),
gen_op(Rest, [Assign | Stack]);
gen_op([#variable{} = V, {<<"&">>, _, Parser} | Rest], []) ->
gen_op(Rest, [add_line(#ref{var = V}, Parser)]);
gen_op([#variable{} = V, {<<"&">>, _, Parser}, {<<"=">>, _, _} = A | Rest], Stack) ->
gen_op([A | Rest], [add_line(#ref{var = V}, Parser) | Stack]);
gen_op([#call{} = C, {<<"&">>, _, _Parser} | Rest], []) ->
gen_op(Rest, [C]);
gen_op([#call{} = C, {<<"&">>, _, _Parser}, {<<"=">>, _, _} = A | Rest], Stack) ->
gen_op([A | Rest], [C | Stack]);
gen_op([{<<"@">>, {right, _}, #parser{}} | Rest], [A | Stack]) ->
gen_op(Rest, [{silent, A} | Stack]);
gen_op([{<<126>>, {_, _}, #parser{row = R, col = C}} | Rest], [A | Stack]) ->
gen_op(Rest, [{operation_bnot, A, {{line, R}, {column, C}}} | Stack]);
gen_op([{<<"!">>, {_, _}, #parser{row = R, col = C}} | Rest], [A | Stack]) ->
gen_op(Rest, [{operation_not, A, {{line, R}, {column, C}}} | Stack]);
gen_op([#constant{name = <<"break">>}, #int{int = I}], []) ->
[{break, I}];
gen_op([#constant{name = <<"continue">>}, #int{int = I}], []) ->
[{continue, I}];
gen_op([{<<"->">>, {_, _}, Parser} | Rest], [B, #variable{idx = Idx} = A | Stack]) ->
Object =
case B of
#int{int = I} ->
add_line({object, ephp_data:to_bin(I)}, Parser);
#float{float = F} ->
add_line({object, ephp_data:to_bin(F)}, Parser);
#constant{name = Name} ->
add_line({object, Name}, Parser);
#variable{} ->
add_line({object, B}, Parser);
#call{} ->
add_line({object, B}, Parser);
#text_to_process{} ->
add_line({object, B}, Parser);
_ ->
throw_error(eparse,
Parser,
{<<"`\"identifier (T_STRING)\"' or "
"`\"variable (T_VARIABLE)\"' or "
"`'{'' or `'$''">>})
end,
gen_op(Rest, [A#variable{idx = Idx ++ [Object]} | Stack]);
gen_op([{<<"++">>, {_, _}, Parser} | Rest], [V | Stack]) ->
gen_op(Rest, [{post_incr, V, Parser} | Stack]);
gen_op([{<<"--">>, {_, _}, Parser} | Rest], [V | Stack]) ->
gen_op(Rest, [{post_decr, V, Parser} | Stack]);
gen_op([{<<"::">>, {_, _}, _Parser} | Rest], [#constant{} = A, B | Stack]) ->
gen_op(Rest, [A#constant{type = class, class = B} | Stack]);
gen_op([{<<"(int)">>, {_, _}, _Parser} | Rest], [#int{} = I | Stack]) ->
gen_op(Rest, [I | Stack]);
gen_op([{<<"(int)">>, {_, _}, Parser} | Rest], [#float{float = F} | Stack]) ->
gen_op(Rest, [add_line(#int{int = ephp_data:flooring(F)}, Parser) | Stack]);
gen_op([{<<"(int)">>, {_, _}, Parser} | Rest], [#text{text = T} | Stack]) ->
gen_op(Rest, [add_line(#int{int = ephp_data:bin_to_number(T)}, Parser) | Stack]);
gen_op([{<<"(int)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = int, content = A}, Parser) | Stack]);
gen_op([{<<"(float)">>, {_, _}, Parser} | Rest], [#int{int = I} | Stack]) ->
gen_op(Rest, [add_line(#float{float = erlang:float(I)}, Parser) | Stack]);
gen_op([{<<"(float)">>, {_, _}, _Parser} | Rest], [#float{} = F | Stack]) ->
gen_op(Rest, [F | Stack]);
gen_op([{<<"(float)">>, {_, _}, Parser} | Rest], [#text{text = T} | Stack]) ->
Float =
erlang:float(
ephp_data:bin_to_number(T)),
gen_op(Rest, [add_line(#float{float = Float}, Parser) | Stack]);
gen_op([{<<"(float)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = float, content = A}, Parser) | Stack]);
gen_op([{<<"(string)">>, {_, _}, Parser} | Rest], [#int{int = I} | Stack]) ->
gen_op(Rest, [add_line(#text{text = ephp_data:to_bin(I)}, Parser) | Stack]);
gen_op([{<<"(string)">>, {_, _}, _Parser} | Rest], [#text{} = T | Stack]) ->
gen_op(Rest, [T | Stack]);
gen_op([{<<"(string)">>, {_, _}, Parser} | Rest], [#float{float = F} | Stack]) ->
gen_op(Rest, [add_line(#text{text = ephp_data:to_bin(F)}, Parser) | Stack]);
gen_op([{<<"(string)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = string, content = A}, Parser) | Stack]);
gen_op([{<<"(bool)">>, {_, _}, _Parser} | Rest], [#int{int = I} | Stack]) ->
gen_op(Rest, [ephp_data:to_bool(I) | Stack]);
gen_op([{<<"(bool)">>, {_, _}, _Parser} | Rest], [#text{text = T} | Stack]) ->
gen_op(Rest, [ephp_data:to_bool(T) | Stack]);
gen_op([{<<"(bool)">>, {_, _}, _Parser} | Rest], [#float{float = F} | Stack]) ->
gen_op(Rest, [ephp_data:to_bool(F) | Stack]);
gen_op([{<<"(bool)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = bool, content = A}, Parser) | Stack]);
gen_op([{<<"(array)">>, {_, _}, Parser} | Rest], [#int{line = DParser} = D | Stack]) ->
gen_op(Rest, [add_to_array(#array{line = DParser}, Parser, D) | Stack]);
gen_op([{<<"(array)">>, {_, _}, Parser} | Rest], [#text{line = DParser} = D | Stack]) ->
gen_op(Rest, [add_to_array(#array{line = DParser}, Parser, D) | Stack]);
gen_op([{<<"(array)">>, {_, _}, Parser} | Rest], [#float{line = DParser} = D | Stack]) ->
gen_op(Rest, [add_to_array(#array{line = DParser}, Parser, D) | Stack]);
gen_op([{<<"(array)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = array, content = A}, Parser) | Stack]);
gen_op([{<<"(object)">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#cast{type = object, content = A}, Parser) | Stack]);
gen_op([{<<"(unset)">>, {_, _}, _Parser} | Rest], [_ | Stack]) ->
gen_op(Rest, [undefined | Stack]);
gen_op([{<<"clone">>, {_, _}, Parser} | Rest], [A | Stack]) ->
gen_op(Rest, [add_line(#clone{var = A}, Parser) | Stack]);
% TODO add the rest of casting operators
gen_op([{<<"??">>, {_, _}, Parser} | Rest], [B, A | Stack]) ->
Isset = add_line(#call{name = <<"isset">>, args = [A]}, Parser),
IfBlock =
add_line(#if_block{conditions = Isset,
true_block = A,
false_block = B},
Parser),
gen_op(Rest, [IfBlock | Stack]);
gen_op([{<<"?">>, {_, _}, Parser} | Rest],
[#operation{type = <<":">>} = OpElse, Cond | Stack]) ->
#operation{expression_left = TrueBlock, expression_right = FalseBlock} = OpElse,
IfBlock =
add_line(#if_block{conditions = Cond,
true_block = TrueBlock,
false_block = FalseBlock},
Parser),
gen_op(Rest, [IfBlock | Stack]);
gen_op([{<<"?">>, {_, _}, Parser} | _Rest], _Stack) ->
throw_error(eparse, Parser, <<>>);
gen_op([{Op, {_, _}, Parser} | Rest], [B, A | Stack]) ->
gen_op(Rest, [add_line(operator(Op, A, B), Parser) | Stack]);
gen_op([A | Rest], Stack) ->
gen_op(Rest, [A | Stack]).
-spec add_to_array(php_array(), parser(), php_integer() | php_float() | text()) ->
php_array().
%% @hidden
add_to_array(#array{elements = E} = Array, Parser, Element) ->
Array#array{elements = E ++ [add_line(#array_element{element = Element}, Parser)]}.
parse_negative(Elements) ->
parse_negative(lists:reverse(Elements), []).
parse_negative([#int{} = I, {<<"-">>, {_, _}, _}, {_, {_, _}, _} = Op | Rest], Stack) ->
parse_negative([I#int{int = -I#int.int}, Op | Rest], Stack);
parse_negative([#float{} = F, {<<"-">>, {_, _}, _}, {_, {_, _}, _} = Op | Rest], Stack) ->
parse_negative([F#float{float = -F#float.float}, Op | Rest], Stack);
parse_negative([A, {<<"-">>, {_, _}, _}, {_, {_, _}, _} = Op | Rest], Stack) ->
parse_negative([{operation_minus, A, undefined}, Op | Rest], Stack);
parse_negative([#int{} = I, {<<"-">>, {_, _}, _}], Stack) ->
[I#int{int = -I#int.int} | Stack];
parse_negative([#float{} = F, {<<"-">>, {_, _}, _}], Stack) ->
[F#float{float = -F#float.float} | Stack];
parse_negative([A, {<<"-">>, {_, _}, _}], Stack) ->
[{operation_minus, A, undefined} | Stack];
parse_negative([A | Rest], Stack) ->
parse_negative(Rest, [A | Stack]);
parse_negative([], Stack) ->
Stack.
shunting_yard([], [], Postfix) ->
Postfix;
shunting_yard([], OpS, Postfix) ->
Postfix ++ OpS;
shunting_yard([{_, {_, _}, _} = Op | Rest], [], Postfix) ->
shunting_yard(Rest, [Op], Postfix);
shunting_yard([{_, {left, P1}, _} = Op | Rest], [{_, {_, P2}, _} = Op1 | OpS], Postfix)
when P1 > P2 ->
shunting_yard(Rest, [Op | OpS], Postfix ++ [Op1]);
shunting_yard([{_, {_, P1}, _} = Op | Rest], [{_, {_, P2}, _} = Op1 | OpS], Postfix)
when P1 >= P2 ->
shunting_yard(Rest, [Op | OpS], Postfix ++ [Op1]);
shunting_yard([{_, {left, P1}, _} = Op | Rest], [{_, {_, P2}, _} | _] = OpS, Postfix)
when P1 =< P2 ->
shunting_yard(Rest, [Op | OpS], Postfix);
shunting_yard([{_, {_, P1}, _} = Op | Rest], [{_, {_, P2}, _} | _] = OpS, Postfix)
when P1 < P2 ->
shunting_yard(Rest, [Op | OpS], Postfix);
shunting_yard([A | Rest], OpS, Postfix) ->
shunting_yard(Rest, OpS, Postfix ++ [A]).