% @doc
% working out infix parsing bullshit on toy arith language
%
% our operators for now are
%
% [+, *, ^] in outer->inner order
-module(ifarith).

-export([main/0]).

test_str() ->
    "1 + 2 + 3"

main() ->
    % first going to tokenize
    Tokens = tokens(test_str()).

-record(tk,
        {type = none :: int | op | noise,
         str  = none :: none | string(),
         val  = none :: none | integer() | atom()}).

tokens(Stk, []) ->
    lists:reverse(Stk).
% [+*^] op token
tokens(Stk, [Char | Rest]) ->
    case Char of
        Op when $+ =:= Op; $* =:= Op; $^ =:= Op ->
            Tk = #tk{type = op, str = [Op], val = list_to_tuple([Op])},
            tokens([Tk | Stk], Rest);
        D when $0 =< D, D =< $9 ->
            {Tk, NewSrcStr} = tk_int([D], [D], Rest),
            tokens([Tk | Stk], NewSrcStr).
        _ ->
            tokens(Stk, Rest)
    end.


% tokens for now are
-spec tk_int(DigitStack, CharStack, SrcStr) -> Result when
        DigitStack  :: string(),
        CharStack   :: string(),
        SrcStr      :: string(),
        Result      :: {Token, NewSrcStr},
        Token       :: #tk{},
        NewSrcStr   :: string().

tk_int(DigitStack, CharStack, SrcStr) ->
    case SrcStr of
        % cases when still consuming the int
        % [0-9]
        [D | NewSrcStr] when $0 =< D, D =< $9 ->
            tk_int([D | DigitStack], [D | CharStack], NewSrcStr);
        [$_ | NewSrcStr] ->
            tk_int(DigitStack, [D | CharStack], NewSrcStr);
        % otherwise done
        _ ->
            Digits = 
    end.