reader/wgsl: Allow trailing commas in lists
Also allows empty constexpr type constructors.
Fixed: tint:739
Change-Id: Ic4729c13b6ac538491d5d1d3c7960e78fac80127
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/49443
Commit-Queue: James Price <jrprice@google.com>
Auto-Submit: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index 6f75fde..d303610 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc
@@ -1416,16 +1416,16 @@
// param_list
// :
-// | (param COMMA)* param
+// | (param COMMA)* param COMMA?
Expect<ast::VariableList> ParserImpl::expect_param_list() {
- // Check for an empty list.
- auto t = peek();
- if (!t.IsIdentifier() && !t.IsAttrLeft()) {
- return ast::VariableList{};
- }
-
ast::VariableList ret;
while (synchronized_) {
+ // Check for the end of the list.
+ auto t = peek();
+ if (!t.IsIdentifier() && !t.IsAttrLeft()) {
+ break;
+ }
+
auto param = expect_param();
if (param.errored)
return Failure::kErrored;
@@ -1912,34 +1912,26 @@
}
// case_selectors
-// : const_literal (COMMA const_literal)*
+// : const_literal (COMMA const_literal)* COMMA?
Expect<ast::CaseSelectorList> ParserImpl::expect_case_selectors() {
ast::CaseSelectorList selectors;
- for (;;) {
- auto t = peek();
- auto matched_comma = match(Token::Type::kComma);
-
- if (selectors.empty() && matched_comma)
- return add_error(t, "a selector is expected before the comma");
- if (matched_comma)
- t = peek();
-
+ while (synchronized_) {
auto cond = const_literal();
- if (cond.errored)
+ if (cond.errored) {
return Failure::kErrored;
- if (!cond.matched) {
- if (matched_comma) {
- return add_error(t, "a selector is expected after the comma");
- }
+ } else if (!cond.matched) {
break;
+ } else if (!cond->Is<ast::IntLiteral>()) {
+ return add_error(cond.value->source(),
+ "invalid case selector must be an integer value");
}
- if (!cond->Is<ast::IntLiteral>())
- return add_error(t, "invalid case selector must be an integer value");
- if (!selectors.empty() && !matched_comma)
- return add_error(t, "expected a comma after the previous selector");
selectors.push_back(cond.value->As<ast::IntLiteral>());
+
+ if (!match(Token::Type::kComma)) {
+ break;
+ }
}
if (selectors.empty())
@@ -2305,25 +2297,18 @@
}
// argument_expression_list
-// : PAREN_LEFT (logical_or_expression COMMA)* logical_or_expression
+// : PAREN_LEFT ((logical_or_expression COMMA)* logical_or_expression COMMA?)?
// PAREN_RIGHT
Expect<ast::ExpressionList> ParserImpl::expect_argument_expression_list(
const std::string& use) {
return expect_paren_block(use, [&]() -> Expect<ast::ExpressionList> {
- // Check for empty list.
- // TODO(crbug.com/tint/739): Remove this (handled by !arg.matched).
- if (peek().IsParenRight()) {
- return ast::ExpressionList{};
- }
-
ast::ExpressionList ret;
while (synchronized_) {
auto arg = logical_or_expression();
- if (arg.errored)
+ if (arg.errored) {
return Failure::kErrored;
- if (!arg.matched) {
- // TODO(crbug.com/tint/739): remove error to allow trailing commas.
- return add_error(peek(), "unable to parse argument expression");
+ } else if (!arg.matched) {
+ break;
}
ret.push_back(arg.value);
@@ -2838,7 +2823,7 @@
}
// const_expr
-// : type_decl PAREN_LEFT (const_expr COMMA)? const_expr PAREN_RIGHT
+// : type_decl PAREN_LEFT ((const_expr COMMA)? const_expr COMMA?)? PAREN_RIGHT
// | const_literal
Expect<ast::ConstructorExpression*> ParserImpl::expect_const_expr() {
auto t = peek();
@@ -2852,15 +2837,20 @@
auto params = expect_paren_block("type constructor",
[&]() -> Expect<ast::ExpressionList> {
ast::ExpressionList list;
- auto param = expect_const_expr();
- if (param.errored)
- return Failure::kErrored;
- list.emplace_back(param.value);
- while (match(Token::Type::kComma)) {
- param = expect_const_expr();
- if (param.errored)
+ while (synchronized_) {
+ if (peek().IsParenRight()) {
+ break;
+ }
+
+ auto arg = expect_const_expr();
+ if (arg.errored) {
return Failure::kErrored;
- list.emplace_back(param.value);
+ }
+ list.emplace_back(arg.value);
+
+ if (!match(Token::Type::kComma)) {
+ break;
+ }
}
return list;
});
diff --git a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
index ca8ed6c..bb73660 100644
--- a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
+++ b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
@@ -50,6 +50,17 @@
ASSERT_TRUE(e.value[2]->Is<ast::BinaryExpression>());
}
+TEST_F(ParserImplTest, ArgumentExpressionList_TrailingComma) {
+ auto p = parser("(a, 42,)");
+ auto e = p->expect_argument_expression_list("argument list");
+ ASSERT_FALSE(p->has_error()) << p->error();
+ ASSERT_FALSE(e.errored);
+
+ ASSERT_EQ(e.value.size(), 2u);
+ ASSERT_TRUE(e.value[0]->Is<ast::IdentifierExpression>());
+ ASSERT_TRUE(e.value[1]->Is<ast::ConstructorExpression>());
+}
+
TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingLeftParen) {
auto p = parser("a)");
auto e = p->expect_argument_expression_list("argument list");
@@ -66,12 +77,20 @@
EXPECT_EQ(p->error(), "1:3: expected ')' for argument list");
}
-TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingExpression) {
- auto p = parser("(a, )");
+TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingExpression_0) {
+ auto p = parser("(,)");
auto e = p->expect_argument_expression_list("argument list");
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(e.errored);
- EXPECT_EQ(p->error(), "1:5: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:2: expected ')' for argument list");
+}
+
+TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingExpression_1) {
+ auto p = parser("(a, ,)");
+ auto e = p->expect_argument_expression_list("argument list");
+ ASSERT_TRUE(p->has_error());
+ ASSERT_TRUE(e.errored);
+ EXPECT_EQ(p->error(), "1:5: expected ')' for argument list");
}
TEST_F(ParserImplTest, ArgumentExpressionList_HandlesInvalidExpression) {
@@ -79,7 +98,7 @@
auto e = p->expect_argument_expression_list("argument list");
ASSERT_TRUE(p->has_error());
ASSERT_TRUE(e.errored);
- EXPECT_EQ(p->error(), "1:2: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:2: expected ')' for argument list");
}
} // namespace
diff --git a/src/reader/wgsl/parser_impl_call_stmt_test.cc b/src/reader/wgsl/parser_impl_call_stmt_test.cc
index 3a4d206..ec41195 100644
--- a/src/reader/wgsl/parser_impl_call_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_call_stmt_test.cc
@@ -59,13 +59,33 @@
EXPECT_TRUE(c->params()[2]->Is<ast::BinaryExpression>());
}
+TEST_F(ParserImplTest, Statement_Call_WithParams_TrailingComma) {
+ auto p = parser("a(1, b,);");
+ auto e = p->statement();
+ ASSERT_FALSE(p->has_error()) << p->error();
+ ASSERT_NE(e.value, nullptr);
+ EXPECT_TRUE(e.matched);
+ EXPECT_FALSE(e.errored);
+
+ ASSERT_TRUE(e->Is<ast::CallStatement>());
+ auto* c = e->As<ast::CallStatement>()->expr();
+
+ ASSERT_TRUE(c->func()->Is<ast::IdentifierExpression>());
+ auto* ident = c->func()->As<ast::IdentifierExpression>();
+ EXPECT_EQ(ident->symbol(), p->builder().Symbols().Get("a"));
+
+ EXPECT_EQ(c->params().size(), 2u);
+ EXPECT_TRUE(c->params()[0]->Is<ast::ConstructorExpression>());
+ EXPECT_TRUE(c->params()[1]->Is<ast::IdentifierExpression>());
+}
+
TEST_F(ParserImplTest, Statement_Call_Missing_RightParen) {
auto p = parser("a(");
auto e = p->statement();
EXPECT_TRUE(p->has_error());
EXPECT_TRUE(e.errored);
EXPECT_FALSE(e.matched);
- EXPECT_EQ(p->error(), "1:3: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:3: expected ')' for function call");
}
TEST_F(ParserImplTest, Statement_Call_Missing_Semi) {
diff --git a/src/reader/wgsl/parser_impl_const_expr_test.cc b/src/reader/wgsl/parser_impl_const_expr_test.cc
index 8498ed4..00a053c 100644
--- a/src/reader/wgsl/parser_impl_const_expr_test.cc
+++ b/src/reader/wgsl/parser_impl_const_expr_test.cc
@@ -47,6 +47,38 @@
EXPECT_FLOAT_EQ(c->literal()->As<ast::FloatLiteral>()->value(), 2.);
}
+TEST_F(ParserImplTest, ConstExpr_TypeDecl_Empty) {
+ auto p = parser("vec2<f32>()");
+ auto e = p->expect_const_expr();
+ ASSERT_FALSE(p->has_error()) << p->error();
+ ASSERT_FALSE(e.errored);
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
+
+ auto* t = e->As<ast::TypeConstructorExpression>();
+ ASSERT_TRUE(t->type()->Is<sem::Vector>());
+ EXPECT_EQ(t->type()->As<sem::Vector>()->size(), 2u);
+
+ ASSERT_EQ(t->values().size(), 0u);
+}
+
+TEST_F(ParserImplTest, ConstExpr_TypeDecl_TrailingComma) {
+ auto p = parser("vec2<f32>(1., 2.,)");
+ auto e = p->expect_const_expr();
+ ASSERT_FALSE(p->has_error()) << p->error();
+ ASSERT_FALSE(e.errored);
+ ASSERT_TRUE(e->Is<ast::ConstructorExpression>());
+ ASSERT_TRUE(e->Is<ast::TypeConstructorExpression>());
+
+ auto* t = e->As<ast::TypeConstructorExpression>();
+ ASSERT_TRUE(t->type()->Is<sem::Vector>());
+ EXPECT_EQ(t->type()->As<sem::Vector>()->size(), 2u);
+
+ ASSERT_EQ(t->values().size(), 2u);
+ ASSERT_TRUE(t->values()[0]->Is<ast::ScalarConstructorExpression>());
+ ASSERT_TRUE(t->values()[1]->Is<ast::ScalarConstructorExpression>());
+}
+
TEST_F(ParserImplTest, ConstExpr_TypeDecl_MissingRightParen) {
auto p = parser("vec2<f32>(1., 2.");
auto e = p->expect_const_expr();
@@ -65,15 +97,6 @@
EXPECT_EQ(p->error(), "1:11: expected '(' for type constructor");
}
-TEST_F(ParserImplTest, ConstExpr_TypeDecl_HangingComma) {
- auto p = parser("vec2<f32>(1.,)");
- auto e = p->expect_const_expr();
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(e.errored);
- ASSERT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:14: unable to parse constant literal");
-}
-
TEST_F(ParserImplTest, ConstExpr_TypeDecl_MissingComma) {
auto p = parser("vec2<f32>(1. 2.");
auto e = p->expect_const_expr();
@@ -83,15 +106,6 @@
EXPECT_EQ(p->error(), "1:14: expected ')' for type constructor");
}
-TEST_F(ParserImplTest, ConstExpr_MissingExpr) {
- auto p = parser("vec2<f32>()");
- auto e = p->expect_const_expr();
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(e.errored);
- ASSERT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:11: unable to parse constant literal");
-}
-
TEST_F(ParserImplTest, ConstExpr_InvalidExpr) {
auto p = parser("vec2<f32>(1., if(a) {})");
auto e = p->expect_const_expr();
diff --git a/src/reader/wgsl/parser_impl_error_msg_test.cc b/src/reader/wgsl/parser_impl_error_msg_test.cc
index 17d5cd4..bca27f3 100644
--- a/src/reader/wgsl/parser_impl_error_msg_test.cc
+++ b/src/reader/wgsl/parser_impl_error_msg_test.cc
@@ -137,14 +137,14 @@
TEST_F(ParserImplErrorTest, CallStmtInvalidArgument0) {
EXPECT("fn f() { f(<); }",
- "test.wgsl:1:12 error: unable to parse argument expression\n"
+ "test.wgsl:1:12 error: expected ')' for function call\n"
"fn f() { f(<); }\n"
" ^\n");
}
TEST_F(ParserImplErrorTest, CallStmtInvalidArgument1) {
EXPECT("fn f() { f(1.0, <); }",
- "test.wgsl:1:17 error: unable to parse argument expression\n"
+ "test.wgsl:1:17 error: expected ')' for function call\n"
"fn f() { f(1.0, <); }\n"
" ^\n");
}
@@ -446,9 +446,9 @@
}
TEST_F(ParserImplErrorTest, FunctionDeclParamMissing) {
- EXPECT("fn f(x : i32, ) {}",
- "test.wgsl:1:15 error: expected identifier for parameter\n"
- "fn f(x : i32, ) {}\n"
+ EXPECT("fn f(x : i32, ,) {}",
+ "test.wgsl:1:15 error: expected ')' for function declaration\n"
+ "fn f(x : i32, ,) {}\n"
" ^\n");
}
diff --git a/src/reader/wgsl/parser_impl_for_stmt_test.cc b/src/reader/wgsl/parser_impl_for_stmt_test.cc
index e82521d..5b72897 100644
--- a/src/reader/wgsl/parser_impl_for_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_for_stmt_test.cc
@@ -250,7 +250,7 @@
// Test a for loop with an invalid continuing statement.
TEST_F(ForStmtErrorTest, InvalidContinuingAsFuncCall) {
std::string for_str = "for (;; a(,) ) { }";
- std::string error_str = "1:11: unable to parse argument expression";
+ std::string error_str = "1:11: expected ')' for function call";
TestForWithError(for_str, error_str);
}
diff --git a/src/reader/wgsl/parser_impl_function_header_test.cc b/src/reader/wgsl/parser_impl_function_header_test.cc
index fba796e..f509264 100644
--- a/src/reader/wgsl/parser_impl_function_header_test.cc
+++ b/src/reader/wgsl/parser_impl_function_header_test.cc
@@ -33,6 +33,18 @@
EXPECT_TRUE(f->return_type->Is<sem::Void>());
}
+TEST_F(ParserImplTest, FunctionHeader_TrailingComma) {
+ auto p = parser("fn main(a :i32,)");
+ auto f = p->function_header();
+ EXPECT_TRUE(f.matched);
+ EXPECT_FALSE(f.errored);
+
+ EXPECT_EQ(f->name, "main");
+ ASSERT_EQ(f->params.size(), 1u);
+ EXPECT_EQ(f->params[0]->symbol(), p->builder().Symbols().Get("a"));
+ EXPECT_TRUE(f->return_type->Is<sem::Void>());
+}
+
TEST_F(ParserImplTest, FunctionHeader_DecoratedReturnType) {
auto p = parser("fn main() -> [[location(1)]] f32");
auto f = p->function_header();
@@ -77,12 +89,12 @@
}
TEST_F(ParserImplTest, FunctionHeader_InvalidParamList) {
- auto p = parser("fn main(a :i32,) -> i32");
+ auto p = parser("fn main(a :i32, ,) -> i32");
auto f = p->function_header();
EXPECT_FALSE(f.matched);
EXPECT_TRUE(f.errored);
EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:16: expected identifier for parameter");
+ EXPECT_EQ(p->error(), "1:17: expected ')' for function declaration");
}
TEST_F(ParserImplTest, FunctionHeader_MissingParenRight) {
diff --git a/src/reader/wgsl/parser_impl_param_list_test.cc b/src/reader/wgsl/parser_impl_param_list_test.cc
index 54e30bd..60c97d2 100644
--- a/src/reader/wgsl/parser_impl_param_list_test.cc
+++ b/src/reader/wgsl/parser_impl_param_list_test.cc
@@ -87,12 +87,12 @@
EXPECT_EQ(e.value.size(), 0u);
}
-TEST_F(ParserImplTest, ParamList_HangingComma) {
+TEST_F(ParserImplTest, ParamList_TrailingComma) {
auto p = parser("a : i32,");
auto e = p->expect_param_list();
- ASSERT_TRUE(p->has_error());
- ASSERT_TRUE(e.errored);
- EXPECT_EQ(p->error(), "1:9: expected identifier for parameter");
+ ASSERT_FALSE(p->has_error());
+ ASSERT_FALSE(e.errored);
+ EXPECT_EQ(e.value.size(), 1u);
}
TEST_F(ParserImplTest, ParamList_Decorations) {
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index 884f1c4..dac0e80 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -121,7 +121,7 @@
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
ASSERT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:5: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:5: expected ')' for type constructor");
}
TEST_F(ParserImplTest, PrimaryExpression_TypeDecl_StructConstructor_Empty) {
diff --git a/src/reader/wgsl/parser_impl_singular_expression_test.cc b/src/reader/wgsl/parser_impl_singular_expression_test.cc
index 2d40f24..d74d1bf 100644
--- a/src/reader/wgsl/parser_impl_singular_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_singular_expression_test.cc
@@ -128,6 +128,18 @@
EXPECT_TRUE(c->params()[2]->Is<ast::BinaryExpression>());
}
+TEST_F(ParserImplTest, SingularExpression_Call_TrailingComma) {
+ auto p = parser("a(b, )");
+ auto e = p->singular_expression();
+ EXPECT_TRUE(e.matched);
+ EXPECT_FALSE(e.errored);
+ ASSERT_NE(e.value, nullptr);
+
+ ASSERT_TRUE(e->Is<ast::CallExpression>());
+ auto* c = e->As<ast::CallExpression>();
+ EXPECT_EQ(c->params().size(), 1u);
+}
+
TEST_F(ParserImplTest, SingularExpression_Call_InvalidArg) {
auto p = parser("a(if(a) {})");
auto e = p->singular_expression();
@@ -135,17 +147,7 @@
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:3: unable to parse argument expression");
-}
-
-TEST_F(ParserImplTest, SingularExpression_Call_HangingComma) {
- auto p = parser("a(b, )");
- auto e = p->singular_expression();
- EXPECT_FALSE(e.matched);
- EXPECT_TRUE(e.errored);
- EXPECT_EQ(e.value, nullptr);
- EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:6: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:3: expected ')' for function call");
}
TEST_F(ParserImplTest, SingularExpression_Call_MissingRightParen) {
@@ -155,7 +157,7 @@
EXPECT_TRUE(e.errored);
EXPECT_EQ(e.value, nullptr);
EXPECT_TRUE(p->has_error());
- EXPECT_EQ(p->error(), "1:3: unable to parse argument expression");
+ EXPECT_EQ(p->error(), "1:3: expected ')' for function call");
}
TEST_F(ParserImplTest, SingularExpression_MemberAccessor) {
diff --git a/src/reader/wgsl/parser_impl_switch_body_test.cc b/src/reader/wgsl/parser_impl_switch_body_test.cc
index 39f33b4..99d3899 100644
--- a/src/reader/wgsl/parser_impl_switch_body_test.cc
+++ b/src/reader/wgsl/parser_impl_switch_body_test.cc
@@ -28,10 +28,28 @@
ASSERT_NE(e.value, nullptr);
ASSERT_TRUE(e->Is<ast::CaseStatement>());
EXPECT_FALSE(e->IsDefault());
+ auto* stmt = e->As<ast::CaseStatement>();
+ ASSERT_EQ(stmt->selectors().size(), 1u);
+ EXPECT_EQ(stmt->selectors()[0]->value_as_u32(), 1u);
ASSERT_EQ(e->body()->size(), 1u);
EXPECT_TRUE(e->body()->get(0)->Is<ast::AssignmentStatement>());
}
+TEST_F(ParserImplTest, SwitchBody_Case_TrailingComma) {
+ auto p = parser("case 1, 2,: { }");
+ auto e = p->switch_body();
+ EXPECT_FALSE(p->has_error()) << p->error();
+ EXPECT_TRUE(e.matched);
+ EXPECT_FALSE(e.errored);
+ ASSERT_NE(e.value, nullptr);
+ ASSERT_TRUE(e->Is<ast::CaseStatement>());
+ EXPECT_FALSE(e->IsDefault());
+ auto* stmt = e->As<ast::CaseStatement>();
+ ASSERT_EQ(stmt->selectors().size(), 2u);
+ EXPECT_EQ(stmt->selectors()[0]->value_as_u32(), 1u);
+ EXPECT_EQ(stmt->selectors()[1]->value_as_u32(), 2u);
+}
+
TEST_F(ParserImplTest, SwitchBody_Case_InvalidConstLiteral) {
auto p = parser("case a == 4: { a = 4; }");
auto e = p->switch_body();
@@ -134,17 +152,7 @@
EXPECT_TRUE(e.errored);
EXPECT_FALSE(e.matched);
EXPECT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:8: expected a comma after the previous selector");
-}
-
-TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectorsEndsWithComma) {
- auto p = parser("case 1, 2,: { }");
- auto e = p->switch_body();
- EXPECT_TRUE(p->has_error());
- EXPECT_TRUE(e.errored);
- EXPECT_FALSE(e.matched);
- EXPECT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:11: a selector is expected after the comma");
+ EXPECT_EQ(p->error(), "1:8: expected ':' for case statement");
}
TEST_F(ParserImplTest, SwitchBody_Case_MultipleSelectorsStartsWithComma) {
@@ -154,7 +162,7 @@
EXPECT_TRUE(e.errored);
EXPECT_FALSE(e.matched);
EXPECT_EQ(e.value, nullptr);
- EXPECT_EQ(p->error(), "1:6: a selector is expected before the comma");
+ EXPECT_EQ(p->error(), "1:6: unable to parse case selectors");
}
TEST_F(ParserImplTest, SwitchBody_Default) {
