Regenerate files after merge

SyntaxTree/tree/SyntaxTreeStreamReader.cs

@@ -464,6 +464,18 @@ namespace PascalABCCompiler.SyntaxTree
 					return new sugared_addressed_value();
 				case 221:
 					return new double_question_node();
+				case 222:
+					return new pattern_node();
+				case 223:
+					return new type_pattern();
+				case 224:
+					return new is_pattern_expr();
+				case 225:
+					return new match_with();
+				case 226:
+					return new pattern_case();
+				case 227:
+					return new pattern_cases();
 			}
 			return null;
 		}
@@ -3919,6 +3931,93 @@ namespace PascalABCCompiler.SyntaxTree
 			_double_question_node.right = _read_node() as expression;
 		}
 
+
+		public void visit(pattern_node _pattern_node)
+		{
+			read_pattern_node(_pattern_node);
+		}
+
+		public void read_pattern_node(pattern_node _pattern_node)
+		{
+			read_syntax_tree_node(_pattern_node);
+		}
+
+
+		public void visit(type_pattern _type_pattern)
+		{
+			read_type_pattern(_type_pattern);
+		}
+
+		public void read_type_pattern(type_pattern _type_pattern)
+		{
+			read_pattern_node(_type_pattern);
+			_type_pattern.identifier = _read_node() as ident;
+			_type_pattern.type = _read_node() as type_definition;
+		}
+
+
+		public void visit(is_pattern_expr _is_pattern_expr)
+		{
+			read_is_pattern_expr(_is_pattern_expr);
+		}
+
+		public void read_is_pattern_expr(is_pattern_expr _is_pattern_expr)
+		{
+			read_expression(_is_pattern_expr);
+			_is_pattern_expr.left = _read_node() as expression;
+			_is_pattern_expr.right = _read_node() as pattern_node;
+		}
+
+
+		public void visit(match_with _match_with)
+		{
+			read_match_with(_match_with);
+		}
+
+		public void read_match_with(match_with _match_with)
+		{
+			read_statement(_match_with);
+			_match_with.expr = _read_node() as expression;
+			_match_with.case_list = _read_node() as pattern_cases;
+		}
+
+
+		public void visit(pattern_case _pattern_case)
+		{
+			read_pattern_case(_pattern_case);
+		}
+
+		public void read_pattern_case(pattern_case _pattern_case)
+		{
+			read_statement(_pattern_case);
+			_pattern_case.pattern = _read_node() as pattern_node;
+			_pattern_case.case_action = _read_node() as statement;
+		}
+
+
+		public void visit(pattern_cases _pattern_cases)
+		{
+			read_pattern_cases(_pattern_cases);
+		}
+
+		public void read_pattern_cases(pattern_cases _pattern_cases)
+		{
+			read_statement(_pattern_cases);
+			if (br.ReadByte() == 0)
+			{
+				_pattern_cases.elements = null;
+			}
+			else
+			{
+				_pattern_cases.elements = new List<pattern_case>();
+				Int32 ssyy_count = br.ReadInt32();
+				for(Int32 ssyy_i = 0; ssyy_i < ssyy_count; ssyy_i++)
+				{
+					_pattern_cases.elements.Add(_read_node() as pattern_case);
+				}
+			}
+		}
+
 	}
 
 

SyntaxTree/tree/SyntaxTreeStreamWriter.cs

@@ -6138,6 +6138,171 @@ namespace PascalABCCompiler.SyntaxTree
 			}
 		}
 
+
+		public void visit(pattern_node _pattern_node)
+		{
+			bw.Write((Int16)222);
+			write_pattern_node(_pattern_node);
+		}
+
+		public void write_pattern_node(pattern_node _pattern_node)
+		{
+			write_syntax_tree_node(_pattern_node);
+		}
+
+
+		public void visit(type_pattern _type_pattern)
+		{
+			bw.Write((Int16)223);
+			write_type_pattern(_type_pattern);
+		}
+
+		public void write_type_pattern(type_pattern _type_pattern)
+		{
+			write_pattern_node(_type_pattern);
+			if (_type_pattern.identifier == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_type_pattern.identifier.visit(this);
+			}
+			if (_type_pattern.type == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_type_pattern.type.visit(this);
+			}
+		}
+
+
+		public void visit(is_pattern_expr _is_pattern_expr)
+		{
+			bw.Write((Int16)224);
+			write_is_pattern_expr(_is_pattern_expr);
+		}
+
+		public void write_is_pattern_expr(is_pattern_expr _is_pattern_expr)
+		{
+			write_expression(_is_pattern_expr);
+			if (_is_pattern_expr.left == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_is_pattern_expr.left.visit(this);
+			}
+			if (_is_pattern_expr.right == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_is_pattern_expr.right.visit(this);
+			}
+		}
+
+
+		public void visit(match_with _match_with)
+		{
+			bw.Write((Int16)225);
+			write_match_with(_match_with);
+		}
+
+		public void write_match_with(match_with _match_with)
+		{
+			write_statement(_match_with);
+			if (_match_with.expr == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_match_with.expr.visit(this);
+			}
+			if (_match_with.case_list == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_match_with.case_list.visit(this);
+			}
+		}
+
+
+		public void visit(pattern_case _pattern_case)
+		{
+			bw.Write((Int16)226);
+			write_pattern_case(_pattern_case);
+		}
+
+		public void write_pattern_case(pattern_case _pattern_case)
+		{
+			write_statement(_pattern_case);
+			if (_pattern_case.pattern == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_pattern_case.pattern.visit(this);
+			}
+			if (_pattern_case.case_action == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				_pattern_case.case_action.visit(this);
+			}
+		}
+
+
+		public void visit(pattern_cases _pattern_cases)
+		{
+			bw.Write((Int16)227);
+			write_pattern_cases(_pattern_cases);
+		}
+
+		public void write_pattern_cases(pattern_cases _pattern_cases)
+		{
+			write_statement(_pattern_cases);
+			if (_pattern_cases.elements == null)
+			{
+				bw.Write((byte)0);
+			}
+			else
+			{
+				bw.Write((byte)1);
+				bw.Write(_pattern_cases.elements.Count);
+				for(Int32 ssyy_i = 0; ssyy_i < _pattern_cases.elements.Count; ssyy_i++)
+				{
+					if (_pattern_cases.elements[ssyy_i] == null)
+					{
+						bw.Write((byte)0);
+					}
+					else
+					{
+						bw.Write((byte)1);
+						_pattern_cases.elements[ssyy_i].visit(this);
+					}
+				}
+			}
+		}
+
 	}
 
 

SyntaxTree/tree/Visitor.cs

@@ -1336,6 +1336,42 @@ namespace PascalABCCompiler.SyntaxTree
 		///<param name="_double_question_node">Node to visit</param>
 		///<returns> Return value is void </returns>
 		void visit(double_question_node _double_question_node);
+		///<summary>
+		///Method to visit pattern_node.
+		///</summary>
+		///<param name="_pattern_node">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(pattern_node _pattern_node);
+		///<summary>
+		///Method to visit type_pattern.
+		///</summary>
+		///<param name="_type_pattern">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(type_pattern _type_pattern);
+		///<summary>
+		///Method to visit is_pattern_expr.
+		///</summary>
+		///<param name="_is_pattern_expr">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(is_pattern_expr _is_pattern_expr);
+		///<summary>
+		///Method to visit match_with.
+		///</summary>
+		///<param name="_match_with">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(match_with _match_with);
+		///<summary>
+		///Method to visit pattern_case.
+		///</summary>
+		///<param name="_pattern_case">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(pattern_case _pattern_case);
+		///<summary>
+		///Method to visit pattern_cases.
+		///</summary>
+		///<param name="_pattern_cases">Node to visit</param>
+		///<returns> Return value is void </returns>
+		void visit(pattern_cases _pattern_cases);
 	}