File 2544-parsetools-Fix-handling-of-locations-and-a... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2544-parsetools-Fix-handling-of-locations-and-annotations.patch of Package erlang (Revision 3fbb28c0756b0c6ee7bbab1611cc9dcf)

Currently displaying revision 3fbb28c0756b0c6ee7bbab1611cc9dcf , Show latest

From 568706c4c4b8261e7a63e20be9a355ebe5d6562e Mon Sep 17 00:00:00 2001
From: Hans Bolinder <hasse@erlang.org>
Date: Mon, 13 Feb 2017 17:00:47 +0100
Subject: [PATCH 15/15] parsetools: Fix handling of locations and annotations

---
 lib/parsetools/src/yecc.erl        | 130 +++++++++++++------------
 lib/parsetools/src/yeccgramm.yrl   |  45 ++++-----
 lib/parsetools/src/yeccparser.erl  | 192 ++++++++++++++-----------------------
 lib/parsetools/test/yecc_SUITE.erl |   4 +-
 4 files changed, 162 insertions(+), 209 deletions(-)

diff --git a/lib/parsetools/src/yecc.erl b/lib/parsetools/src/yecc.erl
index f6b80eb1b..05446c1a8 100644
--- a/lib/parsetools/src/yecc.erl
+++ b/lib/parsetools/src/yecc.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2016. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2017. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -81,7 +81,7 @@
 
 -record(rule, {
           n,             % rule n in the grammar file
-          line,
+          anno,
           symbols,       % the names of symbols
           tokens,
           is_guard,      % the action is a guard (not used)
@@ -105,7 +105,7 @@
 
 -record(user_code, {state, terminal, funname, action}).
 
--record(symbol, {line = none, name}).
+-record(symbol, {anno = none, name}).
 
 %% ACCEPT is neither an atom nor a non-terminal.
 -define(ACCEPT, {}).
@@ -517,7 +517,7 @@ parse_grammar(Grammar, Inport, NextLine, St0) ->
     parse_grammar(Inport, NextLine, St).
 
 parse_grammar({error,ErrorLine,Error}, St) ->
-    add_error(ErrorLine, Error, St);
+    add_error(erl_anno:new(ErrorLine), Error, St);
 parse_grammar({rule, Rule, Tokens}, St0) ->
     NmbrOfDaughters = case Rule of
                           [_, #symbol{name = '$empty'}]  -> 0;
@@ -534,15 +534,15 @@ parse_grammar({rule, Rule, Tokens}, St0) ->
     St#yecc{rules_list = [RuleDef | St#yecc.rules_list]};
 parse_grammar({prec, Prec}, St) ->
     St#yecc{prec = Prec ++ St#yecc.prec};
-parse_grammar({#symbol{}, [{string,Line,String}]}, St) ->
-    add_error(Line, {bad_symbol, String}, St);
-parse_grammar({#symbol{line = Line, name = Name}, Symbols}, St) ->
+parse_grammar({#symbol{}, [{string,Anno,String}]}, St) ->
+    add_error(Anno, {bad_symbol, String}, St);
+parse_grammar({#symbol{anno = Anno, name = Name}, Symbols}, St) ->
     CF = fun(I) ->
                  case element(I, St) of
                      [] -> 
                          setelement(I, St, Symbols);
                      _ -> 
-                         add_error(Line, {duplicate_declaration, Name}, St)
+                         add_error(Anno, {duplicate_declaration, Name}, St)
                  end
          end,
     OneSymbol = length(Symbols) =:= 1,
@@ -553,7 +553,7 @@ parse_grammar({#symbol{line = Line, name = Name}, Symbols}, St) ->
         'Endsymbol' when OneSymbol ->  CF(#yecc.endsymbol);
         'Expect' when OneSymbol -> CF(#yecc.expect_shift_reduce);
         'States' when OneSymbol -> CF(#yecc.expect_n_states); % undocumented
-        _ -> add_warning(Line, bad_declaration, St)
+        _ -> add_warning(Anno, bad_declaration, St)
     end.
 
 read_grammar(Inport, St, Line) ->
@@ -599,7 +599,7 @@ precedence(_) -> unknown.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 check_grammar(St0) ->
-    Empty = #symbol{line = none, name = '$empty'},
+    Empty = #symbol{anno = none, name = '$empty'},
     AllSymbols = St0#yecc.nonterminals ++ St0#yecc.terminals ++ [Empty],
     St1 = St0#yecc{all_symbols = AllSymbols},
     Cs = [fun check_nonterminals/1, fun check_terminals/1, 
@@ -640,12 +640,12 @@ check_rootsymbol(St) ->
     case St#yecc.rootsymbol of
         [] ->
             add_error(rootsymbol_missing, St);
-        [#symbol{line = Line, name = SymName}] ->
+        [#symbol{anno = Anno, name = SymName}] ->
             case kind_of_symbol(St, SymName) of
                 nonterminal ->
                     St#yecc{rootsymbol = SymName};
                 _ ->
-                    add_error(Line, {bad_rootsymbol, SymName}, St)
+                    add_error(Anno, {bad_rootsymbol, SymName}, St)
             end
     end.
 
@@ -653,12 +653,12 @@ check_endsymbol(St) ->
     case St#yecc.endsymbol of
         [] ->
             St#yecc{endsymbol = '$end'};
-        [#symbol{line = Line, name = SymName}] ->
+        [#symbol{anno = Anno, name = SymName}] ->
             case kind_of_symbol(St, SymName) of
                 nonterminal ->
-                    add_error(Line, {endsymbol_is_nonterminal, SymName}, St);
+                    add_error(Anno, {endsymbol_is_nonterminal, SymName}, St);
                 terminal ->
-                    add_error(Line, {endsymbol_is_terminal, SymName}, St);
+                    add_error(Anno, {endsymbol_is_terminal, SymName}, St);
                 _ ->
                     St#yecc{endsymbol = SymName}
             end
@@ -670,8 +670,8 @@ check_expect(St0) ->
             St0#yecc{expect_shift_reduce = 0};
         [#symbol{name = Expect}] when is_integer(Expect) ->
             St0#yecc{expect_shift_reduce = Expect};
-        [#symbol{line = Line, name = Name}] ->
-            St1 = add_error(Line, {bad_expect, Name}, St0),
+        [#symbol{anno = Anno, name = Name}] ->
+            St1 = add_error(Anno, {bad_expect, Name}, St0),
             St1#yecc{expect_shift_reduce = 0}
     end.
 
@@ -681,27 +681,27 @@ check_states(St) ->
             St;
         [#symbol{name = NStates}] when is_integer(NStates) ->
             St#yecc{expect_n_states = NStates};
-        [#symbol{line = Line, name = Name}] ->
-            add_error(Line, {bad_states, Name}, St)
+        [#symbol{anno = Anno, name = Name}] ->
+            add_error(Anno, {bad_states, Name}, St)
     end.
 
 check_precedences(St0) ->
     {St1, _} = 
-        foldr(fun({#symbol{line = Line, name = Op},_I,_A}, {St,Ps}) ->
+        foldr(fun({#symbol{anno = Anno, name = Op},_I,_A}, {St,Ps}) ->
                       case member(Op, Ps) of
                           true ->
-                              {add_error(Line, {duplicate_precedence,Op}, St),
+                              {add_error(Anno, {duplicate_precedence,Op}, St),
                                Ps};
                           false ->
                               {St, [Op | Ps]}
                       end
               end, {St0,[]}, St0#yecc.prec),
-    foldl(fun({#symbol{line = Line, name = Op},I,A}, St) ->
+    foldl(fun({#symbol{anno = Anno, name = Op},I,A}, St) ->
                   case kind_of_symbol(St, Op) of
                       endsymbol ->
-                          add_error(Line,{precedence_op_is_endsymbol,Op}, St);
+                          add_error(Anno,{precedence_op_is_endsymbol,Op}, St);
                       unknown ->
-                          add_error(Line, {precedence_op_is_unknown, Op}, St);
+                          add_error(Anno, {precedence_op_is_unknown, Op}, St);
                       _ -> 
                           St#yecc{prec = [{Op,I,A} | St#yecc.prec]}
                   end
@@ -709,13 +709,13 @@ check_precedences(St0) ->
 
 check_rule(Rule0, {St0,Rules}) ->
     Symbols = Rule0#rule.symbols,
-    #symbol{line = HeadLine, name = Head} = hd(Symbols),
+    #symbol{anno = HeadAnno, name = Head} = hd(Symbols),
     case member(Head, St0#yecc.nonterminals) of
         false -> 
-            {add_error(HeadLine, {undefined_nonterminal, Head}, St0), Rules};
+            {add_error(HeadAnno, {undefined_nonterminal, Head}, St0), Rules};
         true ->
             St = check_rhs(tl(Symbols), St0),
-            Rule = Rule0#rule{line = HeadLine, symbols = names(Symbols)},
+            Rule = Rule0#rule{anno = HeadAnno, symbols = names(Symbols)},
             {St, [Rule | Rules]}
     end.
 
@@ -725,7 +725,7 @@ check_rules(St0) ->
         [] ->
             add_error(no_grammar_rules, St);
         _ ->
-            Rule = #rule{line = none, 
+            Rule = #rule{anno = none,
                          symbols = [?ACCEPT, St#yecc.rootsymbol],
                          tokens = []},
             Rules1 = [Rule | Rules0],
@@ -740,9 +740,9 @@ duplicates(List) ->
 names(Symbols) ->
     map(fun(Symbol) -> Symbol#symbol.name end, Symbols).
 
-symbol_line(Name, St) ->
-    #symbol{line = Line} = symbol_find(Name, St#yecc.all_symbols),
-    Line.
+symbol_anno(Name, St) ->
+    #symbol{anno = Anno} = symbol_find(Name, St#yecc.all_symbols),
+    Anno.
 
 symbol_member(Symbol, Symbols) ->
     symbol_find(Symbol#symbol.name, Symbols) =/= false.
@@ -894,31 +894,33 @@ report_warnings(St) ->
 add_error(E, St) ->
     add_error(none, E, St).
 
-add_error(Line, E, St) ->
-    add_error(St#yecc.infile, Line, E, St).
+add_error(Anno, E, St) ->
+    add_error(St#yecc.infile, Anno, E, St).
 
-add_error(File, Line, E, St) ->
-    St#yecc{errors = [{File,{Line,?MODULE,E}}|St#yecc.errors]}.    
+add_error(File, Anno, E, St) ->
+    Loc = location(Anno),
+    St#yecc{errors = [{File,{Loc,?MODULE,E}}|St#yecc.errors]}.
 
 add_errors(SymNames, E0, St0) ->
     foldl(fun(SymName, St) ->
-                  add_error(symbol_line(SymName, St), {E0, SymName}, St)
+                  add_error(symbol_anno(SymName, St), {E0, SymName}, St)
           end, St0, SymNames).
 
-add_warning(Line, W, St) ->
-    St#yecc{warnings = [{St#yecc.infile,{Line,?MODULE,W}}|St#yecc.warnings]}.
+add_warning(Anno, W, St) ->
+    Loc = location(Anno),
+    St#yecc{warnings = [{St#yecc.infile,{Loc,?MODULE,W}}|St#yecc.warnings]}.
 
 add_warnings(SymNames, W0, St0) ->
     foldl(fun(SymName, St) ->
-                  add_warning(symbol_line(SymName, St), {W0, SymName}, St)
+                  add_warning(symbol_anno(SymName, St), {W0, SymName}, St)
           end, St0, SymNames).
 
 check_rhs([#symbol{name = '$empty'}], St) ->
     St;
 check_rhs(Rhs, St0) ->
     case symbol_find('$empty', Rhs) of
-        #symbol{line = Line} ->
-            add_error(Line, illegal_empty, St0);
+        #symbol{anno = Anno} ->
+            add_error(Anno, illegal_empty, St0);
         false ->
             foldl(fun(Sym, St) ->
                           case symbol_member(Sym, St#yecc.all_symbols) of
@@ -926,13 +928,13 @@ check_rhs(Rhs, St0) ->
                                   St;
                               false -> 
                                   E = {undefined_symbol,Sym#symbol.name},
-                                  add_error(Sym#symbol.line, E, St)
+                                  add_error(Sym#symbol.anno, E, St)
                           end
                   end, St0, Rhs)
     end.
 
 check_action(Tokens) ->
-    case erl_parse:parse_exprs(add_roberts_dot(Tokens, 0)) of
+    case erl_parse:parse_exprs(add_roberts_dot(Tokens, erl_anno:new(0))) of
         {error, _Error} ->
             {false, false};
         {ok, [Expr | Exprs]} ->
@@ -940,10 +942,10 @@ check_action(Tokens) ->
             {IsGuard, true}
     end.
 
-add_roberts_dot([], Line) ->
-    [{'dot', Line}];
-add_roberts_dot([{'dot', Line} | _], _) ->
-    [{'dot', Line}];
+add_roberts_dot([], Anno) ->
+    [{'dot', Anno}];
+add_roberts_dot([{'dot', Anno} | _], _) ->
+    [{'dot', Anno}];
 add_roberts_dot([Token | Tokens], _) ->
     [Token | add_roberts_dot(Tokens, element(2, Token))].
 
@@ -953,21 +955,22 @@ subst_pseudo_vars([H0 | T0], NmbrOfDaughters, St0) ->
     {H, St1} = subst_pseudo_vars(H0, NmbrOfDaughters, St0),
     {T, St} = subst_pseudo_vars(T0, NmbrOfDaughters, St1),
     {[H | T], St};
-subst_pseudo_vars({atom, Line, Atom}, NmbrOfDaughters, St0) ->
+subst_pseudo_vars({atom, Anno, Atom}, NmbrOfDaughters, St0) ->
     case atom_to_list(Atom) of
         [$$ | Rest] ->
             try list_to_integer(Rest) of
                 N when N > 0, N =< NmbrOfDaughters ->
-                    {{var, Line, list_to_atom(append("__", Rest))}, St0};
+                    {{var, Anno, list_to_atom(append("__", Rest))}, St0};
                 _ ->
-                    St = add_error(Line, {undefined_pseudo_variable, Atom}, 
+                    St = add_error(Anno,
+                                   {undefined_pseudo_variable, Atom},
                                    St0),
-                    {{atom, Line, '$undefined'}, St}
+                    {{atom, Anno, '$undefined'}, St}
             catch 
-                error: _ -> {{atom, Line, Atom}, St0}
+                error: _ -> {{atom, Anno, Atom}, St0}
             end;
         _ ->
-            {{atom, Line, Atom}, St0}
+            {{atom, Anno, Atom}, St0}
     end;
 subst_pseudo_vars(Tuple, NmbrOfDaughters, St0) when is_tuple(Tuple) ->
     {L, St} = subst_pseudo_vars(tuple_to_list(Tuple), NmbrOfDaughters, St0),
@@ -2295,9 +2298,9 @@ function_name(Name, Suf) ->
     list_to_atom(concat([Name, '_' | quoted_atom(Suf)])).
 
 rule(RulePointer, St) ->
-    #rule{n = N, line = Line, symbols = Symbols} = 
+    #rule{n = N, anno = Anno, symbols = Symbols} =
         dict:fetch(RulePointer, St#yecc.rule_pointer2rule),
-    {Symbols, Line, N}.
+    {Symbols, Anno, N}.
 
 get_rule(RuleNmbr, St) ->
     dict:fetch(RuleNmbr, St#yecc.rule_pointer2rule).
@@ -2463,7 +2466,7 @@ include(St, File, Outport) ->
 include1(eof, _, _, _File, L, _St) ->
     L;
 include1({error, _}=_Error, _Inport, _Outport, File, L, St) ->
-    throw(add_error(File, L, cannot_parse, St));
+    throw(add_error(File, erl_anno:new(L), cannot_parse, St));
 include1(Line, Inport, Outport, File, L, St) ->
     Incr = case member($\n, Line) of
                true -> 1;
@@ -2488,7 +2491,7 @@ includefile_version(Includefile) ->
 
 parse_file(Epp) ->
     case epp:parse_erl_form(Epp) of
-        {ok, {function,_Line,yeccpars1,7,_Clauses}} ->
+        {ok, {function,_Anno,yeccpars1,7,_Clauses}} ->
             {1,4};
         {eof,_Line} ->
             {1,1};
@@ -2503,7 +2506,7 @@ pp_tokens(Tokens, Line0, Enc) ->
 pp_tokens1([], _Line0, _Enc, _T0) ->
     [];
 pp_tokens1([T | Ts], Line0, Enc, T0) ->
-    Line = element(2, T),
+    Line = location(anno(T)),
     [pp_sep(Line, Line0, T0), pp_symbol(T, Enc)|pp_tokens1(Ts, Line, Enc, T)].
 
 pp_symbol({var,_,Var}, _Enc) -> Var;
@@ -2538,10 +2541,17 @@ output_file_directive(St, _Filename, _Line) ->
     St.
 
 first_line(Tokens) ->
-    element(2, hd(Tokens)).
+    location(anno(hd(Tokens))).
 
 last_line(Tokens) ->
-    element(2, lists:last(Tokens)).
+    location(anno(lists:last(Tokens))).
+
+location(none) -> none;
+location(Anno) ->
+    erl_anno:line(Anno).
+
+anno(Token) ->
+    element(2, Token).
 
 %% Keep track of the current line in the generated file.
 fwrite(#yecc{outport = Outport, line = Line}=St, Format, Args) ->
diff --git a/lib/parsetools/src/yeccgramm.yrl b/lib/parsetools/src/yeccgramm.yrl
index c7b2ef6a8..40aa85a43 100644
--- a/lib/parsetools/src/yeccgramm.yrl
+++ b/lib/parsetools/src/yeccgramm.yrl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 1996-2015. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2017. All Rights Reserved.
 %% 
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -39,43 +39,38 @@ rule -> head '->' symbols attached_code dot: {rule, ['$1' | '$3'], '$4'}.
 head -> symbol : '$1'.
 symbols -> symbol : ['$1'].
 symbols -> symbol symbols : ['$1' | '$2'].
-strings -> string : [string('$1')].
-strings -> string strings : [string('$1') | '$2'].
+strings -> string : ['$1'].
+strings -> string strings : ['$1' | '$2'].
 attached_code -> ':' tokens : {erlang_code, '$2'}.
-attached_code -> '$empty' : {erlang_code, [{atom, 0, '$undefined'}]}.
+attached_code -> '$empty' : {erlang_code,
+                             [{atom, erl_anno:new(0), '$undefined'}]}.
 tokens -> token : ['$1'].
 tokens -> token tokens : ['$1' | '$2'].
 symbol -> var : symbol('$1').
 symbol -> atom : symbol('$1').
 symbol -> integer : symbol('$1').
 symbol -> reserved_word : symbol('$1').
-token -> var : token('$1').
-token -> atom : token('$1').
-token -> float : token('$1').
-token -> integer : token('$1').
-token -> string : token('$1').
-token -> char : token('$1').
-token -> reserved_symbol : {value_of('$1'), line_of('$1')}.
-token -> reserved_word : {value_of('$1'), line_of('$1')}.
-token -> '->' : {'->', line_of('$1')}. % Have to be treated in this
-token -> ':' : {':', line_of('$1')}.   % manner, because they are also
-				       % special symbols of the metagrammar
+token -> var : '$1'.
+token -> atom : '$1'.
+token -> float : '$1'.
+token -> integer : '$1'.
+token -> string : '$1'.
+token -> char : '$1'.
+token -> reserved_symbol : {value_of('$1'), anno_of('$1')}.
+token -> reserved_word : {value_of('$1'), anno_of('$1')}.
+token -> '->' : {'->', anno_of('$1')}. % Have to be treated in this
+token -> ':' : {':', anno_of('$1')}.   % manner, because they are also
+                                       % special symbols of the metagrammar
 
 Erlang code.
 
--record(symbol, {line, name}).
+-record(symbol, {anno, name}).
 
 symbol(Symbol) ->
-    #symbol{line = line_of(Symbol), name = value_of(Symbol)}.
-
-token(Token) ->
-    setelement(2, Token, line_of(Token)).
-
-string(Token) ->
-    setelement(2, Token, line_of(Token)).
+    #symbol{anno = anno_of(Symbol), name = value_of(Symbol)}.
 
 value_of(Token) ->
     element(3, Token).
 
-line_of(Token) ->
-    erl_anno:line(element(2, Token)).
+anno_of(Token) ->
+    element(2, Token).
diff --git a/lib/parsetools/src/yeccparser.erl b/lib/parsetools/src/yeccparser.erl
index 0025284cc..6f6f66d56 100644
--- a/lib/parsetools/src/yeccparser.erl
+++ b/lib/parsetools/src/yeccparser.erl
@@ -1,29 +1,23 @@
 -module(yeccparser).
 -export([parse/1, parse_and_scan/1, format_error/1]).
--file("yeccgramm.yrl", 63).
+-file("yeccgramm.yrl", 65).
 
--record(symbol, {line, name}).
+-record(symbol, {anno, name}).
 
 symbol(Symbol) ->
-    #symbol{line = line_of(Symbol), name = value_of(Symbol)}.
-
-token(Token) ->
-    setelement(2, Token, line_of(Token)).
-
-string(Token) ->
-    setelement(2, Token, line_of(Token)).
+    #symbol{anno = anno_of(Symbol), name = value_of(Symbol)}.
 
 value_of(Token) ->
     element(3, Token).
 
-line_of(Token) ->
-    erl_anno:line(element(2, Token)).
+anno_of(Token) ->
+    element(2, Token).
 
--file("lib/parsetools/include/yeccpre.hrl", 0).
+-file("/ldisk/hasse/otp/lib/parsetools/include/yeccpre.hrl", 0).
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2015. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2017. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -147,21 +141,10 @@ yecc_end(Line) ->
     {'$end', Line}.
 
 yecctoken_end_location(Token) ->
-    try
-        Str = erl_scan:text(Token),
-        Line = erl_scan:line(Token),
-        Parts = re:split(Str, "\n"),
-        Dline = length(Parts) - 1,
-        Yline = Line + Dline,
-        case erl_scan:column(Token) of
-            Column when is_integer(Column) ->
-                Col = byte_size(lists:last(Parts)),
-                {Yline, Col + if Dline =:= 0 -> Column; true -> 1 end};
-            undefined ->
-                Yline
-        end
-    catch _:_ ->
-        yecctoken_location(Token)
+    try erl_anno:end_location(element(2, Token)) of
+        undefined -> yecctoken_location(Token);
+        Loc -> Loc
+    catch _:_ -> yecctoken_location(Token)
     end.
 
 -compile({nowarn_unused_function, yeccerror/1}).
@@ -172,15 +155,15 @@ yeccerror(Token) ->
 
 -compile({nowarn_unused_function, yecctoken_to_string/1}).
 yecctoken_to_string(Token) ->
-    case catch erl_scan:text(Token) of
-        Txt when is_list(Txt) -> Txt;
-        _ -> yecctoken2string(Token)
+    try erl_scan:text(Token) of
+        undefined -> yecctoken2string(Token);
+        Txt -> Txt
+    catch _:_ -> yecctoken2string(Token)
     end.
 
 yecctoken_location(Token) ->
-    case catch erl_scan:location(Token) of
-        Loc when Loc =/= undefined -> Loc;
-        _ -> element(2, Token)
+    try erl_scan:location(Token)
+    catch _:_ -> element(2, Token)
     end.
 
 -compile({nowarn_unused_function, yecctoken2string/1}).
@@ -204,8 +187,9 @@ yecctoken2string(Other) ->
 
 
 
--file("yeccgramm.erl", 207).
+-file("yeccgramm.erl", 190).
 
+-dialyzer({nowarn_function, yeccpars2/7}).
 yeccpars2(0=S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_0(S, Cat, Ss, Stack, T, Ts, Tzr);
 %% yeccpars2(1=S, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -281,6 +265,7 @@ yeccpars2(35=S, Cat, Ss, Stack, T, Ts, Tzr) ->
 yeccpars2(Other, _, _, _, _, _, _) ->
  erlang:error({yecc_bug,"1.4",{missing_state_in_action_table, Other}}).
 
+-dialyzer({nowarn_function, yeccpars2_0/7}).
 yeccpars2_0(S, atom, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 6, Ss, Stack, T, Ts, Tzr);
 yeccpars2_0(S, integer, Ss, Stack, T, Ts, Tzr) ->
@@ -308,11 +293,13 @@ yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
 yeccpars2_2(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_grammar(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccpars2_3/7}).
 yeccpars2_3(S, '->', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 10, Ss, Stack, T, Ts, Tzr);
 yeccpars2_3(_, _, _, _, T, _, _) ->
  yeccerror(T).
 
+-dialyzer({nowarn_function, yeccpars2_4/7}).
 yeccpars2_4(_S, '$end', _Ss, Stack, _T, _Ts, _Tzr) ->
  {ok, hd(Stack)};
 yeccpars2_4(_, _, _, _, T, _, _) ->
@@ -362,11 +349,13 @@ yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_13_(Stack),
  yeccgoto_symbols(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccpars2_14/7}).
 yeccpars2_14(S, dot, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 29, Ss, Stack, T, Ts, Tzr);
 yeccpars2_14(_, _, _, _, T, _, _) ->
  yeccerror(T).
 
+-dialyzer({nowarn_function, yeccpars2_15/7}).
 yeccpars2_15(S, '->', Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 18, Ss, Stack, T, Ts, Tzr);
 yeccpars2_15(S, ':', Ss, Stack, T, Ts, Tzr) ->
@@ -428,20 +417,16 @@ yeccpars2_19(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_20(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_20_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_21(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_21_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_22_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_23(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_23_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_24_(Stack),
@@ -452,12 +437,10 @@ yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
 
 yeccpars2_26(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_26_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_27(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
- NewStack = yeccpars2_27_(Stack),
- yeccgoto_token(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr).
+ yeccgoto_token(hd(Ss), Cat, Ss, Stack, T, Ts, Tzr).
 
 yeccpars2_28(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  [_|Nss] = Ss,
@@ -469,11 +452,13 @@ yeccpars2_29(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_29_(Stack),
  yeccgoto_rule(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccpars2_30/7}).
 yeccpars2_30(S, dot, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 35, Ss, Stack, T, Ts, Tzr);
 yeccpars2_30(_, _, _, _, T, _, _) ->
  yeccerror(T).
 
+-dialyzer({nowarn_function, yeccpars2_31/7}).
 yeccpars2_31(S, dot, Ss, Stack, T, Ts, Tzr) ->
  yeccpars1(S, 34, Ss, Stack, T, Ts, Tzr);
 yeccpars2_31(_, _, _, _, T, _, _) ->
@@ -500,26 +485,33 @@ yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  NewStack = yeccpars2_35_(Stack),
  yeccgoto_declaration(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_attached_code/7}).
 yeccgoto_attached_code(11, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_14(14, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_declaration/7}).
 yeccgoto_declaration(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_grammar/7}).
 yeccgoto_grammar(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_4(4, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_head/7}).
 yeccgoto_head(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_3(3, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_rule/7}).
 yeccgoto_rule(0=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_2(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_strings/7}).
 yeccgoto_strings(1, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_31(31, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_strings(32=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_symbol/7}).
 yeccgoto_symbol(0, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_symbol(1, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -529,6 +521,7 @@ yeccgoto_symbol(10, Cat, Ss, Stack, T, Ts, Tzr) ->
 yeccgoto_symbol(12, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_12(12, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_symbols/7}).
 yeccgoto_symbols(1, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_symbols(10, Cat, Ss, Stack, T, Ts, Tzr) ->
@@ -536,18 +529,20 @@ yeccgoto_symbols(10, Cat, Ss, Stack, T, Ts, Tzr) ->
 yeccgoto_symbols(12=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_token/7}).
 yeccgoto_token(15, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_17(17, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_token(17, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_17(17, Cat, Ss, Stack, T, Ts, Tzr).
 
+-dialyzer({nowarn_function, yeccgoto_tokens/7}).
 yeccgoto_tokens(15=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_16(_S, Cat, Ss, Stack, T, Ts, Tzr);
 yeccgoto_tokens(17=_S, Cat, Ss, Stack, T, Ts, Tzr) ->
  yeccpars2_28(_S, Cat, Ss, Stack, T, Ts, Tzr).
 
 -compile({inline,yeccpars2_6_/1}).
--file("yeccgramm.yrl", 44).
+-file("yeccgramm.yrl", 46).
 yeccpars2_6_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -555,7 +550,7 @@ yeccpars2_6_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_7_/1}).
--file("yeccgramm.yrl", 45).
+-file("yeccgramm.yrl", 47).
 yeccpars2_7_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -563,7 +558,7 @@ yeccpars2_7_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_8_/1}).
--file("yeccgramm.yrl", 46).
+-file("yeccgramm.yrl", 48).
 yeccpars2_8_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -571,7 +566,7 @@ yeccpars2_8_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_9_/1}).
--file("yeccgramm.yrl", 43).
+-file("yeccgramm.yrl", 45).
 yeccpars2_9_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -579,14 +574,15 @@ yeccpars2_9_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_11_/1}).
--file("yeccgramm.yrl", 40).
+-file("yeccgramm.yrl", 41).
 yeccpars2_11_(__Stack0) ->
  [begin
-   { erlang_code , [ { atom , 0 , '$undefined' } ] }
+   { erlang_code ,
+    [ { atom , erl_anno : new ( 0 ) , '$undefined' } ] }
   end | __Stack0].
 
 -compile({inline,yeccpars2_12_/1}).
--file("yeccgramm.yrl", 35).
+-file("yeccgramm.yrl", 36).
 yeccpars2_12_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -594,7 +590,7 @@ yeccpars2_12_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_13_/1}).
--file("yeccgramm.yrl", 36).
+-file("yeccgramm.yrl", 37).
 yeccpars2_13_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -602,7 +598,7 @@ yeccpars2_13_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_16_/1}).
--file("yeccgramm.yrl", 39).
+-file("yeccgramm.yrl", 40).
 yeccpars2_16_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -610,7 +606,7 @@ yeccpars2_16_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_17_/1}).
--file("yeccgramm.yrl", 41).
+-file("yeccgramm.yrl", 43).
 yeccpars2_17_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
@@ -618,87 +614,39 @@ yeccpars2_17_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_18_/1}).
--file("yeccgramm.yrl", 55).
+-file("yeccgramm.yrl", 57).
 yeccpars2_18_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
-   { '->' , line_of ( __1 ) }
+   { '->' , anno_of ( __1 ) }
   end | __Stack].
 
 -compile({inline,yeccpars2_19_/1}).
--file("yeccgramm.yrl", 56).
+-file("yeccgramm.yrl", 58).
 yeccpars2_19_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
-   { ':' , line_of ( __1 ) }
-  end | __Stack].
-
--compile({inline,yeccpars2_20_/1}).
--file("yeccgramm.yrl", 48).
-yeccpars2_20_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
-  end | __Stack].
-
--compile({inline,yeccpars2_21_/1}).
--file("yeccgramm.yrl", 52).
-yeccpars2_21_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
-  end | __Stack].
-
--compile({inline,yeccpars2_22_/1}).
--file("yeccgramm.yrl", 49).
-yeccpars2_22_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
-  end | __Stack].
-
--compile({inline,yeccpars2_23_/1}).
--file("yeccgramm.yrl", 50).
-yeccpars2_23_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
+   { ':' , anno_of ( __1 ) }
   end | __Stack].
 
 -compile({inline,yeccpars2_24_/1}).
--file("yeccgramm.yrl", 53).
+-file("yeccgramm.yrl", 55).
 yeccpars2_24_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
-   { value_of ( __1 ) , line_of ( __1 ) }
+   { value_of ( __1 ) , anno_of ( __1 ) }
   end | __Stack].
 
 -compile({inline,yeccpars2_25_/1}).
--file("yeccgramm.yrl", 54).
+-file("yeccgramm.yrl", 56).
 yeccpars2_25_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
-   { value_of ( __1 ) , line_of ( __1 ) }
-  end | __Stack].
-
--compile({inline,yeccpars2_26_/1}).
--file("yeccgramm.yrl", 51).
-yeccpars2_26_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
-  end | __Stack].
-
--compile({inline,yeccpars2_27_/1}).
--file("yeccgramm.yrl", 47).
-yeccpars2_27_(__Stack0) ->
- [__1 | __Stack] = __Stack0,
- [begin
-   token ( __1 )
+   { value_of ( __1 ) , anno_of ( __1 ) }
   end | __Stack].
 
 -compile({inline,yeccpars2_28_/1}).
--file("yeccgramm.yrl", 42).
+-file("yeccgramm.yrl", 44).
 yeccpars2_28_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
@@ -706,7 +654,7 @@ yeccpars2_28_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_29_/1}).
--file("yeccgramm.yrl", 33).
+-file("yeccgramm.yrl", 34).
 yeccpars2_29_(__Stack0) ->
  [__5,__4,__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -714,23 +662,23 @@ yeccpars2_29_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_32_/1}).
--file("yeccgramm.yrl", 37).
+-file("yeccgramm.yrl", 38).
 yeccpars2_32_(__Stack0) ->
  [__1 | __Stack] = __Stack0,
  [begin
-   [ string ( __1 ) ]
+   [ __1 ]
   end | __Stack].
 
 -compile({inline,yeccpars2_33_/1}).
--file("yeccgramm.yrl", 38).
+-file("yeccgramm.yrl", 39).
 yeccpars2_33_(__Stack0) ->
  [__2,__1 | __Stack] = __Stack0,
  [begin
-   [ string ( __1 ) | __2 ]
+   [ __1 | __2 ]
   end | __Stack].
 
 -compile({inline,yeccpars2_34_/1}).
--file("yeccgramm.yrl", 32).
+-file("yeccgramm.yrl", 33).
 yeccpars2_34_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -738,7 +686,7 @@ yeccpars2_34_(__Stack0) ->
   end | __Stack].
 
 -compile({inline,yeccpars2_35_/1}).
--file("yeccgramm.yrl", 31).
+-file("yeccgramm.yrl", 32).
 yeccpars2_35_(__Stack0) ->
  [__3,__2,__1 | __Stack] = __Stack0,
  [begin
@@ -746,4 +694,4 @@ yeccpars2_35_(__Stack0) ->
   end | __Stack].
 
 
--file("yeccgramm.yrl", 82).
+-file("yeccgramm.yrl", 77).
diff --git a/lib/parsetools/test/yecc_SUITE.erl b/lib/parsetools/test/yecc_SUITE.erl
index 5bd71d5d1..2c37278d4 100644
--- a/lib/parsetools/test/yecc_SUITE.erl
+++ b/lib/parsetools/test/yecc_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2005-2016. All Rights Reserved.
+%% Copyright Ericsson AB 2005-2017. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -1524,7 +1524,7 @@ otp_7945(suite) -> [];
 otp_7945(Config) when is_list(Config) ->
     A2 = erl_anno:new(2),
     A3 = erl_anno:new(3),
-    {error,_} = erl_parse:parse([{atom,3,foo},{'.',A2,9,9}]),
+    {error,_} = erl_parse:parse([{atom,A3,foo},{'.',A2,9,9}]),
     ok.
 
 otp_8483(doc) ->
-- 
2.12.0

Places

File 2544-parsetools-Fix-handling-of-locations-and-annotations.patch of Package erlang (Revision 3fbb28c0756b0c6ee7bbab1611cc9dcf)

Places