Osmocom Open Build Service

commit_d196f0ac88b0fa12bd7ff15d2a2528c85f1a9682.txt Deleted

commit_d6034d229e32153c9387e4ea311298daa21c9b0f.txt Added

osmo-s1gw_0.3.0.154.d196.dsc -> osmo-s1gw_0.3.0.157.d603.dsc Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/.tarball-version -> osmo-s1gw_0.3.0.157.d603.tar.xz/.tarball-version Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/CHANGELOG.md -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/CHANGELOG.md Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/README.md -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/README.md Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/ebin/hex_core.app -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/ebin/hex_core.app Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/hex_metadata.config -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/hex_metadata.config Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/src/hex_api_release.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/src/hex_api_release.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/src/hex_core.app.src -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/src/hex_core.app.src Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/src/hex_core.hrl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/src/hex_core.hrl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/src/hex_tarball.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/src/hex_tarball.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/hex_core/src/safe_erl_term.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/hex_core/src/safe_erl_term.erl Changed

@@ -1,4 +1,4 @@
--file("/home/todd/.asdf/installs/erlang/26.2.1/lib/parsetools-2.5/include/leexinc.hrl", 0).
+-file("/usr/lib/erlang/lib/parsetools-2.4.1/include/leexinc.hrl", 0).
 %% The source of this file is part of leex distribution, as such it
 %% has the same Copyright as the other files in the leex
 %% distribution. The Copyright is defined in the accompanying file
@@ -12,7 +12,7 @@
 -export(format_error/1).
 
 %% User code. This is placed here to allow extra attributes.
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 24).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 24).
 
 -export(terms/1).
 
@@ -67,308 +67,266 @@
 escape_char($d) -> $\d;       %\d = DEL
 escape_char(C) -> C.
 
--file("/home/todd/.asdf/installs/erlang/26.2.1/lib/parsetools-2.5/include/leexinc.hrl", 14).
+-file("/usr/lib/erlang/lib/parsetools-2.4.1/include/leexinc.hrl", 14).
 
 format_error({illegal,S}) -> "illegal characters ",io_lib:write_string(S);
 format_error({user,S}) -> S.
 
-%% string(InChars) ->
-%% string(InChars, Loc) ->
-%% {ok,Tokens,EndLoc} | {error,ErrorInfo,EndLoc}.
-%% Loc is the starting location of the token, while EndLoc is the first not scanned
-%% location. Location is either Line or {Line,Column}, depending on the "error_location" option.
-
-string(Ics) -> 
-    string(Ics,1).
-string(Ics,L0) -> 
-    string(Ics, L0, 1, Ics, ).
-string(Ics, L0, C0, Tcs, Ts) -> 
-    case do_string(Ics, L0, C0, Tcs, Ts) of
-        {ok, T, {L,_}} -> {ok, T, L};
-        {error, {{EL,_},M,D}, {L,_}} ->
-            EI = {EL,M,D},
-            {error, EI, L}
-    end.
+string(String) -> string(String, 1).
+
+string(String, Line) -> string(String, Line, String, ).
 
-do_string(, L, C, , Ts) ->                     % No partial tokens!
-    {ok,yyrev(Ts),{L,C}};
-do_string(Ics0, L0, C0, Tcs, Ts) ->
-    case yystate(yystate(), Ics0, L0, C0, 0, reject, 0) of
-        {A,Alen,Ics1,L1,_C1} ->                  % Accepting end state
-            C2 = adjust_col(Tcs, Alen, C0),
-            string_cont(Ics1, L1, C2, yyaction(A, Alen, Tcs, L0, C0), Ts);
-        {A,Alen,Ics1,L1,_C1,_S1} ->              % Accepting transition state
-            C2 = adjust_col(Tcs, Alen, C0),
-            string_cont(Ics1, L1, C2, yyaction(A, Alen, Tcs, L0, C0), Ts);
-        {reject,_Alen,Tlen,_Ics1,_L1,_C1,_S1} ->  % After a non-accepting state
-            {error,{{L0, C0} ,?MODULE,{illegal,yypre(Tcs, Tlen+1)}},{L0, C0}};
-        {A,Alen,Tlen,_Ics1,L1, C1,_S1}->
+%% string(InChars, Line, TokenChars, Tokens) ->
+%% {ok,Tokens,Line} | {error,ErrorInfo,Line}.
+%% Note the line number going into yystate, L0, is line of token
+%% start while line number returned is line of token end. We want line
+%% of token start.
+
+string(, L, , Ts) ->                     % No partial tokens!
+    {ok,yyrev(Ts),L};
+string(Ics0, L0, Tcs, Ts) ->
+    case yystate(yystate(), Ics0, L0, 0, reject, 0) of
+        {A,Alen,Ics1,L1} ->                  % Accepting end state
+            string_cont(Ics1, L1, yyaction(A, Alen, Tcs, L0), Ts);
+        {A,Alen,Ics1,L1,_S1} ->              % Accepting transition state
+            string_cont(Ics1, L1, yyaction(A, Alen, Tcs, L0), Ts);
+        {reject,_Alen,Tlen,_Ics1,L1,_S1} ->  % After a non-accepting state
+            {error,{L0,?MODULE,{illegal,yypre(Tcs, Tlen+1)}},L1};
+        {A,Alen,Tlen,_Ics1,L1,_S1} ->
             Tcs1 = yysuf(Tcs, Alen),
             L2 = adjust_line(Tlen, Alen, Tcs1, L1),
-            C2 = adjust_col(Tcs, Alen, C1),
-            string_cont(Tcs1, L2, C2, yyaction(A, Alen, Tcs, L0,C0), Ts)
+            string_cont(Tcs1, L2, yyaction(A, Alen, Tcs, L0), Ts)
     end.
 
-%% string_cont(RestChars, Line, Col, Token, Tokens)
+%% string_cont(RestChars, Line, Token, Tokens)
 %% Test for and remove the end token wrapper. Push back characters
 %% are prepended to RestChars.
 
--dialyzer({nowarn_function, string_cont/5}).
+-dialyzer({nowarn_function, string_cont/4}).
 
-string_cont(Rest, Line, Col, {token,T}, Ts) ->
-    do_string(Rest, Line, Col, Rest, T|Ts);
-string_cont(Rest, Line, Col, {token,T,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    do_string(NewRest, Line, Col, NewRest, T|Ts);
-string_cont(Rest, Line, Col, {end_token,T}, Ts) ->
-    do_string(Rest, Line, Col, Rest, T|Ts);
-string_cont(Rest, Line, Col, {end_token,T,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    do_string(NewRest, Line, Col, NewRest, T|Ts);
-string_cont(Rest, Line, Col, skip_token, Ts) ->
-    do_string(Rest, Line, Col, Rest, Ts);
-string_cont(Rest, Line, Col, {skip_token,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    do_string(NewRest, Line, Col, NewRest, Ts);
-string_cont(_Rest, Line, Col, {error,S}, _Ts) ->
-    {error,{{Line, Col},?MODULE,{user,S}},{Line,Col}}.
+string_cont(Rest, Line, {token,T}, Ts) ->
+    string(Rest, Line, Rest, T|Ts);
+string_cont(Rest, Line, {token,T,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    string(NewRest, Line, NewRest, T|Ts);
+string_cont(Rest, Line, {end_token,T}, Ts) ->
+    string(Rest, Line, Rest, T|Ts);
+string_cont(Rest, Line, {end_token,T,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    string(NewRest, Line, NewRest, T|Ts);
+string_cont(Rest, Line, skip_token, Ts) ->
+    string(Rest, Line, Rest, Ts);
+string_cont(Rest, Line, {skip_token,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    string(NewRest, Line, NewRest, Ts);
+string_cont(_Rest, Line, {error,S}, _Ts) ->
+    {error,{Line,?MODULE,{user,S}},Line}.
 
 %% token(Continuation, Chars) ->
-%% token(Continuation, Chars, Loc) ->
+%% token(Continuation, Chars, Line) ->
 %% {more,Continuation} | {done,ReturnVal,RestChars}.
 %% Must be careful when re-entering to append the latest characters to the
 %% after characters in an accept. The continuation is:
-%% {token,State,CurrLine,CurrCol,TokenChars,TokenLen,TokenLine,TokenCol,AccAction,AccLen}
+%% {token,State,CurrLine,TokenChars,TokenLen,TokenLine,AccAction,AccLen}
 
-token(Cont,Chars) -> 
-    token(Cont,Chars,1).
-token(Cont, Chars, Line) -> 
-    case do_token(Cont,Chars,Line,1) of
-        {more, _} = C -> C;
-        {done, Ret0, R} ->
-            Ret1 = case Ret0 of
-                {ok, T, {L,_}} -> {ok, T, L};
-                {eof, {L,_}} -> {eof, L};
-                {error, {{EL,_},M,D},{L,_}} -> {error, {EL,M,D},L}
-            end,
-            {done, Ret1, R}
-    end.
+token(Cont, Chars) -> token(Cont, Chars, 1).
 
-do_token(, Chars, Line, Col) ->
-    token(yystate(), Chars, Line, Col, Chars, 0, Line, Col, reject, 0);
-do_token({token,State,Line,Col,Tcs,Tlen,Tline,Tcol,Action,Alen}, Chars, _, _) ->
-    token(State, Chars, Line, Col, Tcs ++ Chars, Tlen, Tline, Tcol, Action, Alen).
+token(, Chars, Line) ->
+    token(yystate(), Chars, Line, Chars, 0, Line, reject, 0);
+token({token,State,Line,Tcs,Tlen,Tline,Action,Alen}, Chars, _) ->
+    token(State, Chars, Line, Tcs ++ Chars, Tlen, Tline, Action, Alen).
 
-%% token(State, InChars, Line, Col, TokenChars, TokenLen, TokenLine, TokenCol
+%% token(State, InChars, Line, TokenChars, TokenLen, TokenLine,
 %% AcceptAction, AcceptLen) ->
 %% {more,Continuation} | {done,ReturnVal,RestChars}.
 %% The argument order is chosen to be more efficient.
 
-token(S0, Ics0, L0, C0, Tcs, Tlen0, Tline, Tcol, A0, Alen0) ->
-    case yystate(S0, Ics0, L0, C0, Tlen0, A0, Alen0) of
+token(S0, Ics0, L0, Tcs, Tlen0, Tline, A0, Alen0) ->
+    case yystate(S0, Ics0, L0, Tlen0, A0, Alen0) of
         %% Accepting end state, we have a token.
-        {A1,Alen1,Ics1,L1,C1} ->
-            C2 = adjust_col(Tcs, Alen1, C1),
-            token_cont(Ics1, L1, C2, yyaction(A1, Alen1, Tcs, Tline,Tcol));
+        {A1,Alen1,Ics1,L1} ->
+            token_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline));
         %% Accepting transition state, can take more chars.
-        {A1,Alen1,,L1,C1,S1} ->                  % Need more chars to check
-            {more,{token,S1,L1,C1,Tcs,Alen1,Tline,Tcol,A1,Alen1}};
-        {A1,Alen1,Ics1,L1,C1,_S1} ->               % Take what we got
-            C2 = adjust_col(Tcs, Alen1, C1),
-            token_cont(Ics1, L1, C2, yyaction(A1, Alen1, Tcs, Tline,Tcol));
+        {A1,Alen1,,L1,S1} ->                  % Need more chars to check
+            {more,{token,S1,L1,Tcs,Alen1,Tline,A1,Alen1}};
+        {A1,Alen1,Ics1,L1,_S1} ->               % Take what we got
+            token_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline));
         %% After a non-accepting state, maybe reach accept state later.
-        {A1,Alen1,Tlen1,,L1,C1,S1} ->            % Need more chars to check
-            {more,{token,S1,L1,C1,Tcs,Tlen1,Tline,Tcol,A1,Alen1}};
-        {reject,_Alen1,Tlen1,eof,L1,C1,_S1} ->     % No token match
+        {A1,Alen1,Tlen1,,L1,S1} ->            % Need more chars to check
+            {more,{token,S1,L1,Tcs,Tlen1,Tline,A1,Alen1}};
+        {reject,_Alen1,Tlen1,eof,L1,_S1} ->     % No token match
             %% Check for partial token which is error.
-            Ret = if Tlen1 > 0 -> {error,{{Tline,Tcol},?MODULE,
+            Ret = if Tlen1 > 0 -> {error,{Tline,?MODULE,
                                           %% Skip eof tail in Tcs.
-                                          {illegal,yypre(Tcs, Tlen1)}},{L1,C1}};
-                     true -> {eof,{L1,C1}}
+                                          {illegal,yypre(Tcs, Tlen1)}},L1};
+                     true -> {eof,L1}
                   end,
             {done,Ret,eof};
-        {reject,_Alen1,Tlen1,Ics1,_L1,_C1,_S1} ->    % No token match
-            Error = {{Tline,Tcol},?MODULE,{illegal,yypre(Tcs, Tlen1+1)}},
-            {done,{error,Error,{Tline,Tcol}},Ics1};
-        {A1,Alen1,Tlen1,_Ics1,L1,_C1,_S1} ->       % Use last accept match
+        {reject,_Alen1,Tlen1,Ics1,L1,_S1} ->    % No token match
+            Error = {Tline,?MODULE,{illegal,yypre(Tcs, Tlen1+1)}},
+            {done,{error,Error,L1},Ics1};
+        {A1,Alen1,Tlen1,_Ics1,L1,_S1} ->       % Use last accept match
             Tcs1 = yysuf(Tcs, Alen1),
             L2 = adjust_line(Tlen1, Alen1, Tcs1, L1),
-            C2 = C0 + Alen1,
-            token_cont(Tcs1, L2, C2, yyaction(A1, Alen1, Tcs, Tline, Tcol))
+            token_cont(Tcs1, L2, yyaction(A1, Alen1, Tcs, Tline))
     end.
 
-%% token_cont(RestChars, Line, Col, Token)
+%% token_cont(RestChars, Line, Token)
 %% If we have a token or error then return done, else if we have a
 %% skip_token then continue.
 
--dialyzer({nowarn_function, token_cont/4}).
+-dialyzer({nowarn_function, token_cont/3}).
 
-token_cont(Rest, Line, Col, {token,T}) ->
-    {done,{ok,T,{Line,Col}},Rest};
-token_cont(Rest, Line, Col, {token,T,Push}) ->
-    NewRest = Push ++ Rest,
-    {done,{ok,T,{Line,Col}},NewRest};
-token_cont(Rest, Line, Col, {end_token,T}) ->
-    {done,{ok,T,{Line,Col}},Rest};
-token_cont(Rest, Line, Col, {end_token,T,Push}) ->
-    NewRest = Push ++ Rest,
-    {done,{ok,T,{Line,Col}},NewRest};
-token_cont(Rest, Line, Col, skip_token) ->
-    token(yystate(), Rest, Line, Col, Rest, 0, Line, Col, reject, 0);
-token_cont(Rest, Line, Col, {skip_token,Push}) ->
-    NewRest = Push ++ Rest,
-    token(yystate(), NewRest, Line, Col, NewRest, 0, Line, Col, reject, 0);
-token_cont(Rest, Line, Col, {error,S}) ->
-    {done,{error,{{Line, Col},?MODULE,{user,S}},{Line, Col}},Rest}.
+token_cont(Rest, Line, {token,T}) ->
+    {done,{ok,T,Line},Rest};
+token_cont(Rest, Line, {token,T,Push}) ->
+    NewRest = Push ++ Rest,
+    {done,{ok,T,Line},NewRest};
+token_cont(Rest, Line, {end_token,T}) ->
+    {done,{ok,T,Line},Rest};
+token_cont(Rest, Line, {end_token,T,Push}) ->
+    NewRest = Push ++ Rest,
+    {done,{ok,T,Line},NewRest};
+token_cont(Rest, Line, skip_token) ->
+    token(yystate(), Rest, Line, Rest, 0, Line, reject, 0);
+token_cont(Rest, Line, {skip_token,Push}) ->
+    NewRest = Push ++ Rest,
+    token(yystate(), NewRest, Line, NewRest, 0, Line, reject, 0);
+token_cont(Rest, Line, {error,S}) ->
+    {done,{error,{Line,?MODULE,{user,S}},Line},Rest}.
 
-%% tokens(Continuation, Chars) ->
-%% tokens(Continuation, Chars, Loc) ->
+%% tokens(Continuation, Chars, Line) ->
 %% {more,Continuation} | {done,ReturnVal,RestChars}.
 %% Must be careful when re-entering to append the latest characters to the
 %% after characters in an accept. The continuation is:
-%% {tokens,State,CurrLine,CurrCol,TokenChars,TokenLen,TokenLine,TokenCur,Tokens,AccAction,AccLen}
-%% {skip_tokens,State,CurrLine,CurrCol,TokenChars,TokenLen,TokenLine,TokenCur,Error,AccAction,AccLen}
+%% {tokens,State,CurrLine,TokenChars,TokenLen,TokenLine,Tokens,AccAction,AccLen}
+%% {skip_tokens,State,CurrLine,TokenChars,TokenLen,TokenLine,Error,AccAction,AccLen}
 
-tokens(Cont,Chars) -> 
-    tokens(Cont,Chars,1).
-tokens(Cont, Chars, Line) -> 
-    case do_tokens(Cont,Chars,Line,1) of
-        {more, _} = C -> C;
-        {done, Ret0, R} ->
-            Ret1 = case Ret0 of
-                {ok, T, {L,_}} -> {ok, T, L};
-                {eof, {L,_}} -> {eof, L};
-                {error, {{EL,_},M,D},{L,_}} -> {error, {EL,M,D},L}
-            end,
-            {done, Ret1, R}
-    end.
+tokens(Cont, Chars) -> tokens(Cont, Chars, 1).
 
-do_tokens(, Chars, Line, Col) ->
-    tokens(yystate(), Chars, Line, Col, Chars, 0, Line, Col, , reject, 0);
-do_tokens({tokens,State,Line,Col,Tcs,Tlen,Tline,Tcol,Ts,Action,Alen}, Chars, _,_) ->
-    tokens(State, Chars, Line, Col, Tcs ++ Chars, Tlen, Tline, Tcol, Ts, Action, Alen);
-do_tokens({skip_tokens,State,Line, Col, Tcs,Tlen,Tline,Tcol,Error,Action,Alen}, Chars, _,_) ->
-    skip_tokens(State, Chars, Line, Col, Tcs ++ Chars, Tlen, Tline, Tcol, Error, Action, Alen).
+tokens(, Chars, Line) ->
+    tokens(yystate(), Chars, Line, Chars, 0, Line, , reject, 0);
+tokens({tokens,State,Line,Tcs,Tlen,Tline,Ts,Action,Alen}, Chars, _) ->
+    tokens(State, Chars, Line, Tcs ++ Chars, Tlen, Tline, Ts, Action, Alen);
+tokens({skip_tokens,State,Line,Tcs,Tlen,Tline,Error,Action,Alen}, Chars, _) ->
+    skip_tokens(State, Chars, Line, Tcs ++ Chars, Tlen, Tline, Error, Action, Alen).
 
-%% tokens(State, InChars, Line, Col, TokenChars, TokenLen, TokenLine, TokenCol,Tokens,
+%% tokens(State, InChars, Line, TokenChars, TokenLen, TokenLine, Tokens,
 %% AcceptAction, AcceptLen) ->
 %% {more,Continuation} | {done,ReturnVal,RestChars}.
 
-tokens(S0, Ics0, L0, C0, Tcs, Tlen0, Tline, Tcol, Ts, A0, Alen0) ->
-    case yystate(S0, Ics0, L0, C0, Tlen0, A0, Alen0) of
+tokens(S0, Ics0, L0, Tcs, Tlen0, Tline, Ts, A0, Alen0) ->
+    case yystate(S0, Ics0, L0, Tlen0, A0, Alen0) of
         %% Accepting end state, we have a token.
-        {A1,Alen1,Ics1,L1,C1} ->
-            C2 = adjust_col(Tcs, Alen1, C1),
-            tokens_cont(Ics1, L1, C2, yyaction(A1, Alen1, Tcs, Tline, Tcol), Ts);
+        {A1,Alen1,Ics1,L1} ->
+            tokens_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline), Ts);
         %% Accepting transition state, can take more chars.
-        {A1,Alen1,,L1,C1,S1} ->                  % Need more chars to check
-            {more,{tokens,S1,L1,C1,Tcs,Alen1,Tline,Tcol,Ts,A1,Alen1}};
-        {A1,Alen1,Ics1,L1,C1,_S1} ->               % Take what we got
-            C2 = adjust_col(Tcs, Alen1, C1),
-            tokens_cont(Ics1, L1, C2, yyaction(A1, Alen1, Tcs, Tline,Tcol), Ts);
+        {A1,Alen1,,L1,S1} ->                  % Need more chars to check
+            {more,{tokens,S1,L1,Tcs,Alen1,Tline,Ts,A1,Alen1}};
+        {A1,Alen1,Ics1,L1,_S1} ->               % Take what we got
+            tokens_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline), Ts);
         %% After a non-accepting state, maybe reach accept state later.
-        {A1,Alen1,Tlen1,,L1,C1,S1} ->            % Need more chars to check
-            {more,{tokens,S1,L1,C1,Tcs,Tlen1,Tline,Tcol,Ts,A1,Alen1}};
-        {reject,_Alen1,Tlen1,eof,L1,C1,_S1} ->     % No token match
+        {A1,Alen1,Tlen1,,L1,S1} ->            % Need more chars to check
+            {more,{tokens,S1,L1,Tcs,Tlen1,Tline,Ts,A1,Alen1}};
+        {reject,_Alen1,Tlen1,eof,L1,_S1} ->     % No token match
             %% Check for partial token which is error, no need to skip here.
-            Ret = if Tlen1 > 0 -> {error,{{Tline,Tcol},?MODULE,
+            Ret = if Tlen1 > 0 -> {error,{Tline,?MODULE,
                                           %% Skip eof tail in Tcs.
-                                          {illegal,yypre(Tcs, Tlen1)}},{L1,C1}};
-                     Ts ==  -> {eof,{L1,C1}};
-                     true -> {ok,yyrev(Ts),{L1,C1}}
+                                          {illegal,yypre(Tcs, Tlen1)}},L1};
+                     Ts ==  -> {eof,L1};
+                     true -> {ok,yyrev(Ts),L1}
                   end,
             {done,Ret,eof};
-        {reject,_Alen1,Tlen1,_Ics1,L1,C1,_S1} ->
+        {reject,_Alen1,Tlen1,_Ics1,L1,_S1} ->
             %% Skip rest of tokens.
-            Error = {{L1,C1},?MODULE,{illegal,yypre(Tcs, Tlen1+1)}},
-            skip_tokens(yysuf(Tcs, Tlen1+1), L1, C1, Error);
-        {A1,Alen1,Tlen1,_Ics1,L1,_C1,_S1} ->
-            Token = yyaction(A1, Alen1, Tcs, Tline,Tcol),
+            Error = {L1,?MODULE,{illegal,yypre(Tcs, Tlen1+1)}},
+            skip_tokens(yysuf(Tcs, Tlen1+1), L1, Error);
+        {A1,Alen1,Tlen1,_Ics1,L1,_S1} ->
+            Token = yyaction(A1, Alen1, Tcs, Tline),
             Tcs1 = yysuf(Tcs, Alen1),
             L2 = adjust_line(Tlen1, Alen1, Tcs1, L1),
-            C2 = C0 + Alen1,
-            tokens_cont(Tcs1, L2, C2, Token, Ts)
+            tokens_cont(Tcs1, L2, Token, Ts)
     end.
 
-%% tokens_cont(RestChars, Line, Column, Token, Tokens)
+%% tokens_cont(RestChars, Line, Token, Tokens)
 %% If we have an end_token or error then return done, else if we have
 %% a token then save it and continue, else if we have a skip_token
 %% just continue.
 
--dialyzer({nowarn_function, tokens_cont/5}).
+-dialyzer({nowarn_function, tokens_cont/4}).
 
-tokens_cont(Rest, Line, Col, {token,T}, Ts) ->
-    tokens(yystate(), Rest, Line, Col, Rest, 0, Line, Col, T|Ts, reject, 0);
-tokens_cont(Rest, Line, Col, {token,T,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    tokens(yystate(), NewRest, Line, Col, NewRest, 0, Line, Col, T|Ts, reject, 0);
-tokens_cont(Rest, Line, Col, {end_token,T}, Ts) ->
-    {done,{ok,yyrev(Ts, T),{Line,Col}},Rest};
-tokens_cont(Rest, Line, Col, {end_token,T,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    {done,{ok,yyrev(Ts, T),{Line, Col}},NewRest};
-tokens_cont(Rest, Line, Col, skip_token, Ts) ->
-    tokens(yystate(), Rest, Line, Col, Rest, 0, Line, Col, Ts, reject, 0);
-tokens_cont(Rest, Line, Col, {skip_token,Push}, Ts) ->
-    NewRest = Push ++ Rest,
-    tokens(yystate(), NewRest, Line, Col, NewRest, 0, Line, Col, Ts, reject, 0);
-tokens_cont(Rest, Line, Col, {error,S}, _Ts) ->
-    skip_tokens(Rest, Line, Col, {{Line,Col},?MODULE,{user,S}}).
+tokens_cont(Rest, Line, {token,T}, Ts) ->
+    tokens(yystate(), Rest, Line, Rest, 0, Line, T|Ts, reject, 0);
+tokens_cont(Rest, Line, {token,T,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    tokens(yystate(), NewRest, Line, NewRest, 0, Line, T|Ts, reject, 0);
+tokens_cont(Rest, Line, {end_token,T}, Ts) ->
+    {done,{ok,yyrev(Ts, T),Line},Rest};
+tokens_cont(Rest, Line, {end_token,T,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    {done,{ok,yyrev(Ts, T),Line},NewRest};
+tokens_cont(Rest, Line, skip_token, Ts) ->
+    tokens(yystate(), Rest, Line, Rest, 0, Line, Ts, reject, 0);
+tokens_cont(Rest, Line, {skip_token,Push}, Ts) ->
+    NewRest = Push ++ Rest,
+    tokens(yystate(), NewRest, Line, NewRest, 0, Line, Ts, reject, 0);
+tokens_cont(Rest, Line, {error,S}, _Ts) ->
+    skip_tokens(Rest, Line, {Line,?MODULE,{user,S}}).
 
-%% skip_tokens(InChars, Line, Col, Error) -> {done,{error,Error,{Line,Col}},Ics}.
+%%skip_tokens(InChars, Line, Error) -> {done,{error,Error,Line},Ics}.
 %% Skip tokens until an end token, junk everything and return the error.
 
-skip_tokens(Ics, Line, Col, Error) ->
-    skip_tokens(yystate(), Ics, Line, Col, Ics, 0, Line, Col, Error, reject, 0).
+skip_tokens(Ics, Line, Error) ->
+    skip_tokens(yystate(), Ics, Line, Ics, 0, Line, Error, reject, 0).
 
-%% skip_tokens(State, InChars, Line, Col, TokenChars, TokenLen, TokenLine, TokenCol, Tokens,
+%% skip_tokens(State, InChars, Line, TokenChars, TokenLen, TokenLine, Tokens,
 %% AcceptAction, AcceptLen) ->
 %% {more,Continuation} | {done,ReturnVal,RestChars}.
 
-skip_tokens(S0, Ics0, L0, C0, Tcs, Tlen0, Tline, Tcol, Error, A0, Alen0) ->
-    case yystate(S0, Ics0, L0, C0, Tlen0, A0, Alen0) of
-        {A1,Alen1,Ics1,L1, C1} ->                  % Accepting end state
-            skip_cont(Ics1, L1, C1, yyaction(A1, Alen1, Tcs, Tline, Tcol), Error);
-        {A1,Alen1,,L1,C1, S1} ->                 % After an accepting state
-            {more,{skip_tokens,S1,L1,C1,Tcs,Alen1,Tline,Tcol,Error,A1,Alen1}};
-        {A1,Alen1,Ics1,L1,C1,_S1} ->
-            skip_cont(Ics1, L1, C1, yyaction(A1, Alen1, Tcs, Tline, Tcol), Error);
-        {A1,Alen1,Tlen1,,L1,C1,S1} ->           % After a non-accepting state
-            {more,{skip_tokens,S1,L1,C1,Tcs,Tlen1,Tline,Tcol,Error,A1,Alen1}};
-        {reject,_Alen1,_Tlen1,eof,L1,C1,_S1} ->
-            {done,{error,Error,{L1,C1}},eof};
-        {reject,_Alen1,Tlen1,_Ics1,L1,C1,_S1} ->
-            skip_tokens(yysuf(Tcs, Tlen1+1), L1, C1,Error);
-        {A1,Alen1,Tlen1,_Ics1,L1,C1,_S1} ->
-            Token = yyaction(A1, Alen1, Tcs, Tline, Tcol),
+skip_tokens(S0, Ics0, L0, Tcs, Tlen0, Tline, Error, A0, Alen0) ->
+    case yystate(S0, Ics0, L0, Tlen0, A0, Alen0) of
+        {A1,Alen1,Ics1,L1} ->                  % Accepting end state
+            skip_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline), Error);
+        {A1,Alen1,,L1,S1} ->                 % After an accepting state
+            {more,{skip_tokens,S1,L1,Tcs,Alen1,Tline,Error,A1,Alen1}};
+        {A1,Alen1,Ics1,L1,_S1} ->
+            skip_cont(Ics1, L1, yyaction(A1, Alen1, Tcs, Tline), Error);
+        {A1,Alen1,Tlen1,,L1,S1} ->           % After a non-accepting state
+            {more,{skip_tokens,S1,L1,Tcs,Tlen1,Tline,Error,A1,Alen1}};
+        {reject,_Alen1,_Tlen1,eof,L1,_S1} ->
+            {done,{error,Error,L1},eof};
+        {reject,_Alen1,Tlen1,_Ics1,L1,_S1} ->
+            skip_tokens(yysuf(Tcs, Tlen1+1), L1, Error);
+        {A1,Alen1,Tlen1,_Ics1,L1,_S1} ->
+            Token = yyaction(A1, Alen1, Tcs, Tline),
             Tcs1 = yysuf(Tcs, Alen1),
             L2 = adjust_line(Tlen1, Alen1, Tcs1, L1),
-            skip_cont(Tcs1, L2, C1, Token, Error)
+            skip_cont(Tcs1, L2, Token, Error)
     end.
 
-%% skip_cont(RestChars, Line, Col, Token, Error)
+%% skip_cont(RestChars, Line, Token, Error)
 %% Skip tokens until we have an end_token or error then return done
 %% with the original rror.
 
--dialyzer({nowarn_function, skip_cont/5}).
+-dialyzer({nowarn_function, skip_cont/4}).
 
-skip_cont(Rest, Line, Col, {token,_T}, Error) ->
-    skip_tokens(yystate(), Rest, Line, Col, Rest, 0, Line, Col, Error, reject, 0);
-skip_cont(Rest, Line, Col, {token,_T,Push}, Error) ->
-    NewRest = Push ++ Rest,
-    skip_tokens(yystate(), NewRest, Line, Col, NewRest, 0, Line, Col, Error, reject, 0);
-skip_cont(Rest, Line, Col, {end_token,_T}, Error) ->
-    {done,{error,Error,{Line,Col}},Rest};
-skip_cont(Rest, Line, Col, {end_token,_T,Push}, Error) ->
-    NewRest = Push ++ Rest,
-    {done,{error,Error,{Line,Col}},NewRest};
-skip_cont(Rest, Line, Col, skip_token, Error) ->
-    skip_tokens(yystate(), Rest, Line, Col, Rest, 0, Line, Col, Error, reject, 0);
-skip_cont(Rest, Line, Col, {skip_token,Push}, Error) ->
-    NewRest = Push ++ Rest,
-    skip_tokens(yystate(), NewRest, Line, Col, NewRest, 0, Line, Col, Error, reject, 0);
-skip_cont(Rest, Line, Col, {error,_S}, Error) ->
-    skip_tokens(yystate(), Rest, Line, Col, Rest, 0, Line, Col, Error, reject, 0).
+skip_cont(Rest, Line, {token,_T}, Error) ->
+    skip_tokens(yystate(), Rest, Line, Rest, 0, Line, Error, reject, 0);
+skip_cont(Rest, Line, {token,_T,Push}, Error) ->
+    NewRest = Push ++ Rest,
+    skip_tokens(yystate(), NewRest, Line, NewRest, 0, Line, Error, reject, 0);
+skip_cont(Rest, Line, {end_token,_T}, Error) ->
+    {done,{error,Error,Line},Rest};
+skip_cont(Rest, Line, {end_token,_T,Push}, Error) ->
+    NewRest = Push ++ Rest,
+    {done,{error,Error,Line},NewRest};
+skip_cont(Rest, Line, skip_token, Error) ->
+    skip_tokens(yystate(), Rest, Line, Rest, 0, Line, Error, reject, 0);
+skip_cont(Rest, Line, {skip_token,Push}, Error) ->
+    NewRest = Push ++ Rest,
+    skip_tokens(yystate(), NewRest, Line, NewRest, 0, Line, Error, reject, 0);
+skip_cont(Rest, Line, {error,_S}, Error) ->
+    skip_tokens(yystate(), Rest, Line, Rest, 0, Line, Error, reject, 0).
 
 -compile({nowarn_unused_function, yyrev/1, yyrev/2, yypre/2, yysuf/2}).
 
@@ -390,336 +348,313 @@
 adjust_line(T, A, _|Cs, L) ->
     adjust_line(T-1, A, Cs, L).
 
-%% adjust_col(Chars, AcceptLength, Col) -> NewCol
-%% Handle newlines, tabs and unicode chars.
-adjust_col(_, 0, Col) ->
-    Col;
-adjust_col($\n | R, L, _) ->
-    adjust_col(R, L-1, 1);
-adjust_col($\t | R, L, Col) ->
-    adjust_col(R, L-1, tab_forward(Col)+1);
-adjust_col(C | R, L, Col) when C>=0 andalso C=< 16#7F ->
-    adjust_col(R, L-1, Col+1);
-adjust_col(C | R, L, Col) when C>= 16#80 andalso C=< 16#7FF ->
-    adjust_col(R, L-1, Col+2);
-adjust_col(C | R, L, Col) when C>= 16#800 andalso C=< 16#FFFF ->
-    adjust_col(R, L-1, Col+3);
-adjust_col(C | R, L, Col) when C>= 16#10000 andalso C=< 16#10FFFF ->
-    adjust_col(R, L-1, Col+4).
-
-tab_forward(C) ->
-    D = C rem tab_size(),
-    A = tab_size()-D,
-    C+A.
-
-tab_size() -> 8.
-
 %% yystate() -> InitialState.
-%% yystate(State, InChars, Line, Col, CurrTokLen, AcceptAction, AcceptLen) ->
-%% {Action, AcceptLen, RestChars, Line, Col} |
-%% {Action, AcceptLen, RestChars, Line, Col, State} |
-%% {reject, AcceptLen, CurrTokLen, RestChars, Line, Col, State} |
-%% {Action, AcceptLen, CurrTokLen, RestChars, Line, Col, State}.
+%% yystate(State, InChars, Line, CurrTokLen, AcceptAction, AcceptLen) ->
+%% {Action, AcceptLen, RestChars, Line} |
+%% {Action, AcceptLen, RestChars, Line, State} |
+%% {reject, AcceptLen, CurrTokLen, RestChars, Line, State} |
+%% {Action, AcceptLen, CurrTokLen, RestChars, Line, State}.
 %% Generated state transition functions. The non-accepting end state
 %% return signal either an unrecognised character or end of current
 %% input.
 
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.erl", 392).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.erl", 360).
 yystate() -> 12.
 
-yystate(19, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(15, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, 34|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(7, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(8, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(19, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 33 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 35, C =< 91 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 93 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(19, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,19};
-yystate(18, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(14, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, 39|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(10, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(5, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(18, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 38 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 40, C =< 91 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 93 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(18, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,18};
-yystate(17, 60|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(11, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(17, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,17};
-yystate(16, 10|Ics, Line, _, Tlen, _, _) ->
-    yystate(16, Ics, Line+1, 1, Tlen+1, 8, Tlen);
-yystate(16, C|Ics, Line, Col, Tlen, _, _) when C >= 0, C =< 9 ->
-    yystate(16, Ics, Line, Col, Tlen+1, 8, Tlen);
-yystate(16, C|Ics, Line, Col, Tlen, _, _) when C >= 11, C =< 32 ->
-    yystate(16, Ics, Line, Col, Tlen+1, 8, Tlen);
-yystate(16, Ics, Line, Col, Tlen, _, _) ->
-    {8,Tlen,Ics,Line,Col,16};
-yystate(15, 94|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(19, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, 93|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(15, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, 34|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(7, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(8, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(15, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 33 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 35, C =< 91 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 95 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(15, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,15};
-yystate(14, 94|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(18, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, 93|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(14, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, 39|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(10, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(5, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(14, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 38 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 40, C =< 91 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 95 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(14, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,14};
-yystate(13, Ics, Line, Col, Tlen, _, _) ->
-    {4,Tlen,Ics,Line,Col};
-yystate(12, 125|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 123|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 93|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 91|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 62|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(3, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 61|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(3, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 60|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(17, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 47|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(1, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 46|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(6, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 39|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 35|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 34|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(16, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(12, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(16, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 32 ->
-    yystate(16, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 43, C =< 45 ->
-    yystate(13, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 48, C =< 57 ->
-    yystate(9, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 97, C =< 122 ->
-    yystate(4, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(12, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,12};
-yystate(11, Ics, Line, Col, Tlen, _, _) ->
-    {5,Tlen,Ics,Line,Col};
-yystate(10, 92|Ics, Line, Col, Tlen, _, _) ->
-    yystate(14, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, 39|Ics, Line, Col, Tlen, _, _) ->
-    yystate(2, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, 10|Ics, Line, _, Tlen, _, _) ->
-    yystate(5, Ics, Line+1, 1, Tlen+1, 1, Tlen);
-yystate(10, C|Ics, Line, Col, Tlen, _, _) when C >= 0, C =< 9 ->
-    yystate(5, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, C|Ics, Line, Col, Tlen, _, _) when C >= 11, C =< 38 ->
-    yystate(5, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, C|Ics, Line, Col, Tlen, _, _) when C >= 40, C =< 91 ->
-    yystate(5, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, C|Ics, Line, Col, Tlen, _, _) when C >= 93 ->
-    yystate(5, Ics, Line, Col, Tlen+1, 1, Tlen);
-yystate(10, Ics, Line, Col, Tlen, _, _) ->
-    {1,Tlen,Ics,Line,Col,10};
-yystate(9, C|Ics, Line, Col, Tlen, _, _) when C >= 48, C =< 57 ->
-    yystate(9, Ics, Line, Col, Tlen+1, 3, Tlen);
-yystate(9, Ics, Line, Col, Tlen, _, _) ->
-    {3,Tlen,Ics,Line,Col,9};
-yystate(8, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(15, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, 34|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(0, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(8, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(8, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 33 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 35, C =< 91 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 93 ->
-    yystate(8, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(8, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,8};
-yystate(7, 92|Ics, Line, Col, Tlen, _, _) ->
-    yystate(15, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, 34|Ics, Line, Col, Tlen, _, _) ->
-    yystate(0, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, 10|Ics, Line, _, Tlen, _, _) ->
-    yystate(8, Ics, Line+1, 1, Tlen+1, 2, Tlen);
-yystate(7, C|Ics, Line, Col, Tlen, _, _) when C >= 0, C =< 9 ->
-    yystate(8, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, C|Ics, Line, Col, Tlen, _, _) when C >= 11, C =< 33 ->
-    yystate(8, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, C|Ics, Line, Col, Tlen, _, _) when C >= 35, C =< 91 ->
-    yystate(8, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, C|Ics, Line, Col, Tlen, _, _) when C >= 93 ->
-    yystate(8, Ics, Line, Col, Tlen+1, 2, Tlen);
-yystate(7, Ics, Line, Col, Tlen, _, _) ->
-    {2,Tlen,Ics,Line,Col,7};
-yystate(6, Ics, Line, Col, Tlen, _, _) ->
-    {6,Tlen,Ics,Line,Col};
-yystate(5, 92|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(14, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, 39|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(2, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, 10|Ics, Line, _, Tlen, Action, Alen) ->
-    yystate(5, Ics, Line+1, 1, Tlen+1, Action, Alen);
-yystate(5, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 0, C =< 9 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 11, C =< 38 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 40, C =< 91 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, C|Ics, Line, Col, Tlen, Action, Alen) when C >= 93 ->
-    yystate(5, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(5, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,5};
-yystate(4, 95|Ics, Line, Col, Tlen, _, _) ->
-    yystate(4, Ics, Line, Col, Tlen+1, 0, Tlen);
-yystate(4, 64|Ics, Line, Col, Tlen, _, _) ->
-    yystate(4, Ics, Line, Col, Tlen+1, 0, Tlen);
-yystate(4, C|Ics, Line, Col, Tlen, _, _) when C >= 48, C =< 57 ->
-    yystate(4, Ics, Line, Col, Tlen+1, 0, Tlen);
-yystate(4, C|Ics, Line, Col, Tlen, _, _) when C >= 65, C =< 90 ->
-    yystate(4, Ics, Line, Col, Tlen+1, 0, Tlen);
-yystate(4, C|Ics, Line, Col, Tlen, _, _) when C >= 97, C =< 122 ->
-    yystate(4, Ics, Line, Col, Tlen+1, 0, Tlen);
-yystate(4, Ics, Line, Col, Tlen, _, _) ->
-    {0,Tlen,Ics,Line,Col,4};
-yystate(3, 62|Ics, Line, Col, Tlen, Action, Alen) ->
-    yystate(11, Ics, Line, Col, Tlen+1, Action, Alen);
-yystate(3, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,3};
-yystate(2, Ics, Line, Col, Tlen, _, _) ->
-    {1,Tlen,Ics,Line,Col};
-yystate(1, Ics, Line, Col, Tlen, _, _) ->
-    {7,Tlen,Ics,Line,Col};
-yystate(0, Ics, Line, Col, Tlen, _, _) ->
-    {2,Tlen,Ics,Line,Col};
-yystate(S, Ics, Line, Col, Tlen, Action, Alen) ->
-    {Action,Alen,Tlen,Ics,Line,Col,S}.
+yystate(19, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(15, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, 34|Ics, Line, Tlen, Action, Alen) ->
+    yystate(7, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(8, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(19, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 33 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, C|Ics, Line, Tlen, Action, Alen) when C >= 35, C =< 91 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, C|Ics, Line, Tlen, Action, Alen) when C >= 93 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(19, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,19};
+yystate(18, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(14, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, 39|Ics, Line, Tlen, Action, Alen) ->
+    yystate(10, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(5, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(18, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 38 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, C|Ics, Line, Tlen, Action, Alen) when C >= 40, C =< 91 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, C|Ics, Line, Tlen, Action, Alen) when C >= 93 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(18, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,18};
+yystate(17, 60|Ics, Line, Tlen, Action, Alen) ->
+    yystate(11, Ics, Line, Tlen+1, Action, Alen);
+yystate(17, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,17};
+yystate(16, 10|Ics, Line, Tlen, _, _) ->
+    yystate(16, Ics, Line+1, Tlen+1, 8, Tlen);
+yystate(16, C|Ics, Line, Tlen, _, _) when C >= 0, C =< 9 ->
+    yystate(16, Ics, Line, Tlen+1, 8, Tlen);
+yystate(16, C|Ics, Line, Tlen, _, _) when C >= 11, C =< 32 ->
+    yystate(16, Ics, Line, Tlen+1, 8, Tlen);
+yystate(16, Ics, Line, Tlen, _, _) ->
+    {8,Tlen,Ics,Line,16};
+yystate(15, 94|Ics, Line, Tlen, Action, Alen) ->
+    yystate(19, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, 93|Ics, Line, Tlen, Action, Alen) ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(15, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, 34|Ics, Line, Tlen, Action, Alen) ->
+    yystate(7, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(8, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(15, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 33 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, C|Ics, Line, Tlen, Action, Alen) when C >= 35, C =< 91 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, C|Ics, Line, Tlen, Action, Alen) when C >= 95 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(15, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,15};
+yystate(14, 94|Ics, Line, Tlen, Action, Alen) ->
+    yystate(18, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, 93|Ics, Line, Tlen, Action, Alen) ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(14, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, 39|Ics, Line, Tlen, Action, Alen) ->
+    yystate(10, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(5, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(14, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 38 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, C|Ics, Line, Tlen, Action, Alen) when C >= 40, C =< 91 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, C|Ics, Line, Tlen, Action, Alen) when C >= 95 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(14, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,14};
+yystate(13, Ics, Line, Tlen, _, _) ->
+    {4,Tlen,Ics,Line};
+yystate(12, 125|Ics, Line, Tlen, Action, Alen) ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 123|Ics, Line, Tlen, Action, Alen) ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 93|Ics, Line, Tlen, Action, Alen) ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 91|Ics, Line, Tlen, Action, Alen) ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 62|Ics, Line, Tlen, Action, Alen) ->
+    yystate(3, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 61|Ics, Line, Tlen, Action, Alen) ->
+    yystate(3, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 60|Ics, Line, Tlen, Action, Alen) ->
+    yystate(17, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 47|Ics, Line, Tlen, Action, Alen) ->
+    yystate(1, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 46|Ics, Line, Tlen, Action, Alen) ->
+    yystate(6, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 39|Ics, Line, Tlen, Action, Alen) ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 35|Ics, Line, Tlen, Action, Alen) ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 34|Ics, Line, Tlen, Action, Alen) ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(16, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(12, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(16, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 32 ->
+    yystate(16, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, C|Ics, Line, Tlen, Action, Alen) when C >= 43, C =< 45 ->
+    yystate(13, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, C|Ics, Line, Tlen, Action, Alen) when C >= 48, C =< 57 ->
+    yystate(9, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, C|Ics, Line, Tlen, Action, Alen) when C >= 97, C =< 122 ->
+    yystate(4, Ics, Line, Tlen+1, Action, Alen);
+yystate(12, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,12};
+yystate(11, Ics, Line, Tlen, _, _) ->
+    {5,Tlen,Ics,Line};
+yystate(10, 92|Ics, Line, Tlen, _, _) ->
+    yystate(14, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, 39|Ics, Line, Tlen, _, _) ->
+    yystate(2, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, 10|Ics, Line, Tlen, _, _) ->
+    yystate(5, Ics, Line+1, Tlen+1, 1, Tlen);
+yystate(10, C|Ics, Line, Tlen, _, _) when C >= 0, C =< 9 ->
+    yystate(5, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, C|Ics, Line, Tlen, _, _) when C >= 11, C =< 38 ->
+    yystate(5, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, C|Ics, Line, Tlen, _, _) when C >= 40, C =< 91 ->
+    yystate(5, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, C|Ics, Line, Tlen, _, _) when C >= 93 ->
+    yystate(5, Ics, Line, Tlen+1, 1, Tlen);
+yystate(10, Ics, Line, Tlen, _, _) ->
+    {1,Tlen,Ics,Line,10};
+yystate(9, C|Ics, Line, Tlen, _, _) when C >= 48, C =< 57 ->
+    yystate(9, Ics, Line, Tlen+1, 3, Tlen);
+yystate(9, Ics, Line, Tlen, _, _) ->
+    {3,Tlen,Ics,Line,9};
+yystate(8, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(15, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, 34|Ics, Line, Tlen, Action, Alen) ->
+    yystate(0, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(8, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(8, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 33 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, C|Ics, Line, Tlen, Action, Alen) when C >= 35, C =< 91 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, C|Ics, Line, Tlen, Action, Alen) when C >= 93 ->
+    yystate(8, Ics, Line, Tlen+1, Action, Alen);
+yystate(8, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,8};
+yystate(7, 92|Ics, Line, Tlen, _, _) ->
+    yystate(15, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, 34|Ics, Line, Tlen, _, _) ->
+    yystate(0, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, 10|Ics, Line, Tlen, _, _) ->
+    yystate(8, Ics, Line+1, Tlen+1, 2, Tlen);
+yystate(7, C|Ics, Line, Tlen, _, _) when C >= 0, C =< 9 ->
+    yystate(8, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, C|Ics, Line, Tlen, _, _) when C >= 11, C =< 33 ->
+    yystate(8, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, C|Ics, Line, Tlen, _, _) when C >= 35, C =< 91 ->
+    yystate(8, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, C|Ics, Line, Tlen, _, _) when C >= 93 ->
+    yystate(8, Ics, Line, Tlen+1, 2, Tlen);
+yystate(7, Ics, Line, Tlen, _, _) ->
+    {2,Tlen,Ics,Line,7};
+yystate(6, Ics, Line, Tlen, _, _) ->
+    {6,Tlen,Ics,Line};
+yystate(5, 92|Ics, Line, Tlen, Action, Alen) ->
+    yystate(14, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, 39|Ics, Line, Tlen, Action, Alen) ->
+    yystate(2, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, 10|Ics, Line, Tlen, Action, Alen) ->
+    yystate(5, Ics, Line+1, Tlen+1, Action, Alen);
+yystate(5, C|Ics, Line, Tlen, Action, Alen) when C >= 0, C =< 9 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, C|Ics, Line, Tlen, Action, Alen) when C >= 11, C =< 38 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, C|Ics, Line, Tlen, Action, Alen) when C >= 40, C =< 91 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, C|Ics, Line, Tlen, Action, Alen) when C >= 93 ->
+    yystate(5, Ics, Line, Tlen+1, Action, Alen);
+yystate(5, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,5};
+yystate(4, 95|Ics, Line, Tlen, _, _) ->
+    yystate(4, Ics, Line, Tlen+1, 0, Tlen);
+yystate(4, 64|Ics, Line, Tlen, _, _) ->
+    yystate(4, Ics, Line, Tlen+1, 0, Tlen);
+yystate(4, C|Ics, Line, Tlen, _, _) when C >= 48, C =< 57 ->
+    yystate(4, Ics, Line, Tlen+1, 0, Tlen);
+yystate(4, C|Ics, Line, Tlen, _, _) when C >= 65, C =< 90 ->
+    yystate(4, Ics, Line, Tlen+1, 0, Tlen);
+yystate(4, C|Ics, Line, Tlen, _, _) when C >= 97, C =< 122 ->
+    yystate(4, Ics, Line, Tlen+1, 0, Tlen);
+yystate(4, Ics, Line, Tlen, _, _) ->
+    {0,Tlen,Ics,Line,4};
+yystate(3, 62|Ics, Line, Tlen, Action, Alen) ->
+    yystate(11, Ics, Line, Tlen+1, Action, Alen);
+yystate(3, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,3};
+yystate(2, Ics, Line, Tlen, _, _) ->
+    {1,Tlen,Ics,Line};
+yystate(1, Ics, Line, Tlen, _, _) ->
+    {7,Tlen,Ics,Line};
+yystate(0, Ics, Line, Tlen, _, _) ->
+    {2,Tlen,Ics,Line};
+yystate(S, Ics, Line, Tlen, Action, Alen) ->
+    {Action,Alen,Tlen,Ics,Line,S}.
 
-%% yyaction(Action, TokenLength, TokenChars, TokenLine, TokenCol) ->
+%% yyaction(Action, TokenLength, TokenChars, TokenLine) ->
 %% {token,Token} | {end_token, Token} | skip_token | {error,String}.
 %% Generated action function.
 
-yyaction(0, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(0, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_0(TokenChars, TokenLine);
-yyaction(1, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(1, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_1(TokenChars, TokenLen, TokenLine);
-yyaction(2, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(2, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_2(TokenChars, TokenLen, TokenLine);
-yyaction(3, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(3, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_3(TokenChars, TokenLine);
-yyaction(4, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(4, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_4(TokenChars, TokenLine);
-yyaction(5, TokenLen, YYtcs, TokenLine, _) ->
+yyaction(5, TokenLen, YYtcs, TokenLine) ->
     TokenChars = yypre(YYtcs, TokenLen),
     yyaction_5(TokenChars, TokenLine);
-yyaction(6, _, _, TokenLine, _) ->
+yyaction(6, _, _, TokenLine) ->
     yyaction_6(TokenLine);
-yyaction(7, _, _, TokenLine, _) ->
+yyaction(7, _, _, TokenLine) ->
     yyaction_7(TokenLine);
-yyaction(8, _, _, _, _) ->
+yyaction(8, _, _, _) ->
     yyaction_8();
-yyaction(_, _, _, _, _) -> error.
+yyaction(_, _, _, _) -> error.
 
 -compile({inline,yyaction_0/2}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 12).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 12).
 yyaction_0(TokenChars, TokenLine) ->
      tokenize_atom (TokenChars, TokenLine) .
 
 -compile({inline,yyaction_1/3}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 13).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 13).
 yyaction_1(TokenChars, TokenLen, TokenLine) ->
      tokenize_atom (escape (unquote (TokenChars, TokenLen)), TokenLine) .
 
 -compile({inline,yyaction_2/3}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 14).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 14).
 yyaction_2(TokenChars, TokenLen, TokenLine) ->
      { token, { string, TokenLine, escape (unquote (TokenChars, TokenLen)) } } .
 
 -compile({inline,yyaction_3/2}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 15).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 15).
 yyaction_3(TokenChars, TokenLine) ->
      { token, { integer, TokenLine, list_to_integer (TokenChars) } } .
 
 -compile({inline,yyaction_4/2}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 16).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 16).
 yyaction_4(TokenChars, TokenLine) ->
      { token, { list_to_atom (TokenChars), TokenLine } } .
 
 -compile({inline,yyaction_5/2}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 17).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 17).
 yyaction_5(TokenChars, TokenLine) ->
      { token, { list_to_atom (TokenChars), TokenLine } } .
 
 -compile({inline,yyaction_6/1}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 18).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 18).
 yyaction_6(TokenLine) ->
      { token, { dot, TokenLine } } .
 
 -compile({inline,yyaction_7/1}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 19).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 19).
 yyaction_7(TokenLine) ->
      { token, { '/', TokenLine } } .
 
 -compile({inline,yyaction_8/0}).
--file("/home/todd/ERLANG/hex_core/src/safe_erl_term.xrl", 20).
+-file("/obs/_cache/osmo-s1gw/_build/default/plugins/hex_core/src/safe_erl_term.xrl", 20).
 yyaction_8() ->
      skip_token .
--file("/home/todd/.asdf/installs/erlang/26.2.1/lib/parsetools-2.5/include/leexinc.hrl", 344).
+
+-file("/usr/lib/erlang/lib/parsetools-2.4.1/include/leexinc.hrl", 313).

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/README.md -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/README.md Changed

@@ -1,13 +1,13 @@
 # rebar3_hex
 
-!Build Status(https://github.com/erlef/rebar3_hex/actions/workflows/ci.yml/badge.svg)(https://github.com/erlef/rebar3_hex/actions/workflows/ci.yml) 
+!Build Status(https://github.com/erlef/rebar3_hex/actions/workflows/ci.yml/badge.svg)(https://github.com/erlef/rebar3_hex/actions/workflows/ci.yml)
 !Hex pm(https://img.shields.io/hexpm/v/rebar3_hex.svg)(https://hex.pm/packages/rebar3_hex)
 !Docs(https://img.shields.io/badge/hex-docs-green.svg?style=flat)(https://hexdocs.pm/rebar3_hex)
-!Erlang Versions(https://img.shields.io/badge/Supported%20Erlang%2FOTP-22.0%20to%2024.0-blue)(http://www.erlang.org)
+!Erlang Versions(https://img.shields.io/badge/Supported%20Erlang%2FOTP-25.0%20to%2027.0-blue)(http://www.erlang.org)
 
 rebar3_hex is a plugin for Rebar3(https://www.rebar3.org/) that bundles providers to interact with Hex(https://hex.pm/).
 
-> 💡 **rebar3_hex is a tool for package authors**  
+> 💡 **rebar3_hex is a tool for package authors**
 > If your Erlang project is not meant to be published on Hex, Rebar3 itself should be enough for you.
 
 ## Setup
@@ -18,22 +18,22 @@
 {plugins, rebar3_hex}.
 ```
 
-Alternatively, you can add to your project's rebar3 config in project plugins : 
+Alternatively, you can add to your project's rebar3 config in project plugins :
 
 ```erlang
 {project_plugins, rebar3_hex}.
 ```
 
-**NOTE** : Be sure **not** to add `rebar3_hex` to the plugins section within a projects rebar3 config as this will 
+**NOTE** : Be sure **not** to add `rebar3_hex` to the plugins section within a projects rebar3 config as this will
 become a dependency for others downloading your package from hex.pm
 
 ### Documentation
 
 rebar3_hex by default expects you to configure a documentation provider. We recommend using
-rebar3_ex_doc(https://hexdocs.pm/rebar3_ex_doc/) for publishing documentation along with your package for a 
-consistent format and style on hex.pm(https://hex.pm/). 
+rebar3_ex_doc(https://hexdocs.pm/rebar3_ex_doc/) for publishing documentation along with your package for a
+consistent format and style on hex.pm(https://hex.pm/).
 
-Example : 
+Example :
 
 ```erlang
 
@@ -46,16 +46,16 @@
 {hex, {doc, ex_doc}}.
 ```
 
-Alternatively, or on Erlang versions older than OTP-24, you can use the edoc provider that ships with rebar3 : 
+Alternatively, or on Erlang versions older than OTP-24, you can use the edoc provider that ships with rebar3 :
 
 ```erlang
 {hex, {doc, edoc}}.
 ```
 
-## Basic usage 
+## Basic usage
 
 You should read the docs(https://hexdocs.pm/rebar3_hex/) for a complete over for each provider, but below is a
-brief overview of basic usage. 
+brief overview of basic usage.
 
 ### Authenticating User
 
@@ -66,8 +66,8 @@
 $ rebar3 hex user auth
 ```
 
-Note that this will ask for your hex.pm username and password, as well as a password for encrypting your api token that 
-has write permissions to the repository. When publishing a package you will have to give this password to decrypt the 
+Note that this will ask for your hex.pm username and password, as well as a password for encrypting your api token that
+has write permissions to the repository. When publishing a package you will have to give this password to decrypt the
 token in order to publish.
 
 See the docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_user.html) for more information.
@@ -76,7 +76,7 @@
 
 The `build` provider is very useful for seeing exactly what would be published using either the `publish` or `cut` task
 without any chance of actually publishing the package or docs. Tarballs for the package and docs are written to
-`_build/<profile>/lib/your_app/hex/` by default. 
+`_build/<profile>/lib/your_app/hex/` by default.
 
 
 ```
@@ -85,32 +85,32 @@
 
 See the docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_build.html) for more information.
 
-### Publishing 
+### Publishing
 
-Two providers are available for publishing packages, `publish` and `cut` 
+Two providers are available for publishing packages, `publish` and `cut`
 
-By default `publish` builds and pushes your package and docs to a repository. See the 
-docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_publish.html) for more information. 
+By default `publish` builds and pushes your package and docs to a repository. See the
+docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_publish.html) for more information.
 
 ``` shell
 $ rebar3 hex publish
 ```
 
-`cut` is available to provide some additional functionality around versioning and git tags. See the 
-docs(https://hexdocs.pm/hex/rebar3_hex_cut.html) for more information.
+`cut` is available to provide some additional functionality around versioning and git tags. See the
+docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_cut.html) for more information.
 
 ``` shell
 $ rebar3 hex cut
 ```
 
-In either case, both providers will display the details of what is being published 
-(what files, the version, dependencies) and ask if it should continue, so be sure to read the 
+In either case, both providers will display the details of what is being published
+(what files, the version, dependencies) and ask if it should continue, so be sure to read the
 output carefully and make sure it is publishing what you expected.
 
-### Managing package owners 
+### Managing package owners
 
 Owners can be added, removed, and listed for packages you are an owner of with the `hex owner` command. Packages
-can also be transfered to other registered users on hexpm as well. 
+can also be transfered to other registered users on hexpm as well.
 
 ``` shell
 $ rebar3 hex owner add | remove | list | transfer <package> <email>
@@ -118,28 +118,28 @@
 
 See the docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_owner.html) for more information.
 
-### Retiring packages 
+### Retiring packages
 
-Packages can be flagged as retired on hexpm via the `retire` provider : 
+Packages can be flagged as retired on hexpm via the `retire` provider :
 
 ```
 $ rebar3 hex retire PACKAGE VERSION REASON --message
 ```
 
-They can also be unretired in case a mistake was made : 
+They can also be unretired in case a mistake was made :
 
 ```
-$ rebar3 hex retire PACKAGE VERSION --unretire 
+$ rebar3 hex retire PACKAGE VERSION --unretire
 ```
 
 See the docs(https://hexdocs.pm/rebar3_hex/rebar3_hex_retire.html) for more information.
 
 ### Organizations
 
-rebar3_hex supports working with organizations via the `organization` provider. 
+rebar3_hex supports working with organizations via the `organization` provider.
 
 Simply add your organization to either your global rebar.config (i.e., `~/.config/rebar3/rebar.config` ) or a local
-project rebar.config. 
+project rebar.config.
 
 ```erlang
 {hex, {repos, #{name => <<"hexpm:your_org">>}}}.
@@ -149,7 +149,7 @@
 repository first:
 
 ```
-$ rebar3 hex auth    # make sure you're authenticated to the main repo first 
+$ rebar3 hex auth    # make sure you're authenticated to the main repo first
 $ rebar3 hex organization auth hexpm:your_org  # authenticate to the org
 ```
 
@@ -160,7 +160,7 @@
 
 #### Read-Only Repo Key for CI
 
-If you have a private organization or other private repository it is recommended that you use a repo specific 
+If you have a private organization or other private repository it is recommended that you use a repo specific
 auth token for reading from the repository in CI. To generate a token:
 
 ```shell
@@ -168,22 +168,22 @@
 Successfully authenticated to hexpm:myrepo
 ```
 
-Now you can generate a key to use in CI for your organization 
+Now you can generate a key to use in CI for your organization
 
 ```
 $ rebar3 hex organization key hexpm:myrepo generate
 abc123
 ```
 
-Then in CI use whatever method is available for setting an environment variable to the token and add this call at the 
+Then in CI use whatever method is available for setting an environment variable to the token and add this call at the
 beginning of your CI runs to add the token to your rebar3 hex config. Below we'll use the environment `REPO_KEY` as an
-example. 
+example.
 
 ```shell
 $ rebar3 hex organization auth hexpm:myrepo --key $REPO_KEY
 ```
 
-### Searching hexpm 
+### Searching hexpm
 
 A `search` provider is available to search packages across hex.pm as a convenience.
 
@@ -191,6 +191,6 @@
 $ rebar3 hex search
 ```
 
-# Further reading 
-See Publishing packages(https://hex.pm/docs/rebar3-publish) on hexpm for more setup and usage instructions. See the 
+# Further reading
+See Publishing packages(https://hex.pm/docs/rebar3-publish) on hexpm for more setup and usage instructions. See the
 docs(https://hexdocs.pm/rebar3_hex) for detailed documentation for all available providers.

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/ebin/rebar3_hex.app -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/ebin/rebar3_hex.app Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/hex_metadata.config -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/hex_metadata.config Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/rebar.config -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/rebar.config Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/rebar.lock -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/rebar.lock Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex.app.src -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex.app.src Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_build.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_build.erl Changed

@@ -212,6 +212,9 @@
     " rebar3 hex build package if you only need to build a package.",
     io_lib:format(Str, );
 
+format_error({app_not_found, AppName})  ->
+    io_lib:format("App ~s specified with --app switch not found in project", AppName);
+
 format_error(app_switch_required) ->
      "--app switch is required when building packages or docs in a umbrella with multiple apps";
 
@@ -230,6 +233,14 @@
 doc_provider_not_found(Provider) ->
     io_lib:format("The doc provider ~ts specified in your hex config could not be found", Provider).
 
+handle_task(#{apps := _,_|_ = Apps, args := #{app := AppName}} = T) ->
+    case rebar3_hex_app:find(Apps, AppName) of
+        {ok, App} ->
+          handle_task(T#{apps := App});
+        _Error ->
+            ?RAISE({app_not_found, AppName})
+    end;
+
 handle_task(#{apps := _,_|_}) ->
     ?RAISE(app_switch_required);
 
@@ -484,7 +495,6 @@
     create_docs(State, Repo, App, #{doc_dir => undefined}).
 
 %% @private
--dialyzer({nowarn_function, create_docs/4}).
 create_docs(State, Repo, App, Args) ->
     case maybe_gen_docs(State, Repo, App, Args) of
         {ok, DocDir} ->
@@ -496,23 +506,19 @@
                     PkgName = rebar_utils:to_list(proplists:get_value(pkg_name, AppDetails, Name)),
                     OriginalVsn = rebar_app_info:original_vsn(App),
                     Vsn = rebar_utils:vcs_vsn(App, OriginalVsn, State),
-                    case create_docs_tarball(Files) of
+                    case hex_tarball:create_docs(Files) of
                         {ok, Tarball} ->
                             {ok, #{
                                 type => docs, tarball => Tarball, name => binarify(PkgName), version => binarify(Vsn)
                             }};
                         {error, Reason} ->
-                            {error, hex_tarball:format_error(Reason)};
-                        Err ->
-                            Err
+                            {error, hex_tarball:format_error(Reason)}
                     end;
                 false ->
                     {error, missing_doc_index}
             end;
         {error, _} = Err ->
-            Err;
-        Err ->
-            {error, Err}
+            Err
     end.
 
 maybe_gen_docs(_State, _Repo, App, #{doc_dir := DocDir}) when is_list(DocDir) ->
@@ -591,24 +597,12 @@
 binarify(Term) ->
     Term.
 
--dialyzer({nowarn_function, create_package_tarball/2}).
 create_package_tarball(Metadata, Files) ->
     case hex_tarball:create(Metadata, Files) of
         {ok, #{tarball := Tarball, inner_checksum := _Checksum}} ->
             Tarball;
         {error, Reason} ->
-            {error, hex_tarball:format_error(Reason)};
-        Error ->
-            Error
-    end.
-
--dialyzer({nowarn_function, create_docs_tarball/1}).
-create_docs_tarball(Files) ->
-    case hex_tarball:create_docs(Files) of
-        {ok, Tarball} ->
-            {ok, Tarball};
-        Error ->
-            Error
+            {error, hex_tarball:format_error(Reason)}
     end.
 
 -spec to_atom(atom() | string() | binary() | integer() | float()) ->

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_client.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_client.erl Changed

@@ -35,7 +35,7 @@
     response(Res).
 
 me(HexConfig) ->
-    Res = hex_api_user:me(HexConfig),
+    Res = hex_api_user:me(to_hex_core_config(HexConfig)),
     response(Res).
 
 key_add(HexConfig, <<KeyName/binary>>, Perms) ->
@@ -69,11 +69,11 @@
     response(Res).
 
 test_key(HexConfig, Perms) ->
-   Res = hex_api_auth:test(HexConfig, Perms),
+   Res = hex_api_auth:test(to_hex_core_config(HexConfig), Perms),
    response(Res).
 
 publish(HexConfig, Tarball, Opts) ->
-    Res = hex_api_release:publish(HexConfig, Tarball, Opts),
+    Res = hex_api_release:publish(to_hex_core_config(HexConfig), Tarball, Opts),
     response(Res).
 
 delete_release(HexConfig, Name, Version) ->
@@ -95,7 +95,6 @@
     Res = hex_api:delete(Config, "packages", Name, "releases", Version, "docs"),
     response(Res).
 
--dialyzer({nowarn_function, retire/5}).
 retire(Config, Package, Version, Reason, Message) ->
     Msg = #{<<"reason">> => Reason,
             <<"message">> => Message
@@ -161,3 +160,7 @@
 
 to_binary(Subject) ->
     rebar_utils:to_binary(Subject).
+
+to_hex_core_config(#{name := Name} = HexConfig) ->
+    NewHexConfig = HexConfig#{repo_name := Name},
+    maps:remove(name, NewHexConfig).

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_error.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_error.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_organization.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_organization.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_publish.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_publish.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_retire.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_retire.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_user.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/_checkouts/rebar3_hex/src/rebar3_hex_user.erl Changed

@@ -362,23 +362,25 @@
 handle_task(_) ->
     ?RAISE(bad_command).
 
--dialyzer({no_fail_call, whoami/2}).
 whoami(#{name := Name} = Repo, State) ->
     case maps:get(read_key, Repo, undefined) of
         undefined ->
             ?RAISE(not_authenticated);
         ReadKey ->
-            case rebar3_hex_client:me(maps:remove(name, Repo#{api_key => ReadKey})) of
-                {ok, #{<<"username">> := Username,
-                                       <<"email">> := Email}} ->
-                    rebar3_hex_io:say("~ts : ~ts (~ts)", Name, Username, Email),
+            case rebar3_hex_client:me(Repo#{api_key => ReadKey}) of
+                {ok, #{<<"username">> := UserName} = Res} ->
+                    Header = "Repo", "User Name", "Full Name", "Email",
+                    FullName = maps:get(<<"full_name">>, Res, <<"private">>),
+                    Email = maps:get(<<"email">>, Res, <<"private">>),
+                    Body = binary_to_list(Name), binary_to_list(UserName), binary_to_list(FullName), binary_to_list(Email),
+                    ok = rebar3_hex_results:print_table(Header ++ Body),
                     {ok, State};
                 {error, #{<<"message">> := Message}} ->
                     ?RAISE({whoami, Message});
                 Err  ->
                     ?RAISE({whoami, Err})
             end
-    end.
+      end.
 
 get_string_input(Prompt) ->
     MaxRetries = 3,
@@ -436,7 +438,6 @@
             do_get_password(Type, Fun,  MaxRetries - 1)
     end.
 
--dialyzer({no_fail_call, create_user/5}).
 create_user(Username, Email, Password, Repo, State) ->
     case rebar3_hex_client:create_user(Repo, Username, Password, Email) of
         {ok, _} ->
@@ -493,8 +494,6 @@
     end.
 -endif.
 
--dialyzer({nowarn_function, generate_key/3}).
-%%-dialyzer({nowarn_function, hex_api_key:add/3}).
 generate_key(HexConfig, KeyName, Perms) ->
     case rebar3_hex_key:generate(HexConfig, KeyName, Perms) of
         {ok, #{<<"secret">> := Secret}} ->
@@ -512,11 +511,9 @@
 api_key_name() ->
     rebar_utils:to_binary(hostname()).
 
--dialyzer({nowarn_function, api_key_name/1}).
 api_key_name(Postfix) ->
     rebar_utils:to_binary(hostname(), "-api-", Postfix).
 
--dialyzer({nowarn_function, repos_key_name/0}).
 repos_key_name() ->
     rebar_utils:to_binary(hostname(), "-repositories").

osmo-s1gw_0.3.0.154.d196.tar.xz/build_dep.tar.gz -> osmo-s1gw_0.3.0.157.d603.tar.xz/build_dep.tar.gz Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/debian/changelog -> osmo-s1gw_0.3.0.157.d603.tar.xz/debian/changelog Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/debian/control -> osmo-s1gw_0.3.0.157.d603.tar.xz/debian/control Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/src/erab_fsm.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/src/erab_fsm.erl Changed

osmo-s1gw_0.3.0.154.d196.tar.xz/src/s1ap_proxy.erl -> osmo-s1gw_0.3.0.157.d603.tar.xz/src/s1ap_proxy.erl Changed

@@ -67,8 +67,12 @@
 -type enb_ue_id() :: 0..16#ffffff.
 -type erab_id() :: 0..16#ff.
 -type erab_uid() :: {mme_ue_id(), enb_ue_id(), erab_id()}.
+-type plmn_id() :: {MCC :: nonempty_string(),
+                    MNC :: nonempty_string()}.
 
 -record(proxy_state, {erabs :: dict:dict(),
+                      enb_id :: undefined | non_neg_integer(),
+                      plmn_id :: undefined | plmn_id(),
                       mme_ue_id :: undefined | mme_ue_id(),
                       enb_ue_id :: undefined | enb_ue_id(),
                       erab_id :: undefined | erab_id(),
@@ -195,6 +199,35 @@
     ok.
 
 
+%% Parse PLMN-ID as per 3GPP TS 24.008, Figure 10.5.13
+%% | MCC digit 2 | MCC digit 1 |  octet 1
+%% | MNC digit 3 | MCC digit 3 |  octet 2
+%% | MNC digit 2 | MNC digit 1 |  octet 3
+-spec parse_plmn_id(<< _:24 >>) -> plmn_id().
+parse_plmn_id(<< MCC2:4, MCC1:4,
+                 MNC3:4, MCC3:4,
+                 MNC2:4, MNC1:4 >>) ->
+    MCC = parse_mcc_mnc(MCC1, MCC2, MCC3),
+    MNC = parse_mcc_mnc(MNC1, MNC2, MNC3),
+    {MCC, MNC}.
+
+
+-define(UNHEX(H), H + 48).
+
+parse_mcc_mnc(D1, D2, 16#f) ->
+    ?UNHEX(D1), ?UNHEX(D2);
+
+parse_mcc_mnc(D1, D2, D3) ->
+    ?UNHEX(D1), ?UNHEX(D2), ?UNHEX(D3).
+
+
+-spec parse_enb_id(tuple()) -> non_neg_integer().
+parse_enb_id({'macroENB-ID', << ID:20 >>}) -> ID;
+parse_enb_id({'homeENB-ID', << ID:28 >>}) -> ID;
+parse_enb_id({'short-macroENB-ID', << ID:18 >>}) -> ID;
+parse_enb_id({'long-macroENB-ID', << ID:21 >>}) -> ID.
+
+
 %% Encode an S1AP PDU
 -spec encode_pdu(s1ap_pdu()) -> {ok, binary()} |
                                 {error, {asn1, tuple()}}.
@@ -260,6 +293,17 @@
 -spec handle_pdu(s1ap_pdu(), proxy_state()) -> {{proxy_action(), s1ap_pdu()}, proxy_state()} |
                                                {forward, proxy_state()}.
 
+%% 9.1.8.4 S1 SETUP REQUEST
+handle_pdu({initiatingMessage,
+            #'InitiatingMessage'{procedureCode = ?'id-S1Setup',
+                                 value = C0}}, S0) ->
+    ?LOG_DEBUG("Processing S1 SETUP REQUEST"),
+    %% there's nothing to patch in this PDU, so we forward it as-is
+    %% TODO: check result of handle_ies(), inc. ?S1GW_CTR_S1AP_PROXY_IN_PKT_PROC_ERROR
+    {_, S1} = handle_ies(?'id-Global-ENB-ID',
+                         C0#'S1SetupRequest'.protocolIEs, S0),
+    {forward, S1};
+
 %% 9.1.3.1 E-RAB SETUP REQUEST
 handle_pdu({Outcome = initiatingMessage,
             #'InitiatingMessage'{procedureCode = ?'id-E-RABSetup',
@@ -538,6 +582,18 @@
          Result :: {handle_ie_result(),
                     proxy_state()}.
 
+handle_ie(?'id-Global-ENB-ID',
+          #'Global-ENB-ID'{'pLMNidentity' = PLMNId,
+                           'eNB-ID' = ENBId} = C, S0) ->
+    %% store PLMNId/ENBId
+    %% TODO: use that as a context for logging
+    S1 = S0#proxy_state{plmn_id = parse_plmn_id(PLMNId),
+                        enb_id = parse_enb_id(ENBId)},
+    ?LOG_INFO("Global-ENB-ID: PLMN-ID=~p, eNB-ID=~p",
+              S1#proxy_state.plmn_id,
+               S1#proxy_state.enb_id),
+    {{ok, C}, S1};
+
 %% E-RAB SETUP REQUEST related IEs
 handle_ie(?'id-E-RABToBeSetupListBearerSUReq', C, S) ->
     %% This IE contains a list of BearerSUReq, so patch inner IEs

Changes of Revision 39