Hello community,

here is the log from the commit of package stringtemplate4 for openSUSE:Factory 
checked in at 2020-11-19 16:46:45
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/stringtemplate4 (Old)
 and      /work/SRC/openSUSE:Factory/.stringtemplate4.new.5913 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "stringtemplate4"

Thu Nov 19 16:46:45 2020 rev:4 rq:849421 version:4.3

Changes:
--------
--- /work/SRC/openSUSE:Factory/stringtemplate4/stringtemplate4.changes  
2019-11-26 16:58:50.116118257 +0100
+++ 
/work/SRC/openSUSE:Factory/.stringtemplate4.new.5913/stringtemplate4.changes    
    2020-11-23 10:51:00.642633494 +0100
@@ -1,0 +2,8 @@
+Thu Jun  4 07:14:18 UTC 2020 - Fridrich Strba <[email protected]>
+
+- Ugrade to version 4.3
+- Modified patch:
+  * stringtemplate4-generated-sources.patch
+    + regenerate
+
+-------------------------------------------------------------------

Old:
----
  4.2.tar.gz

New:
----
  4.3.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ stringtemplate4.spec ++++++
--- /var/tmp/diff_new_pack.UHtKR0/_old  2020-11-23 10:51:01.350634202 +0100
+++ /var/tmp/diff_new_pack.UHtKR0/_new  2020-11-23 10:51:01.354634206 +0100
@@ -1,7 +1,7 @@
 #
 # spec file for package stringtemplate4
 #
-# Copyright (c) 2019 SUSE LLC
+# Copyright (c) 2020 SUSE LLC
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -23,7 +23,7 @@
 %bcond_with bootstrap
 %endif
 %global base_name stringtemplate4
-Version:        4.2
+Version:        4.3
 Release:        0
 Summary:        A Java template engine
 License:        BSD-3-Clause

++++++ 4.2.tar.gz -> 4.3.tar.gz ++++++
++++ 27560 lines of diff (skipped)

++++++ stringtemplate4-generated-sources.patch ++++++
--- /var/tmp/diff_new_pack.UHtKR0/_old  2020-11-23 10:51:01.534634386 +0100
+++ /var/tmp/diff_new_pack.UHtKR0/_new  2020-11-23 10:51:01.534634386 +0100
@@ -1,5 +1,5 @@
 --- src/CodeGenerator.tokens   1970-01-01 01:00:00.000000000 +0100
-+++ src/CodeGenerator.tokens   2019-11-03 12:55:49.169482828 +0100
++++ src/CodeGenerator.tokens   2020-04-02 15:05:32.083265957 +0200
 @@ -0,0 +1,79 @@
 +RBRACK=17
 +LBRACK=16
@@ -81,7 +81,7 @@
 +'@end'=34
 +'/'=38
 --- src/Group.tokens   1970-01-01 01:00:00.000000000 +0100
-+++ src/Group.tokens   2019-11-03 12:55:49.169482828 +0100
++++ src/Group.tokens   2020-04-02 15:05:32.083265957 +0200
 @@ -0,0 +1,44 @@
 +T__16=16
 +T__17=17
@@ -128,9 +128,9 @@
 +'import'=29
 +'true'=14
 --- src/org/stringtemplate/v4/compiler/CodeGenerator.java      1970-01-01 
01:00:00.000000000 +0100
-+++ src/org/stringtemplate/v4/compiler/CodeGenerator.java      2019-11-03 
12:55:49.169482828 +0100
++++ src/org/stringtemplate/v4/compiler/CodeGenerator.java      2020-04-02 
15:05:32.083265957 +0200
 @@ -0,0 +1,2595 @@
-+// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/CodeGenerator.g 2019-11-03 
11:54:31
++// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/CodeGenerator.g 2020-04-02 
13:04:44
 +
 +/*
 + * [The "BSD license"]
@@ -2726,9 +2726,9 @@
 +      public static final BitSet FOLLOW_NULL_in_listElement1095 = new 
BitSet(new long[]{0x0000000000000002L});
 +}
 --- src/org/stringtemplate/v4/compiler/GroupLexer.java 1970-01-01 
01:00:00.000000000 +0100
-+++ src/org/stringtemplate/v4/compiler/GroupLexer.java 2019-11-03 
12:55:49.169482828 +0100
++++ src/org/stringtemplate/v4/compiler/GroupLexer.java 2020-04-02 
15:05:32.083265957 +0200
 @@ -0,0 +1,1310 @@
-+// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/Group.g 2019-11-03 11:54:31
++// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/Group.g 2020-04-02 13:04:44
 +
 +/*
 + * [The "BSD license"]
@@ -4039,9 +4039,9 @@
 +
 +}
 --- src/org/stringtemplate/v4/compiler/GroupParser.java        1970-01-01 
01:00:00.000000000 +0100
-+++ src/org/stringtemplate/v4/compiler/GroupParser.java        2019-11-03 
12:55:49.169482828 +0100
++++ src/org/stringtemplate/v4/compiler/GroupParser.java        2020-04-02 
15:05:32.083265957 +0200
 @@ -0,0 +1,1420 @@
-+// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/Group.g 2019-11-03 11:54:31
++// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/Group.g 2020-04-02 13:04:44
 +
 +/*
 + * [The "BSD license"]
@@ -5462,9 +5462,9 @@
 +      public static final BitSet FOLLOW_ID_in_keyValue768 = new BitSet(new 
long[]{0x0000000000000002L});
 +}
 --- src/org/stringtemplate/v4/compiler/STParser.java   1970-01-01 
01:00:00.000000000 +0100
-+++ src/org/stringtemplate/v4/compiler/STParser.java   2019-11-03 
12:55:49.169482828 +0100
-@@ -0,0 +1,5574 @@
-+// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/STParser.g 2019-11-03 11:54:30
++++ src/org/stringtemplate/v4/compiler/STParser.java   2020-04-02 
15:05:32.083265957 +0200
+@@ -0,0 +1,5613 @@
++// $ANTLR 3.5.2 org/stringtemplate/v4/compiler/STParser.g 2020-04-02 13:04:43
 +
 +package org.stringtemplate.v4.compiler;
 +import org.stringtemplate.v4.misc.ErrorManager;
@@ -5625,6 +5625,7 @@
 +                      
EOF2=(CommonToken)match(input,EOF,FOLLOW_EOF_in_templateAndEOF141);  
 +                      stream_EOF.add(EOF2);
 +
++
 +                      // AST REWRITE
 +                      // elements: template
 +                      // token labels: 
@@ -6096,6 +6097,7 @@
 +                                      
NEWLINE6=(CommonToken)match(input,NEWLINE,FOLLOW_NEWLINE_in_element173);  
 +                                      stream_NEWLINE.add(NEWLINE6);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: 
 +                                      // token labels: 
@@ -6128,8 +6130,9 @@
 +                                      state._fsp--;
 +
 +                                      
stream_singleElement.add(singleElement8.getTree());
++
 +                                      // AST REWRITE
-+                                      // elements: singleElement, INDENT
++                                      // elements: INDENT, singleElement
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -6537,8 +6540,9 @@
 +                      
RDELIM21=(CommonToken)match(input,RDELIM,FOLLOW_RDELIM_in_exprTag273);  
 +                      stream_RDELIM.add(RDELIM21);
 +
++
 +                      // AST REWRITE
-+                      // elements: exprOptions, expr
++                      // elements: expr, exprOptions
 +                      // token labels: 
 +                      // rule labels: retval
 +                      // token list labels: 
@@ -6726,8 +6730,9 @@
 +
 +                      }
 +
++
 +                      // AST REWRITE
-+                      // elements: i, ID, template, ID, template
++                      // elements: ID, template, template, ID, i
 +                      // token labels: i
 +                      // rule labels: retval
 +                      // token list labels: 
@@ -6927,6 +6932,7 @@
 +                      
char_literal35=(CommonToken)match(input,RCURLY,FOLLOW_RCURLY_in_subtemplate450);
  
 +                      stream_RCURLY.add(char_literal35);
 +
++
 +                      // AST REWRITE
 +                      // elements: template, ids
 +                      // token labels: 
@@ -7310,8 +7316,9 @@
 +
 +                      }
 +
++
 +                      // AST REWRITE
-+                      // elements: t1, ELSE, c2, c1, c1, IF, t2, IF, ELSE, 
c2, i, t3, ELSEIF, t1, ELSEIF, t3, t2
++                      // elements: ELSE, IF, c2, i, ELSE, IF, c2, c1, ELSEIF, 
t3, t3, t1, ELSEIF, c1, t2, t2, t1
 +                      // token labels: i
 +                      // rule labels: t1, c1, retval, t3
 +                      // token list labels: 
@@ -7345,7 +7352,7 @@
 +                              stream_t1.reset();
 +
 +                              // 
org/stringtemplate/v4/compiler/STParser.g:129:41: ( ^( 'elseif' $c2 $t2) )*
-+                              while ( 
stream_c2.hasNext()||stream_ELSEIF.hasNext()||stream_t2.hasNext() ) {
++                              while ( 
stream_ELSEIF.hasNext()||stream_t2.hasNext()||stream_c2.hasNext() ) {
 +                                      // 
org/stringtemplate/v4/compiler/STParser.g:129:41: ^( 'elseif' $c2 $t2)
 +                                      {
 +                                      CommonTree root_3 = 
(CommonTree)adaptor.nil();
@@ -7356,9 +7363,9 @@
 +                                      }
 +
 +                              }
-+                              stream_c2.reset();
 +                              stream_ELSEIF.reset();
 +                              stream_t2.reset();
++                              stream_c2.reset();
 +
 +                              // 
org/stringtemplate/v4/compiler/STParser.g:129:62: ( ^( 'else' ( $t3)? ) )?
 +                              if ( stream_ELSE.hasNext()||stream_t3.hasNext() 
) {
@@ -7767,6 +7774,7 @@
 +                      
ID64=(CommonToken)match(input,ID,FOLLOW_ID_in_notConditionalExpr773);  
 +                      stream_ID.add(ID64);
 +
++
 +                      // AST REWRITE
 +                      // elements: ID
 +                      // token labels: 
@@ -7814,6 +7822,7 @@
 +                                      
prop=(CommonToken)match(input,ID,FOLLOW_ID_in_notConditionalExpr788);  
 +                                      stream_ID.add(prop);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: prop, notConditionalExpr
 +                                      // token labels: prop
@@ -7861,8 +7870,9 @@
 +                                      
char_literal67=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_notConditionalExpr820);
  
 +                                      stream_RPAREN.add(char_literal67);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: mapExpr, notConditionalExpr
++                                      // elements: notConditionalExpr, mapExpr
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -7976,6 +7986,7 @@
 +                              }
 +                      }
 +
++
 +                      // AST REWRITE
 +                      // elements: option
 +                      // token labels: 
@@ -8096,8 +8107,9 @@
 +                                      state._fsp--;
 +
 +                                      
stream_exprNoComma.add(exprNoComma73.getTree());
++
 +                                      // AST REWRITE
-+                                      // elements: ID, exprNoComma, EQUALS
++                                      // elements: ID, EQUALS, exprNoComma
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -8138,6 +8150,7 @@
 +                                                                      
errMgr.compileTimeError(ErrorType.NO_DEFAULT_VALUE, templateToken, ID71);
 +                                                              }
 +                                                              
++
 +                                      // AST REWRITE
 +                                      // elements: ID
 +                                      // token labels: 
@@ -8255,6 +8268,7 @@
 +                                      state._fsp--;
 +
 +                                      
stream_mapTemplateRef.add(mapTemplateRef76.getTree());
++
 +                                      // AST REWRITE
 +                                      // elements: memberExpr, mapTemplateRef
 +                                      // token labels: 
@@ -8287,6 +8301,7 @@
 +                              case 2 :
 +                                      // 
org/stringtemplate/v4/compiler/STParser.g:184:14: 
 +                                      {
++
 +                                      // AST REWRITE
 +                                      // elements: memberExpr
 +                                      // token labels: 
@@ -8481,8 +8496,9 @@
 +                                      state._fsp--;
 +
 +                                      
stream_mapTemplateRef.add(mapTemplateRef80.getTree());
++
 +                                      // AST REWRITE
-+                                      // elements: mapTemplateRef, memberExpr
++                                      // elements: memberExpr, mapTemplateRef
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -8527,6 +8543,7 @@
 +                              case 2 :
 +                                      // 
org/stringtemplate/v4/compiler/STParser.g:196:14: 
 +                                      {
++
 +                                      // AST REWRITE
 +                                      // elements: memberExpr
 +                                      // token labels: 
@@ -8609,6 +8626,7 @@
 +                                              }
 +                                      }
 +
++
 +                                      // AST REWRITE
 +                                      // elements: mapExpr, x
 +                                      // token labels: 
@@ -8755,8 +8773,9 @@
 +                                      
char_literal85=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_mapTemplateRef1216);
  
 +                                      stream_RPAREN.add(char_literal85);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: args, qualifiedId
++                                      // elements: qualifiedId, args
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -8846,8 +8865,9 @@
 +                                      
char_literal90=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_mapTemplateRef1258);
  
 +                                      stream_RPAREN.add(char_literal90);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: mapExpr, argExprList
++                                      // elements: argExprList, mapExpr
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -8944,6 +8964,7 @@
 +                      state._fsp--;
 +
 +                      stream_includeExpr.add(includeExpr91.getTree());
++
 +                      // AST REWRITE
 +                      // elements: includeExpr
 +                      // token labels: 
@@ -8991,6 +9012,7 @@
 +                                      
ID92=(CommonToken)match(input,ID,FOLLOW_ID_in_memberExpr1294);  
 +                                      stream_ID.add(ID92);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ID, memberExpr
 +                                      // token labels: 
@@ -9037,6 +9059,7 @@
 +                                      
char_literal95=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_memberExpr1326);
  
 +                                      stream_RPAREN.add(char_literal95);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: mapExpr, memberExpr
 +                                      // token labels: 
@@ -9282,8 +9305,9 @@
 +                                      
char_literal99=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_includeExpr1377);
  
 +                                      stream_RPAREN.add(char_literal99);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: expr, ID
++                                      // elements: ID, expr
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -9339,6 +9363,7 @@
 +                                      
char_literal105=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_includeExpr1408);
  
 +                                      stream_RPAREN.add(char_literal105);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ID, args
 +                                      // token labels: 
@@ -9392,8 +9417,9 @@
 +                                      
char_literal109=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_includeExpr1433);
  
 +                                      stream_RPAREN.add(char_literal109);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: qualifiedId, args
++                                      // elements: args, qualifiedId
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -9447,6 +9473,7 @@
 +                                      
rp=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_includeExpr1464);  
 +                                      stream_RPAREN.add(rp);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ID
 +                                      // token labels: 
@@ -9490,6 +9517,7 @@
 +                                      
rp=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_includeExpr1487);  
 +                                      stream_RPAREN.add(rp);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ID
 +                                      // token labels: 
@@ -9804,8 +9832,9 @@
 +                                                      
char_literal132=(CommonToken)match(input,RPAREN,FOLLOW_RPAREN_in_primary1581);  
 +                                                      
stream_RPAREN.add(char_literal132);
 +
++
 +                                                      // AST REWRITE
-+                                                      // elements: expr, 
argExprList
++                                                      // elements: 
argExprList, expr
 +                                                      // token labels: 
 +                                                      // rule labels: retval
 +                                                      // token list labels: 
@@ -9841,6 +9870,7 @@
 +                                              case 2 :
 +                                                      // 
org/stringtemplate/v4/compiler/STParser.g:243:14: 
 +                                                      {
++
 +                                                      // AST REWRITE
 +                                                      // elements: expr
 +                                                      // token labels: 
@@ -9949,6 +9979,7 @@
 +                                      
ID133=(CommonToken)match(input,ID,FOLLOW_ID_in_qualifiedId1641);  
 +                                      stream_ID.add(ID133);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ID
 +                                      // token labels: 
@@ -9979,8 +10010,9 @@
 +                                      
ID135=(CommonToken)match(input,ID,FOLLOW_ID_in_qualifiedId1661);  
 +                                      stream_ID.add(ID135);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: ID, SLASH
++                                      // elements: SLASH, ID
 +                                      // token labels: 
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -10029,8 +10061,9 @@
 +                                      
r=(CommonToken)match(input,ID,FOLLOW_ID_in_qualifiedId1690);  
 +                                      stream_ID.add(r);
 +
++
 +                                      // AST REWRITE
-+                                      // elements: r, SLASH, qualifiedId
++                                      // elements: qualifiedId, SLASH, r
 +                                      // token labels: r
 +                                      // rule labels: retval
 +                                      // token list labels: 
@@ -10237,6 +10270,7 @@
 +
 +                                      }
 +
++
 +                                      // AST REWRITE
 +                                      // elements: ELLIPSIS, namedArg
 +                                      // token labels: 
@@ -10371,6 +10405,7 @@
 +                              }
 +                      }
 +
++
 +                      // AST REWRITE
 +                      // elements: arg
 +                      // token labels: 
@@ -10506,8 +10541,9 @@
 +                      state._fsp--;
 +
 +                      stream_arg.add(arg150.getTree());
++
 +                      // AST REWRITE
-+                      // elements: arg, EQUALS, ID
++                      // elements: ID, arg, EQUALS
 +                      // token labels: 
 +                      // rule labels: retval
 +                      // token list labels: 
@@ -10636,6 +10672,7 @@
 +                                      
char_literal151=(CommonToken)match(input,RBRACK,FOLLOW_RBRACK_in_list1837);  
 +                                      stream_RBRACK.add(char_literal151);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: 
 +                                      // token labels: 
@@ -10700,6 +10737,7 @@
 +                                      
char_literal155=(CommonToken)match(input,RBRACK,FOLLOW_RBRACK_in_list1862);  
 +                                      stream_RBRACK.add(char_literal155);
 +
++
 +                                      // AST REWRITE
 +                                      // elements: listElement
 +                                      // token labels: 
@@ -10808,6 +10846,7 @@
 +                              case 2 :
 +                                      // 
org/stringtemplate/v4/compiler/STParser.g:272:29: 
 +                                      {
++
 +                                      // AST REWRITE
 +                                      // elements: 
 +                                      // token labels: 
@@ -11039,7 +11078,7 @@
 +      public static final BitSet FOLLOW_exprNoComma_in_listElement1882 = new 
BitSet(new long[]{0x0000000000000002L});
 +}
 --- src/STParser.tokens        1970-01-01 01:00:00.000000000 +0100
-+++ src/STParser.tokens        2019-11-03 12:55:49.169482828 +0100
++++ src/STParser.tokens        2020-04-02 15:05:32.083265957 +0200
 @@ -0,0 +1,79 @@
 +RBRACK=17
 +LBRACK=16
_______________________________________________
openSUSE Commits mailing list -- [email protected]
To unsubscribe, email [email protected]
List Netiquette: https://en.opensuse.org/openSUSE:Mailing_list_netiquette
List Archives: 
https://lists.opensuse.org/archives/list/[email protected]

Reply via email to