Current section
Files
Jump to
Current section
Files
src/ephp_parser.erl
-module(ephp_parser).
-author('manuel@altenwald.com').
-compile([warnings_as_errors]).
-export([parse/1, file/1]).
-export([
add_pos/2, new_line/1, copy_level/2, add_line/2, remove_spaces/2,
throw_error/3, code_block/3, code/3, new_line/2,
array_def_level/1, code_statement_level/1, arg_level/1,
code_block_level/1, enclosed_level/1, unclosed_level/1,
variable/3, comment_line/3, comment_block/3, constant/3
]).
-include("ephp.hrl").
-include("ephp_parser.hrl").
-import(ephp_parser_expr, [
expression/3, add_op/2, precedence/1
]).
file(File) ->
{ok, Content} = file:read_file(File),
parse(Content).
parse(Document) when is_list(Document) ->
parse(list_to_binary(Document));
parse(Document) ->
{_, _, Parsed} = document(Document, {root,1,1}, []),
lists:reverse(Parsed).
document(<<>>, Pos, Parsed) ->
{<<>>, Pos, Parsed};
document(<<"<?php",Rest/binary>>, {literal,_,_}=Pos, Parsed) ->
{Rest, add_pos(Pos,5), Parsed};
document(<<"<?php",Rest/binary>>, Pos, Parsed) ->
{Rest0,Pos0,NParsed} = code(Rest, normal_level(add_pos(Pos,5)), []),
case NParsed of
[] ->
document(Rest0, Pos0, Parsed);
_ ->
Eval = add_line(#eval{statements=lists:reverse(NParsed)}, Pos),
document(Rest0,Pos0,[Eval|Parsed])
end;
document(<<"<?=",Rest/binary>>, Pos, Parsed) ->
NewPos = code_value_level(add_pos(Pos,3)),
{Rest0,Pos0,Text} = code(Rest, NewPos, []),
document(Rest0, copy_level(Pos,Pos0), [get_print(Text,NewPos)|Parsed]);
document(<<"<?",Rest/binary>>, {literal,_,_}=Pos, Parsed) ->
%% TODO: if short is not permitted, use as text
{Rest, add_pos(Pos,2), Parsed};
document(<<"<?",Rest/binary>>, Pos, Parsed) ->
%% TODO: if short is not permitted, use as text
{Rest0,Pos0,NParsed} = code(Rest, normal_level(add_pos(Pos,2)), []),
case NParsed of
[] ->
document(Rest0, Pos0, Parsed);
_ ->
Eval = add_line(#eval{statements=lists:reverse(NParsed)}, Pos),
document(Rest0,Pos0,[Eval|Parsed])
end;
document(<<"\n",Rest/binary>>, Pos, Parsed) ->
document(Rest, new_line(Pos), add_to_text(<<"\n">>, Pos, Parsed));
document(<<L:1/binary,Rest/binary>>, Pos, Parsed) ->
document(Rest, add_pos(Pos,1), add_to_text(L, Pos, Parsed)).
copy_level({Level,_,_}, {_,Row,Col}) -> {Level,Row,Col}.
code(<<"{", Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, Parsed0} = code(Rest, code_block_level(add_pos(Pos, 2)), []),
code(Rest0, Pos0, Parsed0 ++ Parsed);
code(<<B:8,R:8,E:8,A:8,K:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(B,$B,$b) andalso ?OR(R,$R,$r) andalso ?OR(E,$E,$e) andalso
?OR(A,$A,$a) andalso ?OR(K,$K,$k) andalso
(not (?IS_SPACE(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_)) ->
code(<<SP:8,Rest/binary>>, add_pos(Pos,5), [break|Parsed]);
code(<<C:8,O:8,N:8,T:8,I:8,N:8,U:8,E:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(C,$C,$c) andalso ?OR(O,$O,$o) andalso ?OR(N,$N,$n) andalso
?OR(T,$T,$t) andalso ?OR(I,$I,$i) andalso ?OR(U,$U,$u) andalso
?OR(E,$E,$e) andalso (not (?IS_SPACE(SP) orelse ?IS_NUMBER(SP))) ->
code(<<SP:8,Rest/binary>>, add_pos(Pos,8), [continue|Parsed]);
code(<<R:8,E:8,T:8,U:8,R:8,N:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(R,$R,$r) andalso ?OR(E,$E,$e) andalso ?OR(T,$T,$t) andalso
?OR(U,$U,$u) andalso ?OR(N,$N,$n) andalso
(not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP))) ->
{Rest0, Pos0, Return} = expression(<<SP:8,Rest/binary>>, add_pos(Pos,6), []),
case Return of
[] -> code(Rest0, Pos0, [add_line(#return{}, Pos)|Parsed]);
_ -> code(Rest0, Pos0, [add_line(#return{value = Return}, Pos)|Parsed])
end;
code(<<T:8,H:8,R:8,O:8,W:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(T,$T,$t) andalso ?OR(H,$H,$h) andalso ?OR(R,$R,$r) andalso
?OR(O,$O,$o) andalso ?OR(W,$W,$w) andalso
(not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_)) ->
{Rest0, Pos0, Throw} = expression(<<SP:8,Rest/binary>>, add_pos(Pos,5), []),
case Throw of
[] -> throw_error(eparse, Pos0, Rest);
_ -> code(Rest0, Pos0, [add_line(#throw{value = Throw}, Pos)|Parsed])
end;
code(<<T:8,R:8,Y:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(T,$T,$t) andalso ?OR(R,$R,$r) andalso ?OR(Y,$Y,$y) andalso
(not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_)) ->
{Rest0, Pos0, Code} = code_block(<<SP:8, Rest/binary>>, add_pos(Pos, 3), []),
code(Rest0, copy_level(Pos, Pos0),
[add_line(#try_catch{code_block = Code}, Pos)|Parsed]);
%% TODO catch should be part of try, couldn't be separate!
code(<<C:8,A:8,T:8,C:8,H:8,SP:8,Rest/binary>>, Pos, [#try_catch{} = Try|Parsed])
when ?OR(C,$C,$c) andalso ?OR(A,$A,$a) andalso ?OR(T,$T,$t)
andalso ?OR(H,$H,$h) andalso
(not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_)) ->
{<<"(", Rest0/binary>>, Pos0} =
remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 5)),
{Rest1, Pos1, [Arg]} = ephp_parser_func:funct_args(Rest0, add_pos(Pos0, 1), []),
{Rest2, Pos2, Code} = code_block(Rest1, Pos1, []),
#try_catch{catches = Catches} = Try,
NewCatch = add_line(#catch_block{exception = Arg, code_block = Code}, Pos),
NewTry = Try#try_catch{catches = Catches ++ [NewCatch]},
code(Rest2, copy_level(Pos, Pos2), [NewTry|Parsed]);
code(<<F:8,I:8,N:8,A:8,L:8,L:8,Y:8,SP:8,Rest/binary>>, Pos,
[#try_catch{} = Try|Parsed]) when
?OR(F,$F,$f) andalso ?OR(I,$I,$i) andalso ?OR(N,$N,$n) andalso
?OR(A,$A,$a) andalso ?OR(L,$L,$l) andalso ?OR(Y,$Y,$y) andalso
(not (?IS_ALPHA(SP) orelse ?IS_NUMBER(SP) orelse SP =:= $_)) ->
{Rest0, Pos0, Code} = code_block(<<SP:8, Rest/binary>>, add_pos(Pos, 7), []),
code(Rest0, copy_level(Pos, Pos0), [Try#try_catch{finally = Code}|Parsed]);
code(<<"@", _/binary>> = Rest, Pos, Parsed) ->
{Rest0, Pos0, Exp} = expression(Rest, code_statement_level(Pos), []),
code(Rest0, copy_level(Pos, Pos0), [Exp|Parsed]);
code(<<G:8,L:8,O:8,B:8,A:8,L:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(G,$G,$g) andalso ?OR(L,$L,$l) andalso ?OR(O,$O,$o) andalso
?OR(B,$B,$b) andalso ?OR(A,$A,$a) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0} = remove_spaces(Rest, add_pos(Pos,7)),
{Rest1, Pos1, [Global]} = st_global(Rest0, Pos0, []),
code(Rest1, copy_level(Pos, Pos1), [Global|Parsed]);
code(<<"}",Rest/binary>>, {code_block,_,_}=Pos, Parsed) ->
{Rest, add_pos(Pos,1), lists:reverse(Parsed)};
code(<<"}",Rest/binary>>, {switch_block,_,_}=Pos, Parsed) ->
{Rest, add_pos(Pos,1), lists:reverse(switch_case_block(Parsed))};
code(<<E:8,N:8,D:8,I:8,F:8,SP:8,Rest/binary>>, {if_old_block,_,_}=Pos, Parsed)
when
?OR(E,$E,$e) andalso ?OR(N,$N,$n) andalso ?OR(D,$D,$d) andalso
?OR(I,$I,$i) andalso ?OR(F,$F,$f) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $;) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,5)),
{Rest0, Pos0, lists:reverse(Parsed)};
code(<<E:8,N:8,D:8,S:8,W:8,I:8,T:8,C:8,H:8,SP:8,Rest/binary>>,
{switch_old_block,_,_} = Pos, Parsed) when
?OR(E,$E,$e) andalso ?OR(N,$N,$n) andalso ?OR(D,$D,$d) andalso
?OR(S,$S,$s) andalso ?OR(W,$W,$w) andalso ?OR(I,$I,$i) andalso
?OR(T,$T,$t) andalso ?OR(C,$C,$c) andalso ?OR(H,$H,$h) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $;) ->
{Rest0, Pos0} = remove_spaces(<<SP:8, Rest/binary>>, add_pos(Pos, 9)),
{Rest0, Pos0, lists:reverse(switch_case_block(Parsed))};
code(<<E:8,N:8,D:8,F:8,O:8,R:8,E:8,A:8,C:8,H:8,SP:8,Rest/binary>>,
{foreach_old_block,_,_}=Pos, Parsed) when
?OR(E,$E,$e) andalso ?OR(N,$N,$n) andalso ?OR(D,$D,$d) andalso
?OR(F,$F,$f) andalso ?OR(O,$O,$o) andalso ?OR(R,$R,$r) andalso
?OR(A,$A,$a) andalso ?OR(C,$C,$c) andalso ?OR(H,$H,$h) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $;) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,10)),
{Rest0, Pos0, lists:reverse(Parsed)};
code(<<E:8,N:8,D:8,F:8,O:8,R:8,SP:8,Rest/binary>>,
{for_old_block,_,_}=Pos, Parsed) when
?OR(E,$E,$e) andalso ?OR(N,$N,$n) andalso ?OR(D,$D,$d) andalso
?OR(F,$F,$f) andalso ?OR(O,$O,$o) andalso ?OR(R,$R,$r) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $;) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,6)),
{Rest0, Pos0, lists:reverse(Parsed)};
code(<<E:8,N:8,D:8,W:8,H:8,I:8,L:8,E:8,SP:8,Rest/binary>>,
{while_old_block,_,_}=Pos, Parsed) when
?OR(E,$E,$e) andalso ?OR(N,$N,$n) andalso ?OR(D,$D,$d) andalso
?OR(W,$W,$w) andalso ?OR(H,$H,$h) andalso ?OR(I,$I,$i) andalso
?OR(L,$L,$l) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $;) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,8)),
{Rest0, Pos0, lists:reverse(Parsed)};
code(<<A:8,_/binary>> = Rest, {code_statement,_,_}=Pos, Parsed)
when A =:= $; orelse A =:= $} ->
{Rest, Pos, Parsed};
code(<<T:8,R:8,U:8,E:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(T,$t,$T) andalso ?OR(R,$r,$R) andalso ?OR(U,$u,$U)
andalso ?OR(E,$e,$E) andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, Exp} = expression(Rest, Pos, add_op(true, [])),
code(Rest0, copy_level(Pos, Pos0), [Exp|Parsed]);
code(<<F:8,A:8,L:8,S:8,E:8,SP:8,Rest/binary>>, Pos, 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 (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, Exp} = expression(Rest, Pos, add_op(false, [])),
code(Rest0, copy_level(Pos, Pos0), [Exp|Parsed]);
code(<<I:8,F:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(I,$i,$I) andalso ?OR(F,$f,$F)
andalso (?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, Pos),
{Rest1, Pos1, [If]} = st_if(Rest0, Pos0, []),
code(Rest1, copy_level(Pos,Pos1), [If|Parsed]);
code(<<W:8,H:8,I:8,L:8,E:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(W,$w,$W) andalso ?OR(H,$h,$H) andalso ?OR(I,$i,$I)
andalso ?OR(L,$l,$L) andalso ?OR(E,$e,$E)
andalso (?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,5)),
{Rest1, Pos1, NewParsed} = st_while(Rest0, Pos0, Parsed),
code(Rest1, copy_level(Pos,Pos1), NewParsed);
code(<<D:8,O:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(D,$d,$D) andalso ?OR(O,$o,$O) andalso
(?IS_SPACE(SP) orelse ?OR(SP,${,$:) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, [DoWhile]} = st_do_while(Rest, add_pos(Pos,3), []),
code(Rest0, copy_level(Pos,Pos0), [DoWhile|Parsed]);
code(<<F:8,O:8,R:8,E:8,A:8,C:8,H:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(F,$f,$F) andalso ?OR(O,$o,$O) andalso ?OR(R,$r,$R)
andalso ?OR(E,$e,$E) andalso ?OR(A,$a,$A) andalso ?OR(C,$c,$C)
andalso ?OR(H,$h,$H)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>,Pos),
{Rest1, Pos1, NewParsed} = st_foreach(Rest0, Pos0, Parsed),
code(Rest1, copy_level(Pos, Pos1), NewParsed);
code(<<F:8,O:8,R:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(F,$f,$F) andalso ?OR(O,$o,$O) andalso ?OR(R,$r,$R)
andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>,Pos),
{Rest1, Pos1, NewParsed} = st_for(Rest0, Pos0, Parsed),
code(Rest1, copy_level(Pos, Pos1), NewParsed);
code(<<E:8,L:8,S:8,E:8,SP:8,_/binary>> = Rest, {if_old_block,_,_}=Pos, Parsed)
when ?OR(E,$e,$E) andalso ?OR(L,$l,$L) andalso ?OR(S,$s,$S)
andalso (SP =:= $: orelse ?IS_SPACE(SP) orelse ?OR(SP,$i,$I)) ->
{Rest, Pos, Parsed};
code(<<S:8,W:8,I:8,T:8,C:8,H:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(S,$S,$s) andalso ?OR(W,$W,$w) andalso ?OR(I,$I,$i) andalso
?OR(T,$T,$t) andalso ?OR(C,$C,$c) andalso ?OR(H,$H,$h) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $() ->
{<<"(",_/binary>> = Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, Pos),
{Rest1, Pos1, NewParsed} = st_switch(Rest0, add_pos(Pos0,6), Parsed),
code(Rest1, copy_level(Pos, Pos1), NewParsed);
code(<<C:8,A:8,S:8,E:8,SP:8,Rest/binary>>, {Level,_,_}=Pos, Parsed) when
(Level =:= switch_block orelse Level =:= switch_old_block) andalso
?OR(C,$C,$c) andalso ?OR(A,$A,$a) andalso ?OR(S,$S,$s) andalso
?OR(E,$E,$e) andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos,4)),
NewPos = switch_label_level(Pos0),
case expression(Rest0, NewPos, []) of
{<<":", Rest1/binary>>, Pos1, Exp} -> ok;
{<<";", Rest1/binary>>, Pos1, Exp} -> ok
end,
NewParsed = [add_line(#switch_case{
label=Exp,
code_block=[]
}, Pos)|switch_case_block(Parsed)],
code(Rest1, copy_level(Pos, add_pos(Pos1,1)), NewParsed);
code(<<C:8,A:8,S:8,E:8,SP:8,Rest/binary>>, {code_statement,_,_}=Pos, Parsed) when
?OR(C,$C,$c) andalso ?OR(A,$A,$a) andalso ?OR(S,$S,$s) andalso
?OR(E,$E,$e) andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{<<"case",SP:8,Rest/binary>>, Pos, Parsed};
code(<<D:8,E:8,F:8,A:8,U:8,L:8,T:8,SP:8,Rest/binary>>,
{Level,_,_}=Pos, Parsed) when
(Level =:= switch_block orelse Level =:= switch_old_block) andalso
?OR(D,$D,$d) andalso ?OR(E,$E,$e) andalso ?OR(F,$F,$f) andalso
?OR(A,$A,$a) andalso ?OR(U,$U,$u) andalso ?OR(L,$L,$l) andalso
?OR(T,$T,$t) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $:) ->
case remove_spaces(<<SP:8, Rest/binary>>, add_pos(Pos, 4)) of
{<<":", Rest0/binary>>, Pos0} -> ok;
{<<";", Rest0/binary>>, Pos0} -> ok
end,
NewParsed = [add_line(#switch_case{label = default,
code_block = []},
Pos)|switch_case_block(Parsed)],
code(Rest0, copy_level(Pos, add_pos(Pos0, 1)), NewParsed);
code(<<D:8,E:8,F:8,A:8,U:8,L:8,T:8,SP:8,Rest/binary>>,
{code_statement,_,_}=Pos, Parsed) when
?OR(D,$D,$d) andalso ?OR(E,$E,$e) andalso ?OR(F,$F,$f) andalso
?OR(A,$A,$a) andalso ?OR(U,$U,$u) andalso ?OR(L,$L,$l) andalso
?OR(T,$T,$t) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP) orelse SP =:= $:) ->
{<<"default",SP:8,Rest/binary>>, Pos, Parsed};
code(<<A:8,B:8,S:8,T:8,R:8,A:8,C:8,T:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(A,$A,$a) andalso ?OR(B,$B,$b) andalso ?OR(S,$S,$s) andalso
?OR(T,$T,$t) andalso ?OR(R,$R,$r) andalso ?OR(C,$C,$c) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, Parsed0} = code(Rest, add_pos(Pos,9), []),
Class = lists:last(Parsed0),
{Rest0, Pos0, Parsed0 ++ [Class#class{type = abstract}] ++ Parsed};
code(<<F:8,I:8,N:8,A:8,L:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(F,$F,$f) andalso ?OR(I,$I,$i) andalso ?OR(N,$N,$n) andalso
?OR(A,$A,$a) andalso ?OR(L,$L,$l) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
Class = add_line(#class{final = true}, Pos),
code(<<SP:8,Rest/binary>>, add_pos(Pos, 5), [Class|Parsed]);
code(<<C:8,L:8,A:8,S:8,S:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(C,$C,$c) andalso ?OR(L,$L,$l) andalso ?OR(A,$A,$a) andalso
?OR(S,$S,$s) andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, Class0} = case Parsed of
[#class{name = undefined} = Class|_] ->
ephp_parser_class:st_class(<<SP:8,Rest/binary>>, add_pos(Pos, 5),
Class);
_ ->
Class = add_line(#class{}, Pos),
ephp_parser_class:st_class(<<SP:8,Rest/binary>>, add_pos(Pos, 5),
Class)
end,
code(Rest0, copy_level(Pos, Pos0), [Class0|Parsed]);
code(<<I:8,N:8,T:8,E:8,R:8,F:8,A:8,C:8,E:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(I,$I,$i) andalso ?OR(N,$N,$n) andalso ?OR(T,$T,$t) andalso
?OR(E,$E,$e) andalso ?OR(R,$R,$r) andalso ?OR(F,$F,$f) andalso
?OR(A,$A,$a) andalso ?OR(C,$C,$c) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
Interface = add_line(#class{type = interface}, Pos),
{Rest0, Pos0, Interface0} =
ephp_parser_class:st_interface(<<SP:8,Rest/binary>>, add_pos(Pos, 9),
Interface),
code(Rest0, copy_level(Pos, Pos0), [Interface0|Parsed]);
code(<<E:8,C:8,H:8,O:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(E,$e,$E) andalso ?OR(C,$c,$C) andalso ?OR(H,$h,$H) andalso
?OR(O,$o,$O) andalso
(SP =:= $( orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
Call = add_line(#call{name = <<"print">>}, Pos),
{Rest0, Pos0, [Call0]} =
ephp_parser_func:echo(<<SP:8,Rest/binary>>, add_pos(Pos, 4), [Call]),
% FIXME if we detect an OR or AND expression, we put around print
case Call0#call.args of
[#operation{type=Type}=A1] when Type =:= 'or' orelse Type =:= 'and' ->
Print = A1#operation{
expression_left = get_print(A1#operation.expression_left, Pos)
},
code(Rest0, copy_level(Pos, Pos0), [Print|Parsed]);
_ ->
code(Rest0, copy_level(Pos, Pos0), [Call0|Parsed])
end;
code(<<P:8,R:8,I:8,N:8,T:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(P,$p,$P) andalso ?OR(R,$r,$R) andalso ?OR(I,$i,$I)
andalso ?OR(N,$n,$N) andalso ?OR(T,$t,$T)
andalso (?IS_SPACE(SP) orelse SP =:= $() ->
Call = add_line(#call{name = <<"print">>}, Pos),
{Rest0, Pos0, [Call0]} =
ephp_parser_func:echo(<<SP:8,Rest/binary>>, add_pos(Pos, 5), [Call]),
% FIXME if we detect an OR or AND expression, we put around print
case Call0#call.args of
[#operation{type=Type}=A1] when Type =:= 'or' orelse Type =:= 'and' ->
Print = A1#operation{
expression_left = get_print(A1#operation.expression_left, Pos)
},
code(Rest0, copy_level(Pos, Pos0), [Print|Parsed]);
_ ->
code(Rest0, copy_level(Pos, Pos0), [Call0|Parsed])
end;
code(<<C:8,O:8,N:8,S:8,T:8,SP:8,Rest/binary>>, Pos, Parsed)
when ?OR(C,$c,$C) andalso ?OR(O,$o,$O) andalso ?OR(N,$n,$N)
andalso ?OR(S,$s,$S) andalso ?OR(T,$t,$T) andalso ?IS_SPACE(SP) ->
{Rest0, Pos0, #assign{variable=#constant{}=Const, expression=Value}} =
expression(Rest, add_pos(Pos,6), []),
Constant = Const#constant{type=define, value=Value},
code(Rest0, copy_level(Pos, Pos0), [Constant|Parsed]);
code(<<F:8,U:8,N:8,C:8,T:8,I:8,O:8,N:8,SP:8,Rest/binary>>, Pos, 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) ->
{Rest0, Pos0, [#function{}=Function]} =
ephp_parser_func:st_function(Rest, add_pos(Pos,9), []),
code(Rest0, copy_level(Pos, Pos0), Parsed ++ [Function]);
code(<<F:8,U:8,N:8,C:8,T:8,I:8,O:8,N:8,SP:8,Rest/binary>>, Pos, 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_NEWLINE(SP) ->
NewPos = new_line(add_pos(Pos,8)),
{Rest0, Pos0, #function{}=Function} =
ephp_parser_func:st_function(Rest, NewPos, []),
code(Rest0, copy_level(Pos, Pos0), Parsed ++ [Function]);
code(<<"?>\n",Rest/binary>>, {code_value,_,_}=Pos, [Parsed]) ->
{Rest, new_line(Pos), Parsed};
code(<<"?>",Rest/binary>>, {code_value,_,_}=Pos, [Parsed]) ->
{Rest, add_pos(Pos,2), Parsed};
code(<<"?>\n",Rest/binary>>, {L,_,_}=Pos, Parsed) when
L =:= code_block orelse L =:= if_old_block orelse
L =:= while_old_block orelse L =:= for_old_block orelse
L =:= foreach_old_block orelse L =:= switch_block orelse
L =:= switch_old_block ->
NewPos = new_line(literal_level(Pos)),
{Rest0, Pos0, Text} = document(Rest, NewPos, []),
code(Rest0, copy_level(Pos,Pos0), Text ++ Parsed);
code(<<"?>",Rest/binary>>, {L,_,_}=Pos, Parsed) when
L =:= code_block orelse L =:= if_old_block orelse
L =:= while_old_block orelse L =:= for_old_block orelse
L =:= foreach_old_block orelse L =:= switch_block orelse
L =:= switch_old_block ->
{Rest0, Pos0, Text} = document(Rest, literal_level(add_pos(Pos, 2)), []),
code(Rest0, copy_level(Pos,Pos0), Text ++ Parsed);
code(<<"?>", _/binary>> = Rest, {code_statement,_,_} = Pos, Parsed) ->
{Rest, Pos, Parsed};
code(<<"?>\n", Rest/binary>>, Pos, Parsed) ->
{Rest, new_line(Pos), Parsed};
code(<<"?>", Rest/binary>>, Pos, Parsed) ->
{Rest, add_pos(Pos, 2), Parsed};
code(<<"//", Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, add_pos(Pos, 2), Parsed),
code(Rest0, Pos0, Parsed);
code(<<"#", Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, add_pos(Pos, 1), Parsed),
code(Rest0, Pos0, Parsed);
code(<<"/*", Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_block(Rest, add_pos(Pos, 2), Parsed),
code(Rest0, Pos0, Parsed);
code(<<"<<<", _/binary>> = Rest, Pos, Parsed) ->
{Rest0, Pos0, S} = ephp_parser_string:string(Rest,Pos,[]),
code(Rest0, copy_level(Pos, Pos0), [S|Parsed]);
code(<<I:8,N:8,C:8,L:8,U:8,D:8,E:8,SP:8,Rest/binary>>, Pos, 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 (?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 7)),
{Rest1, Pos1, Exp} = expression(Rest0, Pos0, []),
Include = add_line(#call{name = <<"include">>, args=[Exp]}, Pos),
code(Rest1, Pos1, [Include|Parsed]);
code(<<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>>,
Pos, 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
(?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 7)),
{Rest1, Pos1, Exp} = expression(Rest0, Pos0, []),
Include = add_line(#call{name = <<"include_once">>, args=[Exp]}, Pos),
code(Rest1, Pos1, [Include|Parsed]);
code(<<R:8,E:8,Q:8,U:8,I:8,R:8,E:8,SP:8,Rest/binary>>, Pos, 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
(?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 7)),
{Rest1, Pos1, Exp} = expression(Rest0, Pos0, []),
Include = add_line(#call{name = <<"require">>, args=[Exp]}, Pos),
code(Rest1, Pos1, [Include|Parsed]);
code(<<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>>,
Pos, 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
(?IS_SPACE(SP) orelse SP =:= $() ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 7)),
{Rest1, Pos1, Exp} = expression(Rest0, Pos0, []),
Include = add_line(#call{name = <<"require_once">>, args=[Exp]}, Pos),
code(Rest1, Pos1, [Include|Parsed]);
code(<<S:8,T:8,A:8,T:8,I:8,C:8,SP:8,Rest/binary>>, Pos, Parsed) when
?OR(S,$S,$s) andalso ?OR(T,$T,$t) andalso ?OR(A,$A,$a) andalso
?OR(I,$I,$i) andalso ?OR(C,$C,$c) andalso
(?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0, Parsed0} = static(Rest, add_pos(Pos, 7), []),
code(Rest0, copy_level(Pos, Pos0), Parsed0 ++ Parsed);
code(<<A:8,_/binary>> = Rest, Pos, [#constant{}|_])
when ?IS_ALPHA(A) orelse A =:= $_ ->
throw_error(eparse, Pos, Rest);
code(<<A:8,_/binary>> = Rest, Pos, Parsed) when ?IS_ALPHA(A) orelse A =:= $_ ->
{Rest0, Pos0, Parsed0} = expression(Rest,Pos,[]),
code(Rest0, copy_level(Pos, Pos0), [Parsed0] ++ Parsed);
code(<<A:8,_/binary>> = Rest, Pos, Parsed) when ?IS_NUMBER(A)
orelse A =:= $- orelse A =:= $(
orelse A =:= $" orelse A =:= $'
orelse A =:= $$ orelse A =:= $+
orelse A =:= 126 orelse A =:= $! ->
{Rest0, Pos0, Exp} = expression(Rest, Pos, []),
code(Rest0, copy_level(Pos, Pos0), [Exp|Parsed]);
code(<<Space:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(Space) ->
code(Rest, add_pos(Pos,1), Parsed);
code(<<NewLine:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(NewLine) ->
code(Rest, new_line(Pos), Parsed);
code(<<";",Rest/binary>>, Pos, Parsed) ->
code(Rest, add_pos(Pos,1), Parsed);
code(Rest, Pos, [#try_catch{catches = C, finally = F}|_Parsed])
when C =:= [] andalso F =:= [] ->
throw_error(enocatch, Pos, Rest);
code(<<>>, Pos, Parsed) ->
{<<>>, Pos, Parsed};
code(Text, Pos, _Parsed) ->
throw_error(eparse, Pos, Text).
code_block(<<"//",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, Pos, Parsed),
code_block(Rest0, Pos0, Parsed);
code_block(<<"#",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, Pos, Parsed),
code_block(Rest0, Pos0, Parsed);
code_block(<<"/*",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_block(Rest, Pos, Parsed),
code_block(Rest0, Pos0, Parsed);
code_block(<<";",Rest/binary>>, {{_,abstract},_,_}=Pos, Parsed) ->
{Rest, add_pos(Pos,1), Parsed};
%% TODO change this to use always 'code/3' as one statement and block calls
%% several times until '}' is received. Same for old block but given known
%% constants instead.
code_block(<<"{", Rest/binary>>, Pos, Parsed) ->
code(Rest, code_block_level(add_pos(Pos, 1)), Parsed);
code_block(<<":", Rest/binary>>, {if_block,_,_}=Pos, Parsed) ->
code(Rest, if_old_block_level(add_pos(Pos, 1)), Parsed);
code_block(<<":", Rest/binary>>, {foreach_block,_,_}=Pos, Parsed) ->
code(Rest, foreach_old_block_level(add_pos(Pos,1)), Parsed);
code_block(<<":", Rest/binary>>, {for_block,_,_}=Pos, Parsed) ->
code(Rest, for_old_block_level(add_pos(Pos,1)), Parsed);
code_block(<<":", Rest/binary>>, {while_block,_,_}=Pos, Parsed) ->
code(Rest, while_old_block_level(add_pos(Pos,1)), Parsed);
code_block(<<SP:8, Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
code_block(Rest, add_pos(Pos,1), Parsed);
code_block(<<SP:8, Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
code_block(Rest, new_line(Pos), Parsed);
code_block(<<>>, Pos, Parsed) ->
{<<>>, Pos, Parsed};
code_block(Rest, Pos, Parsed) ->
code(Rest, code_statement_level(Pos), Parsed).
static(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
static(Rest, add_pos(Pos,1), Parsed);
static(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
static(Rest, new_line(Pos), Parsed);
static(<<",",Rest/binary>>, Pos, Parsed) when Parsed =/= [] ->
static(Rest, new_line(Pos), Parsed);
static(<<",",_/binary>>, Pos, _Parsed) ->
throw_error(eparse, Pos, <<",">>);
static(<<";",_/binary>> = Rest, Pos, Parsed) ->
{Rest, Pos, Parsed};
static(<<>>, Pos, _Parsed) ->
throw_error(eparse, Pos, <<>>);
static(Rest, Pos, Parsed) ->
case expression(Rest, arg_level(Pos), []) of
{Rest0, Pos0, #assign{variable=Var}=Assign} ->
NewAssign = Assign#assign{variable = Var#variable{type = static}},
static(Rest0, copy_level(Pos, Pos0), Parsed ++ [NewAssign]);
{Rest0, Pos0, #variable{}=Var} ->
NewVar = Var#variable{type = static},
static(Rest0, copy_level(Pos, Pos0), Parsed ++ [NewVar])
end.
variable(<<SP:8,Rest/binary>>, Pos, []) when ?IS_SPACE(SP) ->
variable(Rest, add_pos(Pos,1), []);
variable(<<SP:8,Rest/binary>>, {enclosed,_,_}=Pos, Var) when ?IS_SPACE(SP) ->
variable(Rest, add_pos(Pos,1), Var);
variable(<<SP:8,Rest/binary>>, Pos, []) when ?IS_NEWLINE(SP) ->
variable(Rest, new_line(Pos), []);
variable(<<SP:8,Rest/binary>>, {enclosed,_,_}=Pos, Var) when ?IS_NEWLINE(SP) ->
variable(Rest, new_line(Pos), Var);
variable(<<"$",Rest/binary>>, Pos, []) ->
variable(Rest, add_pos(Pos,1), []);
variable(<<A:8,Rest/binary>>, Pos, [])
when ?IS_ALPHA(A) orelse A =:= $_ orelse A >= 16#7f ->
Var = add_line(#variable{name = <<A:8>>}, Pos),
variable(Rest, add_pos(Pos, 1), [Var]);
variable(<<A:8, Rest/binary>>, {_,_,_} = Pos, [#variable{name = N} = V])
when ?IS_NUMBER(A) orelse ?IS_ALPHA(A) orelse A =:= $_
orelse A >= 16#7f ->
variable(Rest, add_pos(Pos,1), [V#variable{name = <<N/binary, A:8>>}]);
variable(<<SP:8, _/binary>> = Rest, {unclosed, _, _} = Pos, Var)
when ?IS_SPACE(SP) ->
{Rest, add_pos(Pos,1), Var};
variable(<<SP:8, _/binary>> = Rest, {unclosed, _, _} = Pos, Var)
when ?IS_NEWLINE(SP) ->
{Rest, new_line(Pos), Var};
variable(Rest, Pos, []) ->
throw_error(eparse, Pos, Rest);
variable(Rest, Pos, Var) ->
var_access(Rest, Pos, Var).
var_access(<<"}", _/binary>> = Rest, {enclosed, _, _} = Pos, Var) ->
{Rest, Pos, Var};
var_access(<<"[", Rest/binary>>, Pos, [#variable{idx = Indexes} = Var]) ->
{Rest1, Pos1, RawIdx} = expression(Rest, array_level(add_pos(Pos, 1)), []),
Idx = case RawIdx of
[] -> auto;
_ -> RawIdx
end,
NewVar = Var#variable{idx = Indexes ++ [Idx]},
var_access(Rest1, copy_level(Pos, Pos1), [NewVar]);
var_access(<<"{", Rest/binary>>, Pos, [#variable{idx = Indexes} = Var]) ->
NewPos = array_curly_level(add_pos(Pos, 1)),
{Rest1, Pos1, RawIdx} = expression(Rest, NewPos, []),
Idx = case RawIdx of
[] -> auto;
_ -> RawIdx
end,
NewVar = Var#variable{idx = Indexes ++ [Idx]},
var_access(Rest1, copy_level(Pos, Pos1), [NewVar]);
var_access(<<"->",Rest/binary>>, {L,_,_}=Pos, [#variable{}=Var])
when is_number(L) ->
% TODO move this code to ephp_parser_expr
OpL = <<"->">>,
Op = add_op({OpL, precedence(OpL), Pos}, add_op(Var, [])),
{Rest0, Pos0, [Exp]} = accessor(Rest, arg_level(add_pos(Pos,2)), []),
var_access(Rest0, copy_level(Pos, Pos0), [add_op('end', add_op(Exp, Op))]);
var_access(<<"->",Rest/binary>>, Pos, [#variable{}=Var]) ->
% TODO move this code to ephp_parser_expr
OpL = <<"->">>,
Op = add_op({OpL, precedence(OpL), Pos}, add_op(Var, [])),
{Rest0, Pos0, [Exp]} = accessor(Rest, add_pos(Pos,2), []),
var_access(Rest0, copy_level(Pos, Pos0), [add_op('end', add_op(Exp, Op))]);
var_access(Rest, Pos, Parsed) ->
{Rest, Pos, Parsed}.
accessor(<<A:8, Rest/binary>>, Pos, Parsed) when ?IS_SPACE(A) ->
accessor(Rest, add_pos(Pos, 1), Parsed);
accessor(<<A:8, Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(A) ->
accessor(Rest, new_line(Pos), Parsed);
accessor(<<A:8, _/binary>> = Rest, Pos, []) when ?IS_ALPHA(A) orelse A =:= $_ ->
constant(Rest, Pos, []);
accessor(<<"$", Rest/binary>>, Pos, []) ->
variable(Rest, Pos, []);
accessor(<<"{", Rest/binary>>, Pos, []) ->
NewPos = add_pos(enclosed_level(Pos), 1),
{Rest0, Pos0, Acc} = expression(Rest, NewPos, []),
case remove_spaces(Rest0, Pos0) of
{<<"(", Rest1/binary>>, Pos1} ->
NPos1 = add_pos(Pos1, 1),
{Rest2, Pos2, Args} = ephp_parser_func:call_args(Rest1, NPos1, []),
{Rest2, copy_level(Pos, Pos2),
[add_line(#call{name = Acc, args = Args}, Pos1)]};
{Rest1, Pos1} ->
{Rest1, copy_level(Pos, Pos1), [Acc]}
end;
accessor(<<>>, Pos, Parsed) ->
{<<>>, Pos, Parsed};
accessor(_Rest, Pos, []) ->
throw_error(eparse, Pos, {<<"`\"identifier (T_STRING)\"' or "
"`\"variable (T_VARIABLE)\"' or "
"`'{'' or `'$''">>}).
constant(<<A:8,Rest/binary>>, Pos, []) when ?IS_ALPHA(A) orelse A =:= $_ ->
constant(Rest, add_pos(Pos,1), [add_line(#constant{name = <<A:8>>},Pos)]);
constant(<<A:8,Rest/binary>>, Pos, [#constant{name = N} = C])
when ?IS_ALPHA(A) orelse ?IS_NUMBER(A) orelse A =:= $_ ->
constant(Rest, add_pos(Pos,1), [C#constant{name = <<N/binary, A:8>>}]);
constant(<<SP:8,_/binary>> = Rest, {unclosed,_,_}=Pos, [#constant{}]=Parsed)
when ?IS_SPACE(SP) ->
{Rest, Pos, Parsed};
constant(<<SP:8,Rest/binary>>, Pos, [#constant{}]=Parsed)
when ?IS_SPACE(SP) ->
constant_wait(Rest, add_pos(Pos,1), Parsed);
constant(<<SP:8,_/binary>> = Rest, {unclosed,_,_}=Pos, [#constant{}]=Parsed)
when ?IS_NEWLINE(SP) ->
{Rest, Pos, Parsed};
constant(<<SP:8,Rest/binary>>, Pos, [#constant{}]=Parsed)
when ?IS_NEWLINE(SP) ->
constant_wait(Rest, new_line(Pos), Parsed);
constant(<<"(",_/binary>> = Rest, Pos, Parsed) ->
constant_wait(Rest, Pos, Parsed);
% TODO fail when unclosed is used?
constant(<<"::",_/binary>> = Rest, Pos, Parsed) ->
constant_wait(Rest, Pos, Parsed);
constant(Rest, Pos, Parsed) ->
{Rest, Pos, constant_known(Parsed, Pos)}.
%% if after one or several spaces there are a parens, it's a function
%% but if not, it should returns
constant_wait(<<"(", Rest/binary>>, Pos, [#constant{} = C]) ->
Call = #call{name = C#constant.name, line = C#constant.line},
ephp_parser_func:function(Rest, add_pos(Pos, 1), [Call]);
constant_wait(<<"::$", Rest/binary>>, Pos, [#constant{} = C]) ->
NewPos = arg_level(add_pos(Pos, 2)),
{Rest1, Pos1, [Var]} = variable(<<"$", Rest/binary>>, NewPos, []),
NewVar = Var#variable{type = class, class = C#constant.name},
{Rest1, copy_level(Pos, Pos1), [NewVar]};
constant_wait(<<"::",Rest/binary>>, Pos, [#constant{}=Cons]) ->
case constant(Rest, add_pos(Pos,2), []) of
{Rest1, Pos1, [#constant{name = <<"class">>}]} ->
{Rest1, Pos1, [add_line(#text{text=Cons#constant.name}, Pos)]};
{Rest1, Pos1, [#constant{}=C]} ->
{Rest1, Pos1, [C#constant{type=class, class=Cons#constant.name}]};
{Rest1, Pos1, [#call{}=C]} ->
{Rest1, Pos1, [C#call{type=class, class=Cons#constant.name}]}
end;
constant_wait(<<SP:8,Rest/binary>>, Pos, [#constant{}]=Parsed)
when ?IS_SPACE(SP) ->
constant_wait(Rest, add_pos(Pos,1), Parsed);
constant_wait(<<SP:8,Rest/binary>>, Pos, [#constant{}]=Parsed)
when ?IS_NEWLINE(SP) ->
constant_wait(Rest, new_line(Pos), Parsed);
constant_wait(Rest, Pos, Parsed) ->
{Rest, Pos, constant_known(Parsed, Pos)}.
constant_known([#constant{name = <<"__LINE__">>}|Parsed], {_,R,_}=Pos) ->
[add_line(#int{int = R}, Pos)|Parsed];
constant_known([#constant{name = <<"exit">>}|Parsed], Pos) ->
[add_line(#call{name = <<"exit">>}, Pos)|Parsed];
constant_known(C, _Pos) ->
C.
st_global(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
st_global(Rest, add_pos(Pos,1), Parsed);
st_global(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
st_global(Rest, new_line(Pos), Parsed);
st_global(<<",",Rest/binary>>, Pos, Parsed) ->
st_global(Rest, add_pos(Pos,1), Parsed);
st_global(<<";", _/binary>> = Rest, Pos, Parsed) ->
Global = add_line(#global{vars = Parsed}, Pos),
{Rest, Pos, [Global]};
st_global(<<"$",_/binary>> = Rest, Pos, Parsed) ->
{Rest0, Pos0, [Var]} = variable(Rest, Pos, []),
st_global(Rest0, Pos0, [Var|Parsed]).
st_while(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
st_while(Rest, add_pos(Pos,1), Parsed);
st_while(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
st_while(Rest, new_line(Pos), Parsed);
st_while(<<"(",Rest/binary>>, Pos, Parsed) ->
NewPos = add_pos(Pos,1),
{<<")",Rest1/binary>>, Pos1, Conditions} =
expression(Rest, arg_level(NewPos), []),
{Rest2, Pos2, CodeBlock} = code_block(Rest1, while_block_level(Pos1), []),
While = add_line(#while{
type=pre,
conditions=Conditions,
loop_block=CodeBlock
}, Pos),
{Rest2, copy_level(Pos, Pos2), [While|Parsed]};
st_while(<<>>, Pos, _Parsed) ->
throw_error(eparse, Pos, <<>>).
st_do_while(Rest, Pos, Parsed) ->
case code_block(Rest, Pos, []) of
{<<";",Rest0/binary>>, Pos0, CodeBlock} -> ok;
{Rest0, Pos0, CodeBlock} -> ok
end,
{<<WhileRaw:5/binary,Rest1/binary>>, Pos1} = remove_spaces(Rest0, Pos0),
<<"while">> = ephp_string:to_lower(WhileRaw),
{Rest2, Pos2, [While]} = st_while(Rest1, Pos1, []),
DoWhile = add_line(While#while{
type=post,
loop_block=CodeBlock
}, Pos),
{Rest2, copy_level(Pos, Pos2), [DoWhile|Parsed]}.
st_if(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
st_if(Rest, add_pos(Pos,1), Parsed);
st_if(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
st_if(Rest, new_line(Pos), Parsed);
st_if(<<";",Rest/binary>>, Pos, [#if_block{}] = Parsed) ->
st_if(Rest, add_pos(Pos, 1), Parsed);
st_if(<<"//",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, Pos, Parsed),
st_if(Rest0, Pos0, Parsed);
st_if(<<"#",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_line(Rest, Pos, Parsed),
st_if(Rest0, Pos0, Parsed);
st_if(<<"/*",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, _} = comment_block(Rest, Pos, Parsed),
st_if(Rest0, Pos0, Parsed);
st_if(<<"(",Rest/binary>>, Pos, []) ->
NewPos = add_pos(Pos,1),
{<<")",Rest1/binary>>, Pos1, Conditions} =
expression(Rest, arg_level(NewPos), []),
{Rest2, Pos2, CodeBlock} = code_block(Rest1, if_block_level(Pos1), []),
If = add_line(#if_block{
conditions=Conditions,
true_block=CodeBlock
}, Pos),
st_if(Rest2, copy_level(Pos, Pos2), [If]);
st_if(<<E:8,L:8,S:8,E:8,SP:8,Rest/binary>>, Pos, [#if_block{} = If|Parsed]) when
?OR(E,$e,$E) andalso ?OR(L,$l,$L) andalso ?OR(S,$s,$S) andalso
(?OR(SP,${,$:) orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest0, Pos0} = remove_spaces(<<SP:8,Rest/binary>>, add_pos(Pos, 4)),
BlockPos = if_block_level(Pos0),
{Rest1, Pos1, CodeBlock} = code_block(Rest0, BlockPos, []),
IfWithElse = If#if_block{false_block = CodeBlock},
{Rest1, copy_level(Pos, Pos1), [IfWithElse|Parsed]};
st_if(<<E:8,L:8,S:8,E:8,I:8,F:8,SP:8,Rest/binary>>, Pos,
[#if_block{} = If|Parsed]) when
?OR(E,$e,$E) andalso ?OR(L,$l,$L) andalso ?OR(S,$s,$S) andalso
?OR(I,$i,$I) andalso ?OR(F,$f,$F) andalso
(SP =:= $( orelse ?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
{Rest1, Pos1, CodeBlock} = st_if(<<SP:8,Rest/binary>>, add_pos(Pos, 6), []),
IfWithElse = If#if_block{false_block = CodeBlock},
{Rest1, copy_level(Pos, Pos1), [IfWithElse|Parsed]};
st_if(<<>>, Pos, [#if_block{}] = Parsed) ->
{<<>>, Pos, Parsed};
st_if(<<>>, Pos, _Parsed) ->
throw_error(eparse, Pos, <<>>);
st_if(Rest, Pos, [#if_block{}]=Parsed) ->
{Rest, Pos, Parsed}.
args(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
args(Rest, add_pos(Pos,1), Parsed);
args(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
args(Rest, new_line(Pos), Parsed);
args(Rest, Pos, Args) when Rest =/= <<>> ->
case expression(Rest, arg_level(Pos), []) of
{<<")",_/binary>> = Rest0, Pos0, Arg} ->
{Rest0, add_pos(Pos0,1), Args ++ [Arg]};
{<<";",_/binary>> = Rest0, Pos0, Arg} ->
{Rest0, add_pos(Pos0,1), Args ++ [Arg]};
{<<",", Rest0/binary>>, Pos0, Arg} ->
args(Rest0, add_pos(Pos0, 1), Args ++ [Arg]);
{Rest0, Pos0, Arg} ->
args(Rest0, Pos0, Args ++ [Arg])
end.
st_foreach(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
st_foreach(Rest, add_pos(Pos,1), Parsed);
st_foreach(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
st_foreach(Rest, new_line(Pos), Parsed);
st_foreach(<<"(",Rest/binary>>, Pos, Parsed) ->
{Rest0, Pos0, Exp} = expression(Rest, foreach_block_level(Pos), []),
{<<AS:2/binary,Rest1/binary>>, Pos1} = remove_spaces(Rest0, Pos0),
<<"as">> = ephp_string:to_lower(AS),
NewPos = array_def_level(add_pos(Pos1,2)),
{<<")",Rest2/binary>>, Pos2, ExpIter} = expression(Rest1, NewPos, []),
BlockPos = foreach_block_level(add_pos(Pos2,1)),
{Rest3, Pos3, CodeBlock} = code_block(Rest2, BlockPos, []),
RawFor = add_line(#foreach{
iter=ExpIter,
elements=Exp,
loop_block=CodeBlock
}, Pos),
For = case ExpIter of
#ref{} ->
RawFor;
#variable{} ->
RawFor;
[KIter,Iter] ->
RawFor#foreach{kiter=KIter, iter=Iter}
end,
{Rest3, copy_level(Pos, Pos3), [For|Parsed]}.
switch_case_block([]) ->
[];
switch_case_block(Blocks) ->
{Block, [Switch|Rest]} = lists:splitwith(fun
(#switch_case{}) -> false;
(_) -> true
end, Blocks),
[Switch#switch_case{code_block = lists:reverse(Block)}|Rest].
st_switch(<<"(",Rest/binary>>, Pos, Parsed) ->
{<<")", Rest0/binary>>, Pos0, Cond} = expression(Rest, add_pos(Pos,1), []),
NewPos = case remove_spaces(Rest0, add_pos(Pos0, 1)) of
{<<"{", Rest1/binary>>, Pos1} ->
switch_block_level(add_pos(Pos1, 1));
{<<":", Rest1/binary>>, Pos1} ->
switch_old_block_level(add_pos(Pos1, 1))
end,
{Rest2, Pos2, CodeBlock} = code(Rest1, NewPos, []),
Switch = add_line(#switch{condition = Cond, cases = CodeBlock}, Pos),
{Rest2, copy_level(Pos, Pos2), [Switch|Parsed]}.
st_for(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(SP) ->
st_for(Rest, add_pos(Pos,1), Parsed);
st_for(<<SP:8,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(SP) ->
st_for(Rest, new_line(Pos), Parsed);
st_for(<<"(",Rest/binary>>, Pos, Parsed) ->
{<<";",Rest0/binary>>, Pos0, Init} = args(Rest, add_pos(Pos,1), []),
{<<";",Rest1/binary>>, Pos1, [Cond]} = args(Rest0, add_pos(Pos0,1), []),
{<<")",Rest2/binary>>, Pos2, Upda} = args(Rest1, add_pos(Pos1,1), []),
{Rest3, Pos3, CodeBlock} = code_block(Rest2,
for_block_level(add_pos(Pos2,1)), []),
For = add_line(#for{
init=Init, conditions=Cond, update=Upda, loop_block=CodeBlock
}, Pos),
{Rest3, copy_level(Pos, Pos3), [For|Parsed]}.
comment_line(<<>>, Pos, Parsed) ->
{<<>>, Pos, Parsed};
comment_line(<<"?>", _/binary>> = Rest, Pos, Parsed) ->
{Rest, Pos, Parsed};
comment_line(<<A:8, Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(A) ->
{Rest, new_line(Pos), Parsed};
comment_line(<<_/utf8, Rest/binary>>, Pos, Parsed) ->
comment_line(Rest, add_pos(Pos, 1), Parsed).
comment_block(<<>>, Pos, _Parsed) ->
%% TODO: throw parse error
throw_error(eparse, Pos, missing_comment_end);
comment_block(<<"*/", Rest/binary>>, Pos, Parsed) ->
{Rest, add_pos(Pos,2), Parsed};
comment_block(<<A:8, Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(A) ->
comment_block(Rest, new_line(Pos), Parsed);
comment_block(<<_/utf8, Rest/binary>>, Pos, Parsed) ->
comment_block(Rest, add_pos(Pos, 1), Parsed).
%%------------------------------------------------------------------------------
%% helper functions
%%------------------------------------------------------------------------------
add_to_text(L, _Pos, [#print_text{text=Text}=P|Parsed]) ->
NewText = <<Text/binary, L/binary>>,
[P#print_text{text=NewText}|Parsed];
add_to_text(L, Pos, Parsed) ->
[add_line(#print_text{text=L}, Pos)|Parsed].
add_pos({Level,Row,Col}, Offset) ->
{Level,Row,Col+Offset}.
new_line({Level, Row, _Col}, N) ->
{Level, Row + N, 1}.
new_line(Pos) ->
new_line(Pos, 1).
if_old_block_level({_,Row,Col}) -> {if_old_block,Row,Col}.
for_old_block_level({_,Row,Col}) -> {for_old_block,Row,Col}.
foreach_old_block_level({_,Row,Col}) -> {foreach_old_block,Row,Col}.
while_old_block_level({_,Row,Col}) -> {while_old_block,Row,Col}.
switch_old_block_level({_,Row,Col}) -> {switch_old_block,Row,Col}.
if_block_level({_,Row,Col}) -> {if_block,Row,Col}.
for_block_level({_,Row,Col}) -> {for_block,Row,Col}.
foreach_block_level({_,Row,Col}) -> {foreach_block,Row,Col}.
while_block_level({_,Row,Col}) -> {while_block,Row,Col}.
switch_block_level({_,Row,Col}) -> {switch_block,Row,Col}.
switch_label_level({_,Row,Col}) -> {switch_label,Row,Col}.
normal_level({_,Row,Col}) -> {code,Row,Col}.
code_block_level({_,Row,Col}) -> {code_block,Row,Col}.
code_value_level({_,Row,Col}) -> {code_value,Row,Col}.
code_statement_level({_,Row,Col}) -> {code_statement,Row,Col}.
arg_level({_,Row,Col}) -> {arg,Row,Col}.
array_level({_,Row,Col}) -> {array,Row,Col}.
array_curly_level({_,Row,Col}) -> {array_curly,Row,Col}.
array_def_level({_,Row,Col}) -> {{array_def,0},Row,Col}.
literal_level({_,Row,Col}) -> {literal,Row,Col}.
enclosed_level({_, Row, Col}) -> {enclosed, Row, Col}.
unclosed_level({_, Row, Col}) -> {unclosed, Row, Col}.
add_line(true, _) -> true;
add_line(false, _) -> false;
add_line(X, {{line,Row},{column,Col}}) -> add_line(X, {x,Row,Col});
add_line(#array{}=A, {_,Row,Col}) -> A#array{line={{line,Row},{column,Col}}};
add_line(#eval{}=E, {_,Row,Col}) -> E#eval{line={{line,Row},{column,Col}}};
add_line(#print{}=P, {_,Row,Col}) -> P#print{line={{line,Row},{column,Col}}};
add_line(#print_text{}=P, {_,Row,Col}) ->
P#print_text{line={{line,Row},{column,Col}}};
add_line(#variable{}=V, {_,R,C}) -> V#variable{line={{line,R},{column,C}}};
add_line(#constant{}=O, {_,R,C}) -> O#constant{line={{line,R},{column,C}}};
add_line(#int{}=I, {_,R,C}) -> I#int{line={{line,R},{column,C}}};
add_line(#float{}=F, {_,R,C}) -> F#float{line={{line,R},{column,C}}};
add_line(#text_to_process{}=T, {_,R,C}) ->
T#text_to_process{line={{line,R},{column,C}}};
add_line(#text{}=T, {_,R,C}) -> T#text{line={{line,R},{column,C}}};
add_line(#if_block{}=I, {_,R,C}) -> I#if_block{line={{line,R},{column,C}}};
add_line(#assign{}=A, {_,R,C}) -> A#assign{line={{line,R},{column,C}}};
add_line(#array_element{}=A, {_,R,C}) ->
A#array_element{line={{line,R},{column,C}}};
add_line(#for{}=F, {_,R,C}) -> F#for{line={{line,R},{column,C}}};
add_line(#foreach{}=F, {_,R,C}) -> F#foreach{line={{line,R},{column,C}}};
add_line(#operation{}=O, {_,R,C}) -> O#operation{line={{line,R},{column,C}}};
add_line(#concat{}=O, {_,R,C}) -> O#concat{line={{line,R},{column,C}}};
add_line(#while{}=W, {_,R,C}) -> W#while{line={{line,R},{column,C}}};
add_line(#return{}=Rt, {_,R,C}) -> Rt#return{line={{line,R},{column,C}}};
add_line(#function{}=F, {_,R,C}) -> F#function{line={{line,R},{column,C}}};
add_line(#global{}=G, {_,R,C}) -> G#global{line={{line,R},{column,C}}};
add_line(#ref{}=Rf, {_,R,C}) -> Rf#ref{line={{line,R},{column,C}}};
add_line(#switch{}=S, {_,R,C}) -> S#switch{line={{line,R},{column,C}}};
add_line(#switch_case{}=S, {_,R,C}) -> S#switch_case{line={{line,R},{column,C}}};
add_line(#call{}=Cl, {_,R,C}) -> Cl#call{line={{line,R},{column,C}}};
add_line(#class{}=Cl, {_,R,C}) -> Cl#class{line={{line,R},{column,C}}};
add_line(#class_method{}=CM, {_,R,C}) ->
CM#class_method{line={{line,R},{column,C}}};
add_line(#class_const{}=CC, {_,R,C}) ->
CC#class_const{line={{line,R},{column,C}}};
add_line(#class_attr{}=CA, {_,R,C}) ->
CA#class_attr{line={{line,R},{column,C}}};
add_line({object, Expr}, {_,R,C}) -> {object, Expr, {{line,R},{column,C}}};
add_line({class, Expr}, {_,R,C}) -> {class, Expr, {{line,R},{column,C}}};
add_line(#instance{}=I, {_,R,C}) -> I#instance{line={{line,R},{column,C}}};
add_line(#cast{}=Cs, {_,R,C}) -> Cs#cast{line={{line,R},{column,C}}};
add_line(#throw{}=T, {_,R,C}) -> T#throw{line={{line,R},{column,C}}};
add_line(#try_catch{}=T, {_,R,C}) -> T#try_catch{line={{line,R},{column,C}}};
add_line(#catch_block{}=B, {_,R,C}) -> B#catch_block{line={{line,R},{column,C}}};
add_line(#clone{}=L, {_,R,C}) -> L#clone{line={{line,R},{column,C}}};
add_line(#command{}=Co, {_,R,C}) -> Co#command{line={{line,R},{column,C}}}.
remove_spaces(<<SP:8, Rest/binary>>, Pos) when ?IS_SPACE(SP) ->
remove_spaces(Rest, add_pos(Pos, 1));
remove_spaces(<<SP:8, Rest/binary>>, Pos) when ?IS_NEWLINE(SP) ->
remove_spaces(Rest, new_line(Pos));
remove_spaces(<<>>, Pos) -> {<<>>, Pos};
remove_spaces(Rest, Pos) -> {Rest, Pos}.
get_print({Type, Value, _}, Pos) when
Type =:= int; Type =:= float; Type =:= text ->
add_line(#print_text{text=ephp_data:to_bin(Value)}, Pos);
get_print(Value, Pos) when is_atom(Value) ->
add_line(#print_text{text=ephp_data:to_bin(Value)}, Pos);
get_print(Expr, Pos) ->
add_line(#print{expression=Expr}, Pos).
throw_error(Error, {_Level, Row, Col}, Data) when is_binary(Data) ->
Output = iolist_to_binary(Data),
Size = min(byte_size(Output), 20),
Index = {{line, Row}, {column, Col}},
LimitedData = <<Output:Size/binary, "...">>,
ephp_error:error({error, Error, Index, ?E_PARSE, LimitedData});
throw_error(Error, {_Level, Row, Col}, Data) when is_tuple(Data) ->
Index = {{line, Row}, {column, Col}},
ephp_error:error({error, Error, Index, ?E_PARSE, Data}).