123 lines
4.4 KiB
Erlang
123 lines
4.4 KiB
Erlang
%% Copyright 2010, 2011, 2012 Tony Garnock-Jones <tonygarnockjones@gmail.com>.
|
|
%%
|
|
%% This file is part of Hop.
|
|
%%
|
|
%% Hop is free software: you can redistribute it and/or modify it
|
|
%% under the terms of the GNU General Public License as published by
|
|
%% the Free Software Foundation, either version 3 of the License, or
|
|
%% (at your option) any later version.
|
|
%%
|
|
%% Hop is distributed in the hope that it will be useful, but WITHOUT
|
|
%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
%% or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|
%% License for more details.
|
|
%%
|
|
%% You should have received a copy of the GNU General Public License
|
|
%% along with Hop. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
-module(sexp).
|
|
%% SPKI SEXP.
|
|
|
|
-export([lex_state/0, lex/1, lex/2]).
|
|
-export([parse_state/0, parse/1, parse/2]).
|
|
-export([format/1, format_iolist/1]).
|
|
|
|
%% Lexer states
|
|
-record(init, {}).
|
|
-record(str, {remaining, pieces_rev}).
|
|
-record(strlen, {value}).
|
|
|
|
%% Parser states
|
|
-record(parser, {lexer, stack}).
|
|
|
|
-define(ZERO, 48).
|
|
-define(NINE, 57).
|
|
|
|
lex_state() ->
|
|
#init{}.
|
|
|
|
lex(Chunk) ->
|
|
lex(Chunk, lex_state()).
|
|
|
|
lex(<<"(", Rest/binary>>, State = #init{}) ->
|
|
{Events, FinalState} = lex(Rest, State),
|
|
{[open | Events], FinalState};
|
|
lex(<<")", Rest/binary>>, State = #init{}) ->
|
|
{Events, FinalState} = lex(Rest, State),
|
|
{[close | Events], FinalState};
|
|
lex(<<"[", Rest/binary>>, State = #init{}) ->
|
|
{Events, FinalState} = lex(Rest, State),
|
|
{[hint_open | Events], FinalState};
|
|
lex(<<"]", Rest/binary>>, State = #init{}) ->
|
|
{Events, FinalState} = lex(Rest, State),
|
|
{[hint_close | Events], FinalState};
|
|
lex(<<D, Rest/binary>>, #init{}) when D >= ?ZERO andalso D =< ?NINE ->
|
|
lex(Rest, #strlen{value = D - ?ZERO});
|
|
lex(<<X, Rest/binary>>, State = #init{}) when X =< 32 ->
|
|
lex(Rest, State);
|
|
lex(<<D, Rest/binary>>, #strlen{value = V}) when D >= ?ZERO andalso D =< ?NINE ->
|
|
lex(Rest, #strlen{value = V * 10 + D - ?ZERO});
|
|
lex(<<":", Rest/binary>>, #strlen{value = V}) ->
|
|
lex(Rest, #str{remaining = V, pieces_rev = []});
|
|
lex(Chunk, #str{remaining = Len, pieces_rev = PiecesRev}) ->
|
|
case Chunk of
|
|
<<Piece:Len/binary, Rest/binary>> ->
|
|
{Events, FinalState} = lex(Rest, #init{}),
|
|
{[{str, iolist_to_binary(lists:reverse([Piece | PiecesRev]))} | Events], FinalState};
|
|
_ ->
|
|
{[], #str{remaining = Len - size(Chunk), pieces_rev = [Chunk | PiecesRev]}}
|
|
end;
|
|
lex(<<>>, State) ->
|
|
{[], State}.
|
|
|
|
parse_state() ->
|
|
#parser{lexer = lex_state(), stack = []}.
|
|
|
|
parse(Chunk) ->
|
|
Inert = parse_state(),
|
|
case parse(Chunk, Inert) of
|
|
{Terms, Inert} -> {ok, Terms, Inert};
|
|
{Terms, Other} -> {more, Terms, Other}
|
|
end.
|
|
|
|
parse(Chunk, #parser{lexer = Lexer, stack = Stack}) ->
|
|
{Events, NewLexer} = lex(Chunk, Lexer),
|
|
{Terms, NewStack} = parse_events(Events, Stack),
|
|
{Terms, #parser{lexer = NewLexer, stack = NewStack}}.
|
|
|
|
parse_events([open | Rest], Stack) ->
|
|
parse_events(Rest, [[] | Stack]);
|
|
parse_events([close | Rest], [AccRev]) when is_list(AccRev) ->
|
|
{Terms, NewStack} = parse_events(Rest, []),
|
|
{[lists:reverse(AccRev) | Terms], NewStack};
|
|
parse_events([close | Rest], [AccRev, AccRevOuter | Stack]) when is_list(AccRev) ->
|
|
parse_events(Rest, [[lists:reverse(AccRev) | AccRevOuter] | Stack]);
|
|
parse_events([hint_open | Rest], Stack) ->
|
|
parse_events(Rest, [hint | Stack]);
|
|
parse_events([{str, Bin} | Rest], [hint | Stack]) ->
|
|
parse_events(Rest, [{hint, Bin} | Stack]);
|
|
parse_events([hint_close | Rest], Stack = [{hint, _} | _]) ->
|
|
parse_events(Rest, Stack);
|
|
parse_events([{str, BodyBin} | Rest], [{hint, HintBin} | Stack]) ->
|
|
{Terms, NewStack} = parse_events(Rest, Stack),
|
|
{[{HintBin, BodyBin} | Terms], NewStack};
|
|
parse_events([{str, Bin} | Rest], Stack = []) ->
|
|
{Terms, NewStack} = parse_events(Rest, Stack),
|
|
{[Bin | Terms], NewStack};
|
|
parse_events([{str, Bin} | Rest], [AccRev | Stack]) when is_list(AccRev) ->
|
|
parse_events(Rest, [[Bin | AccRev] | Stack]);
|
|
parse_events([], Stack) ->
|
|
{[], Stack}.
|
|
|
|
format(Sexp) ->
|
|
iolist_to_binary(format_iolist(Sexp)).
|
|
|
|
format_bin(Bin) -> [integer_to_list(size(Bin)), $:, Bin].
|
|
|
|
format_iolist(Bin) when is_binary(Bin) ->
|
|
format_bin(Bin);
|
|
format_iolist({H, B}) when is_binary(H) andalso is_binary(B) ->
|
|
[$[, format_bin(H), $], format_bin(B)];
|
|
format_iolist(Sexps) when is_list(Sexps) ->
|
|
[$(, [format_iolist(Sexp) || Sexp <- Sexps], $)].
|