struct attributes_needed<address_of_generator> : std::integral_constant<int, 1> {};
}
-address_of_generator const address_of;
+address_of_generator const address_of = {};
} } }
{
return {f};
}
-} const attribute_conditional;
+} const attribute_conditional = {};
namespace type_traits {
template <typename F, typename G>
{
return {f};
}
-} const attribute_replace;
+} const attribute_replace = {};
namespace type_traits {
template <typename F, typename G>
namespace attributes {
struct unused_type {};
-unused_type const unused;
+unused_type const unused = {};
template <int N, typename Tuple, typename Enable = void>
struct tuple_element;
struct attributes_needed<base_class_definition_generator> : std::integral_constant<int, 1> {};
}
-base_class_definition_generator const base_class_definition;
+base_class_definition_generator const base_class_definition = {};
} } }
struct attributes_needed<c_type_generator> : std::integral_constant<int, 1> {};
}
-c_type_generator const c_type;
+c_type_generator const c_type = {};
} } }
{
return lower_case_generator<G>{g};
}
-} const lower_case;
+} const lower_case = {};
struct upper_case_directive
{
{
return upper_case_generator<G>{g};
}
-} const upper_case;
+} const upper_case = {};
} } }
struct attributes_needed<class_declaration_generator> : std::integral_constant<int, 1> {};
}
-class_declaration_generator const class_declaration;
+class_declaration_generator const class_declaration = {};
} } }
struct attributes_needed<class_definition_generator> : std::integral_constant<int, 1> {};
}
-class_definition_generator const class_definition;
+class_definition_generator const class_definition = {};
} } }
struct attributes_needed<class_implementation_generator> : std::integral_constant<int, 1> {};
}
-class_implementation_generator const class_implementation;
+class_implementation_generator const class_implementation = {};
} } }
struct attributes_needed<converting_argument_generator> : std::integral_constant<int, 1> {};
}
-converting_argument_generator const converting_argument;
+converting_argument_generator const converting_argument = {};
} } }
template <>
struct is_eager_generator<eps_generator> : std::true_type {};
-eps_generator const eps;
+eps_generator const eps = {};
} } }
struct attributes_needed<function_declaration_generator> : std::integral_constant<int, 1> {};
}
-function_declaration_generator const function_declaration;
+function_declaration_generator const function_declaration = {};
} } }
{
return function_definition_generator{name};
}
-} const function_definition;
+} const function_definition = {};
} } }
}
};
-header_guards_directive const header_guards;
+header_guards_directive const header_guards = {};
} } }
struct attributes_needed<header_include_directive_generator> : std::integral_constant<int, 1> {};
}
-header_include_directive_generator const header_include_directive;
+header_include_directive_generator const header_include_directive = {};
} } }
struct attributes_needed<implementation_include_directive_generator> : std::integral_constant<int, 1> {};
}
-implementation_include_directive_generator const implementation_include_directive;
+implementation_include_directive_generator const implementation_include_directive = {};
} } }
{
return scope_tab_generator(n);
}
-} const scope_tab;
+} const scope_tab = {};
template <>
struct is_generator<scope_tab_terminal> : std::true_type {};
{
return namespaces_generator<G>{g};
}
-} const namespaces;
+} const namespaces = {};
template <typename G>
struct is_eager_generator<namespaces_generator<G>> : std::true_type {};
struct attributes_needed<parameter_type_generator> : std::integral_constant<int, 1> {};
}
-parameter_type_generator const parameter_type;
+parameter_type_generator const parameter_type = {};
struct parameter_generator
{
template <>
struct attributes_needed<parameter_generator> : std::integral_constant<int, 1> {};
}
-parameter_generator const parameter;
+parameter_generator const parameter = {};
} } }
{
return literal_generator(literal);
}
-} const lit;
+} const lit = {};
// string
struct string_generator
{
return specific_string_generator{string};
}
-} const string;
+} const string = {};
struct string_replace_terminal
{
{
return string_replace_generator{from, to};
}
-} const string_replace;
+} const string_replace = {};
template <>
struct is_generator<string_generator_terminal> : std::true_type {};
struct attributes_needed<type_generator> : std::integral_constant<int, 1> {};
}
-type_generator const type;
+type_generator const type = {};
} } }